diff --git a/compiler/rustc_ast_lowering/src/path.rs b/compiler/rustc_ast_lowering/src/path.rs
index 46dac2f1af4f4..82a0983e2a1a3 100644
--- a/compiler/rustc_ast_lowering/src/path.rs
+++ b/compiler/rustc_ast_lowering/src/path.rs
@@ -24,6 +24,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
param_mode: ParamMode,
mut itctx: ImplTraitContext<'_, 'hir>,
) -> hir::QPath<'hir> {
+ debug!("lower_qpath(id: {:?}, qself: {:?}, p: {:?})", id, qself, p);
let qself_position = qself.as_ref().map(|q| q.position);
let qself = qself.as_ref().map(|q| self.lower_ty(&q.ty, itctx.reborrow()));
@@ -222,6 +223,10 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
itctx: ImplTraitContext<'_, 'hir>,
explicit_owner: Option<NodeId>,
) -> hir::PathSegment<'hir> {
+ debug!(
+ "path_span: {:?}, lower_path_segment(segment: {:?}, expected_lifetimes: {:?})",
+ path_span, segment, expected_lifetimes
+ );
let (mut generic_args, infer_args) = if let Some(ref generic_args) = segment.args {
let msg = "parenthesized type parameters may only be used with a `Fn` trait";
match **generic_args {
diff --git a/compiler/rustc_middle/src/middle/resolve_lifetime.rs b/compiler/rustc_middle/src/middle/resolve_lifetime.rs
index aa6488b329eba..2665ea8d7fd73 100644
--- a/compiler/rustc_middle/src/middle/resolve_lifetime.rs
+++ b/compiler/rustc_middle/src/middle/resolve_lifetime.rs
@@ -49,6 +49,20 @@ pub enum Region {
Free(DefId, /* lifetime decl */ DefId),
}
+/// This is used in diagnostics to improve suggestions for missing generic arguments.
+/// It gives information on the type of lifetimes that are in scope for a particular `PathSegment`,
+/// so that we can e.g. suggest elided-lifetimes-in-paths of the form <'_, '_> e.g.
+#[derive(Clone, PartialEq, Eq, Hash, TyEncodable, TyDecodable, Debug, HashStable)]
+pub enum LifetimeScopeForPath {
+ // Contains all lifetime names that are in scope and could possibly be used in generics
+ // arguments of path.
+ NonElided(Vec<String>),
+
+ // Information that allows us to suggest args of the form `<'_>` in case
+ // no generic arguments were provided for a path.
+ Elided,
+}
+
/// A set containing, at most, one known element.
/// If two distinct values are inserted into a set, then it
/// becomes `Many`, which can be used to detect ambiguities.
diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs
index 3ffc3641b62aa..3c5440f5b6859 100644
--- a/compiler/rustc_middle/src/query/mod.rs
+++ b/compiler/rustc_middle/src/query/mod.rs
@@ -1301,6 +1301,10 @@ rustc_queries! {
desc { "looking up late bound vars" }
}
+ query lifetime_scope_map(_: LocalDefId) -> Option<FxHashMap<ItemLocalId, LifetimeScopeForPath>> {
+ desc { "finds the lifetime scope for an HirId of a PathSegment" }
+ }
+
query visibility(def_id: DefId) -> ty::Visibility {
eval_always
desc { |tcx| "computing visibility of `{}`", tcx.def_path_str(def_id) }
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index 10f7cc87c7c7c..eaf0887c4e7fe 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -9,7 +9,7 @@ use crate::infer::canonical::{Canonical, CanonicalVarInfo, CanonicalVarInfos};
use crate::lint::{struct_lint_level, LintDiagnosticBuilder, LintLevelSource};
use crate::middle;
use crate::middle::cstore::{CrateStoreDyn, EncodedMetadata};
-use crate::middle::resolve_lifetime::{self, ObjectLifetimeDefault};
+use crate::middle::resolve_lifetime::{self, LifetimeScopeForPath, ObjectLifetimeDefault};
use crate::middle::stability;
use crate::mir::interpret::{self, Allocation, ConstValue, Scalar};
use crate::mir::{Body, Field, Local, Place, PlaceElem, ProjectionKind, Promoted};
@@ -2686,6 +2686,10 @@ impl<'tcx> TyCtxt<'tcx> {
.iter(),
)
}
+
+ pub fn lifetime_scope(self, id: HirId) -> Option<LifetimeScopeForPath> {
+ self.lifetime_scope_map(id.owner).and_then(|mut map| map.remove(&id.local_id))
+ }
}
impl TyCtxtAt<'tcx> {
diff --git a/compiler/rustc_middle/src/ty/query/mod.rs b/compiler/rustc_middle/src/ty/query/mod.rs
index 068f81486118a..3c772a14647c8 100644
--- a/compiler/rustc_middle/src/ty/query/mod.rs
+++ b/compiler/rustc_middle/src/ty/query/mod.rs
@@ -9,7 +9,9 @@ use crate::middle::exported_symbols::{ExportedSymbol, SymbolExportLevel};
use crate::middle::lib_features::LibFeatures;
use crate::middle::privacy::AccessLevels;
use crate::middle::region;
-use crate::middle::resolve_lifetime::{ObjectLifetimeDefault, Region, ResolveLifetimes};
+use crate::middle::resolve_lifetime::{
+ LifetimeScopeForPath, ObjectLifetimeDefault, Region, ResolveLifetimes,
+};
use crate::middle::stability::{self, DeprecationEntry};
use crate::mir;
use crate::mir::interpret::GlobalId;
diff --git a/compiler/rustc_resolve/src/late/lifetimes.rs b/compiler/rustc_resolve/src/late/lifetimes.rs
index e8d21af435887..bf69defb4e674 100644
--- a/compiler/rustc_resolve/src/late/lifetimes.rs
+++ b/compiler/rustc_resolve/src/late/lifetimes.rs
@@ -8,11 +8,11 @@
use crate::late::diagnostics::{ForLifetimeSpanType, MissingLifetimeSpot};
use rustc_ast::walk_list;
-use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap};
use rustc_errors::{struct_span_err, Applicability, DiagnosticBuilder};
use rustc_hir as hir;
use rustc_hir::def::{DefKind, Res};
-use rustc_hir::def_id::DefIdMap;
+use rustc_hir::def_id::{DefIdMap, LocalDefId};
use rustc_hir::hir_id::ItemLocalId;
use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
use rustc_hir::{GenericArg, GenericParam, LifetimeName, Node, ParamName, QPath};
@@ -22,7 +22,7 @@ use rustc_middle::middle::resolve_lifetime::*;
use rustc_middle::ty::{self, DefIdTree, GenericParamDefKind, TyCtxt};
use rustc_middle::{bug, span_bug};
use rustc_session::lint;
-use rustc_span::def_id::{DefId, LocalDefId};
+use rustc_span::def_id::DefId;
use rustc_span::symbol::{kw, sym, Ident, Symbol};
use rustc_span::Span;
use std::borrow::Cow;
@@ -158,6 +158,9 @@ struct NamedRegionMap {
// - trait refs
// - bound types (like `T` in `for<'a> T<'a>: Foo`)
late_bound_vars: HirIdMap<Vec<ty::BoundVariableKind>>,
+
+ // maps `PathSegment` `HirId`s to lifetime scopes.
+ scope_for_path: Option<FxHashMap<LocalDefId, FxHashMap<ItemLocalId, LifetimeScopeForPath>>>,
}
crate struct LifetimeContext<'a, 'tcx> {
@@ -195,7 +198,9 @@ enum Scope<'a> {
/// it should be shifted by the number of `Binder`s in between the
/// declaration `Binder` and the location it's referenced from.
Binder {
- lifetimes: FxHashMap<hir::ParamName, Region>,
+ /// We use an IndexMap here because we want these lifetimes in order
+ /// for diagnostics.
+ lifetimes: FxIndexMap<hir::ParamName, Region>,
/// if we extend this scope with another scope, what is the next index
/// we should use for an early-bound region?
@@ -379,6 +384,10 @@ pub fn provide(providers: &mut ty::query::Providers) {
}
},
late_bound_vars_map: |tcx, id| resolve_lifetimes_for(tcx, id).late_bound_vars.get(&id),
+ lifetime_scope_map: |tcx, id| {
+ let item_id = item_for(tcx, id);
+ do_resolve(tcx, item_id, false, true).scope_for_path.unwrap().remove(&id)
+ },
..*providers
};
@@ -419,7 +428,7 @@ fn resolve_lifetimes_trait_definition(
tcx: TyCtxt<'_>,
local_def_id: LocalDefId,
) -> ResolveLifetimes {
- do_resolve(tcx, local_def_id, true)
+ convert_named_region_map(do_resolve(tcx, local_def_id, true, false))
}
/// Computes the `ResolveLifetimes` map that contains data for an entire `Item`.
@@ -427,19 +436,21 @@ fn resolve_lifetimes_trait_definition(
/// `named_region_map`, `is_late_bound_map`, etc.
#[tracing::instrument(level = "debug", skip(tcx))]
fn resolve_lifetimes(tcx: TyCtxt<'_>, local_def_id: LocalDefId) -> ResolveLifetimes {
- do_resolve(tcx, local_def_id, false)
+ convert_named_region_map(do_resolve(tcx, local_def_id, false, false))
}
fn do_resolve(
tcx: TyCtxt<'_>,
local_def_id: LocalDefId,
trait_definition_only: bool,
-) -> ResolveLifetimes {
+ with_scope_for_path: bool,
+) -> NamedRegionMap {
let item = tcx.hir().expect_item(tcx.hir().local_def_id_to_hir_id(local_def_id));
let mut named_region_map = NamedRegionMap {
defs: Default::default(),
late_bound: Default::default(),
late_bound_vars: Default::default(),
+ scope_for_path: with_scope_for_path.then(|| Default::default()),
};
let mut visitor = LifetimeContext {
tcx,
@@ -455,6 +466,10 @@ fn do_resolve(
};
visitor.visit_item(item);
+ named_region_map
+}
+
+fn convert_named_region_map(named_region_map: NamedRegionMap) -> ResolveLifetimes {
let mut rl = ResolveLifetimes::default();
for (hir_id, v) in named_region_map.defs {
@@ -567,6 +582,41 @@ fn late_region_as_bound_region<'tcx>(tcx: TyCtxt<'tcx>, region: &Region) -> ty::
}
}
+#[tracing::instrument(level = "debug")]
+fn get_lifetime_scopes_for_path(mut scope: &Scope<'_>) -> LifetimeScopeForPath {
+ let mut available_lifetimes = vec![];
+ loop {
+ match scope {
+ Scope::Binder { lifetimes, s, .. } => {
+ available_lifetimes.extend(lifetimes.keys().filter_map(|p| match p {
+ hir::ParamName::Plain(ident) => Some(ident.name.to_string()),
+ _ => None,
+ }));
+ scope = s;
+ }
+ Scope::Body { s, .. } => {
+ scope = s;
+ }
+ Scope::Elision { elide, s } => {
+ if let Elide::Exact(_) = elide {
+ return LifetimeScopeForPath::Elided;
+ } else {
+ scope = s;
+ }
+ }
+ Scope::ObjectLifetimeDefault { s, .. } => {
+ scope = s;
+ }
+ Scope::Root => {
+ return LifetimeScopeForPath::NonElided(available_lifetimes);
+ }
+ Scope::Supertrait { s, .. } | Scope::TraitRefBoundary { s, .. } => {
+ scope = s;
+ }
+ }
+ }
+}
+
impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
/// Returns the binders in scope and the type of `Binder` that should be created for a poly trait ref.
fn poly_trait_ref_binder_info(&mut self) -> (Vec<ty::BoundVariableKind>, BinderScopeType) {
@@ -656,7 +706,7 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> {
self.map.late_bound_vars.insert(hir_id, vec![]);
let scope = Scope::Binder {
hir_id,
- lifetimes: FxHashMap::default(),
+ lifetimes: FxIndexMap::default(),
next_early_index: self.next_early_index(),
s: self.scope,
track_lifetime_uses: true,
@@ -720,9 +770,7 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> {
// We need to add *all* deps, since opaque tys may want them from *us*
for (&owner, defs) in resolved_lifetimes.defs.iter() {
defs.iter().for_each(|(&local_id, region)| {
- self.map
- .defs
- .insert(hir::HirId { owner, local_id }, region.clone());
+ self.map.defs.insert(hir::HirId { owner, local_id }, *region);
});
}
for (&owner, late_bound) in resolved_lifetimes.late_bound.iter() {
@@ -836,7 +884,7 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> {
};
self.missing_named_lifetime_spots
.push(MissingLifetimeSpot::HigherRanked { span, span_type });
- let (lifetimes, binders): (FxHashMap<hir::ParamName, Region>, Vec<_>) = c
+ let (lifetimes, binders): (FxIndexMap<hir::ParamName, Region>, Vec<_>) = c
.generic_params
.iter()
.filter_map(|param| match param.kind {
@@ -1010,7 +1058,7 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> {
debug!(?index);
let mut elision = None;
- let mut lifetimes = FxHashMap::default();
+ let mut lifetimes = FxIndexMap::default();
let mut non_lifetime_count = 0;
for param in generics.params {
match param.kind {
@@ -1181,7 +1229,7 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> {
let mut index = self.next_early_index();
let mut non_lifetime_count = 0;
debug!("visit_ty: index = {}", index);
- let lifetimes: FxHashMap<hir::ParamName, Region> = generics
+ let lifetimes: FxIndexMap<hir::ParamName, Region> = generics
.params
.iter()
.filter_map(|param| match param.kind {
@@ -1241,15 +1289,53 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> {
self.resolve_lifetime_ref(lifetime_ref);
}
+ fn visit_assoc_type_binding(&mut self, type_binding: &'tcx hir::TypeBinding<'_>) {
+ let scope = self.scope;
+ if let Some(scope_for_path) = self.map.scope_for_path.as_mut() {
+ // We add lifetime scope information for `Ident`s in associated type bindings and use
+ // the `HirId` of the type binding as the key in `LifetimeMap`
+ let lifetime_scope = get_lifetime_scopes_for_path(scope);
+ let map = scope_for_path.entry(type_binding.hir_id.owner).or_default();
+ map.insert(type_binding.hir_id.local_id, lifetime_scope);
+ }
+ hir::intravisit::walk_assoc_type_binding(self, type_binding);
+ }
+
fn visit_path(&mut self, path: &'tcx hir::Path<'tcx>, _: hir::HirId) {
for (i, segment) in path.segments.iter().enumerate() {
let depth = path.segments.len() - i - 1;
if let Some(ref args) = segment.args {
self.visit_segment_args(path.res, depth, args);
}
+
+ let scope = self.scope;
+ if let Some(scope_for_path) = self.map.scope_for_path.as_mut() {
+ // Add lifetime scope information to path segment. Note we cannot call `visit_path_segment`
+ // here because that call would yield to resolution problems due to `walk_path_segment`
+ // being called, which processes the path segments generic args, which we have already
+ // processed using `visit_segment_args`.
+ let lifetime_scope = get_lifetime_scopes_for_path(scope);
+ if let Some(hir_id) = segment.hir_id {
+ let map = scope_for_path.entry(hir_id.owner).or_default();
+ map.insert(hir_id.local_id, lifetime_scope);
+ }
+ }
}
}
+ fn visit_path_segment(&mut self, path_span: Span, path_segment: &'tcx hir::PathSegment<'tcx>) {
+ let scope = self.scope;
+ if let Some(scope_for_path) = self.map.scope_for_path.as_mut() {
+ let lifetime_scope = get_lifetime_scopes_for_path(scope);
+ if let Some(hir_id) = path_segment.hir_id {
+ let map = scope_for_path.entry(hir_id.owner).or_default();
+ map.insert(hir_id.local_id, lifetime_scope);
+ }
+ }
+
+ intravisit::walk_path_segment(self, path_span, path_segment);
+ }
+
fn visit_fn_decl(&mut self, fd: &'tcx hir::FnDecl<'tcx>) {
let output = match fd.output {
hir::FnRetTy::DefaultReturn(_) => None,
@@ -1290,7 +1376,7 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> {
ref bound_generic_params,
..
}) => {
- let (lifetimes, binders): (FxHashMap<hir::ParamName, Region>, Vec<_>) =
+ let (lifetimes, binders): (FxIndexMap<hir::ParamName, Region>, Vec<_>) =
bound_generic_params
.iter()
.filter_map(|param| match param.kind {
@@ -1360,7 +1446,7 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> {
self.map.late_bound_vars.insert(*hir_id, binders);
let scope = Scope::Binder {
hir_id: *hir_id,
- lifetimes: FxHashMap::default(),
+ lifetimes: FxIndexMap::default(),
s: self.scope,
next_early_index: self.next_early_index(),
track_lifetime_uses: true,
@@ -1388,7 +1474,7 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> {
let (mut binders, scope_type) = self.poly_trait_ref_binder_info();
let initial_bound_vars = binders.len() as u32;
- let mut lifetimes: FxHashMap<hir::ParamName, Region> = FxHashMap::default();
+ let mut lifetimes: FxIndexMap<hir::ParamName, Region> = FxIndexMap::default();
let binders_iter = trait_ref
.bound_generic_params
.iter()
@@ -2115,7 +2201,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
let mut non_lifetime_count = 0;
let mut named_late_bound_vars = 0;
- let lifetimes: FxHashMap<hir::ParamName, Region> = generics
+ let lifetimes: FxIndexMap<hir::ParamName, Region> = generics
.params
.iter()
.filter_map(|param| match param.kind {
@@ -3034,6 +3120,16 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
}
};
+ // If we specifically need the `scope_for_path` map, then we're in the
+ // diagnostic pass and we don't want to emit more errors.
+ if self.map.scope_for_path.is_some() {
+ self.tcx.sess.delay_span_bug(
+ rustc_span::DUMMY_SP,
+ "Encountered unexpected errors during diagnostics related part",
+ );
+ return;
+ }
+
let mut spans: Vec<_> = lifetime_refs.iter().map(|lt| lt.span).collect();
spans.sort();
let mut spans_dedup = spans.clone();
diff --git a/compiler/rustc_typeck/src/astconv/generics.rs b/compiler/rustc_typeck/src/astconv/generics.rs
index 077375c7c3b4f..456f2a908a8c1 100644
--- a/compiler/rustc_typeck/src/astconv/generics.rs
+++ b/compiler/rustc_typeck/src/astconv/generics.rs
@@ -4,7 +4,7 @@ use crate::astconv::{
GenericArgCountResult, GenericArgPosition,
};
use crate::errors::AssocTypeBindingNotAllowed;
-use crate::structured_errors::{StructuredDiagnostic, WrongNumberOfGenericArgs};
+use crate::structured_errors::{GenericArgsInfo, StructuredDiagnostic, WrongNumberOfGenericArgs};
use rustc_ast::ast::ParamKindOrd;
use rustc_errors::{struct_span_err, Applicability, DiagnosticBuilder, ErrorReported};
use rustc_hir as hir;
@@ -438,6 +438,11 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
has_self: bool,
infer_args: bool,
) -> GenericArgCountResult {
+ debug!(
+ "check_generic_arg_count(span: {:?}, def_id: {:?}, seg: {:?}, gen_params: {:?}, gen_args: {:?})",
+ span, def_id, seg, gen_params, gen_args
+ );
+
let default_counts = gen_params.own_defaults();
let param_counts = gen_params.own_counts();
let named_type_param_count = param_counts.types - has_self as usize;
@@ -453,63 +458,116 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
let mut invalid_args = vec![];
- let mut check_generics =
- |kind, expected_min, expected_max, provided, params_offset, args_offset, silent| {
+ let mut check_lifetime_args = |min_expected_args: usize,
+ max_expected_args: usize,
+ provided_args: usize,
+ late_bounds_ignore: bool|
+ -> bool {
+ if (min_expected_args..=max_expected_args).contains(&provided_args) {
+ return true;
+ }
+
+ if late_bounds_ignore {
+ return true;
+ }
+
+ if provided_args > max_expected_args {
+ invalid_args.extend(
+ gen_args.args[max_expected_args..provided_args].iter().map(|arg| arg.span()),
+ );
+ };
+
+ let gen_args_info = if provided_args > min_expected_args {
+ invalid_args.extend(
+ gen_args.args[min_expected_args..provided_args].iter().map(|arg| arg.span()),
+ );
+ let num_redundant_args = provided_args - min_expected_args;
+ GenericArgsInfo::ExcessLifetimes { num_redundant_args }
+ } else {
+ let num_missing_args = min_expected_args - provided_args;
+ GenericArgsInfo::MissingLifetimes { num_missing_args }
+ };
+
+ WrongNumberOfGenericArgs::new(
+ tcx,
+ gen_args_info,
+ seg,
+ gen_params,
+ has_self as usize,
+ gen_args,
+ def_id,
+ )
+ .diagnostic()
+ .emit();
+
+ false
+ };
+
+ let min_expected_lifetime_args = if infer_lifetimes { 0 } else { param_counts.lifetimes };
+ let max_expected_lifetime_args = param_counts.lifetimes;
+ let num_provided_lifetime_args = arg_counts.lifetimes;
+
+ let lifetimes_correct = check_lifetime_args(
+ min_expected_lifetime_args,
+ max_expected_lifetime_args,
+ num_provided_lifetime_args,
+ explicit_late_bound == ExplicitLateBound::Yes,
+ );
+
+ let mut check_types_and_consts =
+ |expected_min, expected_max, provided, params_offset, args_offset| {
+ debug!(
+ "check_types_and_consts(expected_min: {:?}, expected_max: {:?}, \
+ provided: {:?}, params_offset: {:?}, args_offset: {:?}",
+ expected_min, expected_max, provided, params_offset, args_offset
+ );
if (expected_min..=expected_max).contains(&provided) {
return true;
}
- if silent {
- return true;
- }
+ let num_default_params = expected_max - expected_min;
- if provided > expected_max {
+ let gen_args_info = if provided > expected_max {
invalid_args.extend(
gen_args.args[args_offset + expected_max..args_offset + provided]
.iter()
.map(|arg| arg.span()),
);
+ let num_redundant_args = provided - expected_max;
+
+ GenericArgsInfo::ExcessTypesOrConsts {
+ num_redundant_args,
+ num_default_params,
+ args_offset,
+ }
+ } else {
+ let num_missing_args = expected_max - provided;
+
+ GenericArgsInfo::MissingTypesOrConsts {
+ num_missing_args,
+ num_default_params,
+ args_offset,
+ }
};
- WrongNumberOfGenericArgs {
+ debug!("gen_args_info: {:?}", gen_args_info);
+
+ WrongNumberOfGenericArgs::new(
tcx,
- kind,
- expected_min,
- expected_max,
- provided,
- params_offset,
- args_offset,
- path_segment: seg,
+ gen_args_info,
+ seg,
gen_params,
+ params_offset,
gen_args,
def_id,
- span,
- }
+ )
.diagnostic()
.emit();
false
};
- let lifetimes_correct = check_generics(
- "lifetime",
- if infer_lifetimes { 0 } else { param_counts.lifetimes },
- param_counts.lifetimes,
- arg_counts.lifetimes,
- has_self as usize,
- 0,
- explicit_late_bound == ExplicitLateBound::Yes,
- );
-
let args_correct = {
- let kind = if param_counts.consts + arg_counts.consts == 0 {
- "type"
- } else if named_type_param_count + arg_counts.types == 0 {
- "const"
- } else {
- "generic"
- };
-
let expected_min = if infer_args {
0
} else {
@@ -517,15 +575,15 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
- default_counts.types
- default_counts.consts
};
+ debug!("expected_min: {:?}", expected_min);
+ debug!("arg_counts.lifetimes: {:?}", arg_counts.lifetimes);
- check_generics(
- kind,
+ check_types_and_consts(
expected_min,
param_counts.consts + named_type_param_count,
arg_counts.consts + arg_counts.types,
param_counts.lifetimes + has_self as usize,
arg_counts.lifetimes,
- false,
)
};
diff --git a/compiler/rustc_typeck/src/astconv/mod.rs b/compiler/rustc_typeck/src/astconv/mod.rs
index 2f2e90e4bd66f..7696a0c69cac9 100644
--- a/compiler/rustc_typeck/src/astconv/mod.rs
+++ b/compiler/rustc_typeck/src/astconv/mod.rs
@@ -120,6 +120,7 @@ pub enum SizedByDefault {
#[derive(Debug)]
struct ConvertedBinding<'a, 'tcx> {
+ hir_id: hir::HirId,
item_name: Ident,
kind: ConvertedBindingKind<'a, 'tcx>,
gen_args: &'a GenericArgs<'a>,
@@ -590,6 +591,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
}
};
ConvertedBinding {
+ hir_id: binding.hir_id,
item_name: binding.ident,
kind,
gen_args: binding.gen_args,
@@ -609,6 +611,10 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
item_segment: &hir::PathSegment<'_>,
parent_substs: SubstsRef<'tcx>,
) -> SubstsRef<'tcx> {
+ debug!(
+ "create_substs_for_associated_item(span: {:?}, item_def_id: {:?}, item_segment: {:?}",
+ span, item_def_id, item_segment
+ );
if tcx.generics_of(item_def_id).params.is_empty() {
self.prohibit_generics(slice::from_ref(item_segment));
@@ -1071,9 +1077,10 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
// Include substitutions for generic parameters of associated types
let projection_ty = candidate.map_bound(|trait_ref| {
+ let ident = Ident::new(assoc_ty.ident.name, binding.item_name.span);
let item_segment = hir::PathSegment {
- ident: assoc_ty.ident,
- hir_id: None,
+ ident,
+ hir_id: Some(binding.hir_id),
res: None,
args: Some(binding.gen_args),
infer_args: false,
diff --git a/compiler/rustc_typeck/src/structured_errors/wrong_number_of_generic_args.rs b/compiler/rustc_typeck/src/structured_errors/wrong_number_of_generic_args.rs
index e35c155746642..c533ca28321a1 100644
--- a/compiler/rustc_typeck/src/structured_errors/wrong_number_of_generic_args.rs
+++ b/compiler/rustc_typeck/src/structured_errors/wrong_number_of_generic_args.rs
@@ -1,34 +1,20 @@
use crate::structured_errors::StructuredDiagnostic;
-use hir::def::DefKind;
use rustc_errors::{pluralize, Applicability, DiagnosticBuilder, DiagnosticId};
use rustc_hir as hir;
+use rustc_middle::middle::resolve_lifetime::LifetimeScopeForPath;
use rustc_middle::ty::{self as ty, TyCtxt};
use rustc_session::Session;
-use rustc_span::Span;
use rustc_span::{def_id::DefId, MultiSpan};
+use GenericArgsInfo::*;
+
/// Handles the `wrong number of type / lifetime / ... arguments` family of error messages.
pub struct WrongNumberOfGenericArgs<'a, 'tcx> {
crate tcx: TyCtxt<'tcx>,
- /// "type", "lifetime" etc., put verbatim into the message
- crate kind: &'static str,
-
- /// Minimum number of expected generic arguments (e.g. `2` for `HashMap`)
- crate expected_min: usize,
+ crate angle_brackets: AngleBrackets,
- /// Maximum number of expected generic arguments (e.g. `3` for `HashMap`)
- crate expected_max: usize,
-
- /// Number of generic arguments provided by the user
- crate provided: usize,
-
- /// Offset into `gen_params` - depends on the `kind`; might be different than `args_offset` when
- /// user passed e.g. more arguments than was actually expected
- crate params_offset: usize,
-
- /// Offset into `gen_args` - depends on the `kind`
- crate args_offset: usize,
+ crate gen_args_info: GenericArgsInfo,
/// Offending path segment
crate path_segment: &'a hir::PathSegment<'a>,
@@ -36,64 +22,348 @@ pub struct WrongNumberOfGenericArgs<'a, 'tcx> {
/// Generic parameters as expected by type or trait
crate gen_params: &'a ty::Generics,
+ /// Index offset into parameters. Depends on whether `Self` is included and on
+ /// number of lifetime parameters in case we're processing missing or redundant
+ /// type or constant arguments.
+ crate params_offset: usize,
+
/// Generic arguments as provided by user
crate gen_args: &'a hir::GenericArgs<'a>,
/// DefId of the generic type
crate def_id: DefId,
+}
+
+// Provides information about the kind of arguments that were provided for
+// the PathSegment, for which missing generic arguments were detected
+#[derive(Debug)]
+pub(crate) enum AngleBrackets {
+ // No angle brackets were provided, but generic arguments exist in elided form
+ Implied,
+
+ // No angle brackets were provided
+ Missing,
+
+ // Angle brackets are available, but missing some generic arguments
+ Available,
+}
- /// Offending place where the generic type has been misused
- crate span: Span,
+// Information about the kind of arguments that are either missing or are unexpected
+#[derive(Debug)]
+pub enum GenericArgsInfo {
+ MissingLifetimes {
+ num_missing_args: usize,
+ },
+ ExcessLifetimes {
+ num_redundant_args: usize,
+ },
+ MissingTypesOrConsts {
+ num_missing_args: usize,
+
+ // type or const generic arguments can have default values
+ num_default_params: usize,
+
+ // lifetime arguments precede type and const parameters, this
+ // field gives the number of generic lifetime arguments to let
+ // us infer the position of type and const generic arguments
+ // in the angle brackets
+ args_offset: usize,
+ },
+
+ ExcessTypesOrConsts {
+ num_redundant_args: usize,
+
+ // type or const generic arguments can have default values
+ num_default_params: usize,
+
+ // lifetime arguments precede type and const parameters, this
+ // field gives the number of generic lifetime arguments to let
+ // us infer the position of type and const generic arguments
+ // in the angle brackets
+ args_offset: usize,
+ },
}
-impl<'tcx> WrongNumberOfGenericArgs<'_, 'tcx> {
- fn quantifier_and_bound(&self) -> (&'static str, usize) {
- if self.expected_min == self.expected_max {
- ("", self.expected_min)
- } else if self.provided < self.expected_min {
- ("at least ", self.expected_min)
+impl<'a, 'tcx> WrongNumberOfGenericArgs<'a, 'tcx> {
+ pub fn new(
+ tcx: TyCtxt<'tcx>,
+ gen_args_info: GenericArgsInfo,
+ path_segment: &'a hir::PathSegment<'_>,
+ gen_params: &'a ty::Generics,
+ params_offset: usize,
+ gen_args: &'a hir::GenericArgs<'a>,
+ def_id: DefId,
+ ) -> Self {
+ let angle_brackets = if gen_args.is_empty() {
+ AngleBrackets::Missing
} else {
- ("at most ", self.expected_max)
+ if gen_args.span().is_none() {
+ AngleBrackets::Implied
+ } else {
+ AngleBrackets::Available
+ }
+ };
+
+ Self {
+ tcx,
+ angle_brackets,
+ gen_args_info,
+ path_segment,
+ gen_params,
+ params_offset,
+ gen_args,
+ def_id,
}
}
- fn start_diagnostics(&self) -> DiagnosticBuilder<'tcx> {
- let span = self.path_segment.ident.span;
+ fn missing_lifetimes(&self) -> bool {
+ match self.gen_args_info {
+ MissingLifetimes { .. } | ExcessLifetimes { .. } => true,
+ MissingTypesOrConsts { .. } | ExcessTypesOrConsts { .. } => false,
+ }
+ }
- let msg = {
- let def_path = self.tcx.def_path_str(self.def_id);
- let def_kind = self.tcx.def_kind(self.def_id).descr(self.def_id);
- let (quantifier, bound) = self.quantifier_and_bound();
+ fn kind(&self) -> String {
+ if self.missing_lifetimes() { "lifetime".to_string() } else { "generic".to_string() }
+ }
- if self.gen_args.span().is_some() {
- format!(
- "this {} takes {}{} {} argument{} but {}{} {} argument{} {} supplied",
- def_kind,
- quantifier,
- bound,
- self.kind,
- pluralize!(bound),
- if self.provided > 0 && self.provided < self.expected_min {
- "only "
- } else {
- ""
- },
- self.provided,
- self.kind,
- pluralize!(self.provided),
- if self.provided == 1 { "was" } else { "were" },
- )
- } else {
- format!("missing generics for {} `{}`", def_kind, def_path)
+ fn num_provided_args(&self) -> usize {
+ if self.missing_lifetimes() {
+ self.num_provided_lifetime_args()
+ } else {
+ self.num_provided_type_or_const_args()
+ }
+ }
+
+ fn num_provided_lifetime_args(&self) -> usize {
+ match self.angle_brackets {
+ AngleBrackets::Missing => 0,
+ // Only lifetime arguments can be implied
+ AngleBrackets::Implied => self.gen_args.args.len(),
+ AngleBrackets::Available => self.gen_args.args.iter().fold(0, |acc, arg| match arg {
+ hir::GenericArg::Lifetime(_) => acc + 1,
+ _ => acc,
+ }),
+ }
+ }
+
+ fn num_provided_type_or_const_args(&self) -> usize {
+ match self.angle_brackets {
+ AngleBrackets::Missing => 0,
+ // Only lifetime arguments can be implied
+ AngleBrackets::Implied => 0,
+ AngleBrackets::Available => self.gen_args.args.iter().fold(0, |acc, arg| match arg {
+ hir::GenericArg::Type(_) | hir::GenericArg::Const(_) => acc + 1,
+ _ => acc,
+ }),
+ }
+ }
+
+ fn num_expected_lifetime_args(&self) -> usize {
+ let num_provided_args = self.num_provided_lifetime_args();
+ match self.gen_args_info {
+ MissingLifetimes { num_missing_args } => num_provided_args + num_missing_args,
+ ExcessLifetimes { num_redundant_args } => num_provided_args - num_redundant_args,
+ _ => 0,
+ }
+ }
+
+ fn num_expected_type_or_const_args(&self) -> usize {
+ let num_provided_args = self.num_provided_type_or_const_args();
+ match self.gen_args_info {
+ MissingTypesOrConsts { num_missing_args, .. } => num_provided_args + num_missing_args,
+ ExcessTypesOrConsts { num_redundant_args, .. } => {
+ num_provided_args - num_redundant_args
+ }
+ _ => 0,
+ }
+ }
+
+ // Gives the number of expected arguments taking into account default arguments
+ fn num_expected_type_or_const_args_including_defaults(&self) -> usize {
+ let provided_args = self.num_provided_type_or_const_args();
+ match self.gen_args_info {
+ MissingTypesOrConsts { num_missing_args, num_default_params, .. } => {
+ provided_args + num_missing_args - num_default_params
+ }
+ ExcessTypesOrConsts { num_redundant_args, num_default_params, .. } => {
+ provided_args - num_redundant_args - num_default_params
+ }
+ _ => 0,
+ }
+ }
+
+ fn num_missing_lifetime_args(&self) -> usize {
+ let missing_args = self.num_expected_lifetime_args() - self.num_provided_lifetime_args();
+ assert!(missing_args > 0);
+ missing_args
+ }
+
+ fn num_missing_type_or_const_args(&self) -> usize {
+ let missing_args = self.num_expected_type_or_const_args_including_defaults()
+ - self.num_provided_type_or_const_args();
+ assert!(missing_args > 0);
+ missing_args
+ }
+
+ fn num_excess_lifetime_args(&self) -> usize {
+ match self.gen_args_info {
+ ExcessLifetimes { num_redundant_args } => num_redundant_args,
+ _ => 0,
+ }
+ }
+
+ fn num_excess_type_or_const_args(&self) -> usize {
+ match self.gen_args_info {
+ ExcessTypesOrConsts { num_redundant_args, .. } => num_redundant_args,
+ _ => 0,
+ }
+ }
+
+ fn too_many_args_provided(&self) -> bool {
+ match self.gen_args_info {
+ MissingLifetimes { .. } | MissingTypesOrConsts { .. } => false,
+ ExcessLifetimes { num_redundant_args }
+ | ExcessTypesOrConsts { num_redundant_args, .. } => {
+ assert!(num_redundant_args > 0);
+ true
+ }
+ }
+ }
+
+ fn not_enough_args_provided(&self) -> bool {
+ match self.gen_args_info {
+ MissingLifetimes { num_missing_args }
+ | MissingTypesOrConsts { num_missing_args, .. } => {
+ assert!(num_missing_args > 0);
+ true
+ }
+ ExcessLifetimes { .. } | ExcessTypesOrConsts { .. } => false,
+ }
+ }
+
+ // Helper method to get the index offset in angle brackets, at which type or const arguments
+ // start appearing
+ fn get_lifetime_args_offset(&self) -> usize {
+ match self.gen_args_info {
+ MissingLifetimes { .. } | ExcessLifetimes { .. } => 0,
+ MissingTypesOrConsts { args_offset, .. } | ExcessTypesOrConsts { args_offset, .. } => {
+ args_offset
}
+ }
+ }
+
+ fn get_num_default_params(&self) -> usize {
+ match self.gen_args_info {
+ MissingTypesOrConsts { num_default_params, .. }
+ | ExcessTypesOrConsts { num_default_params, .. } => num_default_params,
+ _ => 0,
+ }
+ }
+
+ // Helper function to choose a quantifier word for the number of expected arguments
+ // and to give a bound for the number of expected arguments
+ fn get_quantifier_and_bound(&self) -> (&'static str, usize) {
+ if self.get_num_default_params() == 0 {
+ match self.gen_args_info {
+ MissingLifetimes { .. } | ExcessLifetimes { .. } => {
+ ("", self.num_expected_lifetime_args())
+ }
+ MissingTypesOrConsts { .. } | ExcessTypesOrConsts { .. } => {
+ ("", self.num_expected_type_or_const_args())
+ }
+ }
+ } else {
+ match self.gen_args_info {
+ MissingLifetimes { .. } => ("at least ", self.num_expected_lifetime_args()),
+ MissingTypesOrConsts { .. } => {
+ ("at least ", self.num_expected_type_or_const_args_including_defaults())
+ }
+ ExcessLifetimes { .. } => ("at most ", self.num_expected_lifetime_args()),
+ ExcessTypesOrConsts { .. } => ("at most ", self.num_expected_type_or_const_args()),
+ }
+ }
+ }
+
+ // Creates lifetime name suggestions from the lifetime parameter names
+ fn get_lifetime_args_suggestions_from_param_names(&self, num_params_to_take: usize) -> String {
+ self.gen_params
+ .params
+ .iter()
+ .skip(self.params_offset + self.num_provided_lifetime_args())
+ .take(num_params_to_take)
+ .map(|param| param.name.to_string())
+ .collect::<Vec<_>>()
+ .join(", ")
+ }
+
+ // Creates type or constant name suggestions from the provided parameter names
+ fn get_type_or_const_args_suggestions_from_param_names(
+ &self,
+ num_params_to_take: usize,
+ ) -> String {
+ self.gen_params
+ .params
+ .iter()
+ .skip(self.params_offset + self.num_provided_type_or_const_args())
+ .take(num_params_to_take)
+ .map(|param| param.name.to_string())
+ .collect::<Vec<_>>()
+ .join(", ")
+ }
+
+ fn create_error_message(&self) -> String {
+ let def_path = self.tcx.def_path_str(self.def_id);
+ let def_kind = self.tcx.def_kind(self.def_id).descr(self.def_id);
+ let (quantifier, bound) = self.get_quantifier_and_bound();
+ let kind = self.kind();
+ let provided_lt_args = self.num_provided_lifetime_args();
+ let provided_type_or_const_args = self.num_provided_type_or_const_args();
+
+ let get_verb = |num_args| if num_args == 1 { "was" } else { "were" };
+
+ let (provided_args_str, verb) = match self.gen_args_info {
+ MissingLifetimes { .. } | ExcessLifetimes { .. } => (
+ format!("{} lifetime argument{}", provided_lt_args, pluralize!(provided_lt_args)),
+ get_verb(provided_lt_args),
+ ),
+ MissingTypesOrConsts { .. } | ExcessTypesOrConsts { .. } => (
+ format!(
+ "{} generic argument{}",
+ provided_type_or_const_args,
+ pluralize!(provided_type_or_const_args)
+ ),
+ get_verb(provided_type_or_const_args),
+ ),
};
+ if self.gen_args.span().is_some() {
+ format!(
+ "this {} takes {}{} {} argument{} but {} {} supplied",
+ def_kind,
+ quantifier,
+ bound,
+ kind,
+ pluralize!(bound),
+ provided_args_str.as_str(),
+ verb
+ )
+ } else {
+ format!("missing generics for {} `{}`", def_kind, def_path)
+ }
+ }
+
+ fn start_diagnostics(&self) -> DiagnosticBuilder<'tcx> {
+ let span = self.path_segment.ident.span;
+ let msg = self.create_error_message();
+
self.tcx.sess.struct_span_err_with_code(span, &msg, self.code())
}
/// Builds the `expected 1 type argument / supplied 2 type arguments` message.
fn notify(&self, err: &mut DiagnosticBuilder<'_>) {
- let (quantifier, bound) = self.quantifier_and_bound();
+ let (quantifier, bound) = self.get_quantifier_and_bound();
+ let provided_args = self.num_provided_args();
err.span_label(
self.path_segment.ident.span,
@@ -101,12 +371,12 @@ impl<'tcx> WrongNumberOfGenericArgs<'_, 'tcx> {
"expected {}{} {} argument{}",
quantifier,
bound,
- self.kind,
+ self.kind(),
pluralize!(bound),
),
);
- // When user's provided too many arguments, we don't highlight each of them, because it
+ // When too many arguments were provided, we don't highlight each of them, because it
// would overlap with the suggestion to remove them:
//
// ```
@@ -114,21 +384,27 @@ impl<'tcx> WrongNumberOfGenericArgs<'_, 'tcx> {
// ----- ----- supplied 2 type arguments
// ^^^^^^^ remove this type argument
// ```
- if self.provided > self.expected_max {
+ if self.too_many_args_provided() {
return;
}
- let args = self.gen_args.args.iter().skip(self.args_offset).take(self.provided).enumerate();
+ let args = self
+ .gen_args
+ .args
+ .iter()
+ .skip(self.get_lifetime_args_offset())
+ .take(provided_args)
+ .enumerate();
for (i, arg) in args {
err.span_label(
arg.span(),
- if i + 1 == self.provided {
+ if i + 1 == provided_args {
format!(
"supplied {} {} argument{}",
- self.provided,
- self.kind,
- pluralize!(self.provided)
+ provided_args,
+ self.kind(),
+ pluralize!(provided_args)
)
} else {
String::new()
@@ -138,56 +414,24 @@ impl<'tcx> WrongNumberOfGenericArgs<'_, 'tcx> {
}
fn suggest(&self, err: &mut DiagnosticBuilder<'_>) {
- if self.provided == 0 {
- if self.gen_args.span().is_some() {
- self.suggest_adding_args(err);
- } else {
- self.suggest_creating_generics(err);
- }
- } else if self.provided < self.expected_min {
- self.suggest_adding_args(err);
- } else {
- self.suggest_removing_args_or_generics(err);
- }
- }
-
- /// Suggests to create generics (`<...>`) when current invocation site contains no generics at
- /// all:
- ///
- /// ```text
- /// type Map = HashMap;
- /// ```
- fn suggest_creating_generics(&self, err: &mut DiagnosticBuilder<'_>) {
- let params = self
- .gen_params
- .params
- .iter()
- .skip(self.params_offset)
- .take(self.expected_min)
- .map(|param| param.name.to_string())
- .collect::<Vec<_>>()
- .join(", ");
-
- let def_kind = self.tcx.def_kind(self.def_id);
-
- let sugg = if matches!(def_kind, DefKind::Fn | DefKind::AssocFn) {
- format!("::<{}>", params)
- } else {
- format!("<{}>", params)
- };
-
- let msg = format!(
- "use angle brackets to add missing {} argument{}",
- self.kind,
- pluralize!(self.expected_min),
+ debug!(
+ "suggest(self.provided {:?}, self.gen_args.span(): {:?})",
+ self.num_provided_args(),
+ self.gen_args.span(),
);
- err.span_suggestion_verbose(
- self.path_segment.ident.span.shrink_to_hi(),
- &msg,
- sugg,
- Applicability::HasPlaceholders,
- );
+ match self.angle_brackets {
+ AngleBrackets::Missing | AngleBrackets::Implied => self.suggest_adding_args(err),
+ AngleBrackets::Available => {
+ if self.not_enough_args_provided() {
+ self.suggest_adding_args(err);
+ } else if self.too_many_args_provided() {
+ self.suggest_removing_args_or_generics(err);
+ } else {
+ unreachable!();
+ }
+ }
+ }
}
/// Suggests to add missing argument(s) when current invocation site already contains some
@@ -197,38 +441,167 @@ impl<'tcx> WrongNumberOfGenericArgs<'_, 'tcx> {
/// type Map = HashMap<String>;
/// ```
fn suggest_adding_args(&self, err: &mut DiagnosticBuilder<'_>) {
- assert!(!self.gen_args.is_empty());
-
if self.gen_args.parenthesized {
return;
}
- let missing_arg_count = self.expected_min - self.provided;
+ match self.gen_args_info {
+ MissingLifetimes { .. } => {
+ self.suggest_adding_lifetime_args(err);
+ }
+ MissingTypesOrConsts { .. } => {
+ self.suggest_adding_type_and_const_args(err);
+ }
+ _ => unreachable!(),
+ }
+ }
- let (span, sugg_prefix) = if self.args_offset + self.provided == 0 {
- let span = self.gen_args.args[0].span().shrink_to_lo();
- (span, "")
+ fn suggest_adding_lifetime_args(&self, err: &mut DiagnosticBuilder<'_>) {
+ debug!("suggest_adding_lifetime_args(path_segment: {:?})", self.path_segment);
+ let num_missing_args = self.num_missing_lifetime_args();
+ let num_params_to_take = num_missing_args;
+ let msg = format!("add missing {} argument{}", self.kind(), pluralize!(num_missing_args));
+
+ // we first try to get lifetime name suggestions from scope or elision information. If none is
+ // available we use the parameter defintions
+ let suggested_args = if let Some(hir_id) = self.path_segment.hir_id {
+ if let Some(lifetimes_in_scope) = self.tcx.lifetime_scope(hir_id) {
+ match lifetimes_in_scope {
+ LifetimeScopeForPath::NonElided(param_names) => {
+ debug!("NonElided(param_names: {:?})", param_names);
+
+ if param_names.len() >= num_params_to_take {
+ // use lifetime parameters in scope for suggestions
+ param_names
+ .iter()
+ .take(num_params_to_take)
+ .map(|p| (*p).clone())
+ .collect::<Vec<_>>()
+ .join(", ")
+ } else {
+ // Not enough lifetime arguments in scope -> create suggestions from
+ // lifetime parameter names in definition. An error for the incorrect
+ // lifetime scope will be output later.
+ self.get_lifetime_args_suggestions_from_param_names(num_params_to_take)
+ }
+ }
+ LifetimeScopeForPath::Elided => {
+ debug!("Elided");
+ // use suggestions of the form `<'_, '_>` in case lifetime can be elided
+ ["'_"].repeat(num_params_to_take).join(",")
+ }
+ }
+ } else {
+ self.get_lifetime_args_suggestions_from_param_names(num_params_to_take)
+ }
} else {
- let span =
- self.gen_args.args[self.args_offset + self.provided - 1].span().shrink_to_hi();
- (span, ", ")
+ self.get_lifetime_args_suggestions_from_param_names(num_params_to_take)
};
- let msg = format!("add missing {} argument{}", self.kind, pluralize!(missing_arg_count));
+ debug!("suggested_args: {:?}", &suggested_args);
- let sugg = self
- .gen_params
- .params
- .iter()
- .skip(self.params_offset + self.provided)
- .take(missing_arg_count)
- .map(|param| param.name.to_string())
- .collect::<Vec<_>>()
- .join(", ");
+ match self.angle_brackets {
+ AngleBrackets::Missing => {
+ let span = self.path_segment.ident.span;
+
+ // insert a suggestion of the form "Y<'a, 'b>"
+ let ident = self.path_segment.ident.name.to_ident_string();
+ let sugg = format!("{}<{}>", ident, suggested_args);
+ debug!("sugg: {:?}", sugg);
+
+ err.span_suggestion_verbose(span, &msg, sugg, Applicability::HasPlaceholders);
+ }
+
+ AngleBrackets::Available => {
+ // angle brackets exist, so we insert missing arguments after the existing args
+
+ assert!(!self.gen_args.args.is_empty());
+
+ if self.num_provided_lifetime_args() > 0 {
+ let last_lt_arg_span = self.gen_args.args
+ [self.num_provided_lifetime_args() - 1]
+ .span()
+ .shrink_to_hi();
+ let source_map = self.tcx.sess.source_map();
- let sugg = format!("{}{}", sugg_prefix, sugg);
+ if let Ok(last_gen_arg) = source_map.span_to_snippet(last_lt_arg_span) {
+ let sugg = format!("{}, {}", last_gen_arg, suggested_args);
- err.span_suggestion_verbose(span, &msg, sugg, Applicability::HasPlaceholders);
+ err.span_suggestion_verbose(
+ last_lt_arg_span,
+ &msg,
+ sugg,
+ Applicability::HasPlaceholders,
+ );
+ }
+ } else {
+ // Non-lifetime arguments included in `gen_args` -> insert missing lifetimes before
+ // existing arguments
+ let first_arg_span = self.gen_args.args[0].span().shrink_to_lo();
+ let source_map = self.tcx.sess.source_map();
+
+ if let Ok(first_gen_arg) = source_map.span_to_snippet(first_arg_span) {
+ let sugg = format!("{}, {}", suggested_args, first_gen_arg);
+
+ err.span_suggestion_verbose(
+ first_arg_span,
+ &msg,
+ sugg,
+ Applicability::HasPlaceholders,
+ );
+ }
+ }
+ }
+ AngleBrackets::Implied => {
+ // We never encounter missing lifetimes in situations in which lifetimes are elided
+ unreachable!();
+ }
+ }
+ }
+
+ fn suggest_adding_type_and_const_args(&self, err: &mut DiagnosticBuilder<'_>) {
+ let num_missing_args = self.num_missing_type_or_const_args();
+ let msg = format!("add missing {} argument{}", self.kind(), pluralize!(num_missing_args));
+
+ let suggested_args =
+ self.get_type_or_const_args_suggestions_from_param_names(num_missing_args);
+ debug!("suggested_args: {:?}", suggested_args);
+
+ match self.angle_brackets {
+ AngleBrackets::Missing | AngleBrackets::Implied => {
+ let span = self.path_segment.ident.span;
+
+ // insert a suggestion of the form "Y<T, U>"
+ let ident = self.path_segment.ident.name.to_ident_string();
+ let sugg = format!("{}<{}>", ident, suggested_args);
+ debug!("sugg: {:?}", sugg);
+
+ err.span_suggestion_verbose(span, &msg, sugg, Applicability::HasPlaceholders);
+ }
+ AngleBrackets::Available => {
+ // angle brackets exist, so we just insert missing arguments after the existing
+ // type or const args
+
+ let index_last_provided_arg =
+ self.get_lifetime_args_offset() + self.num_provided_type_or_const_args() - 1;
+ if index_last_provided_arg < self.gen_args.args.len() {
+ let first_arg_span =
+ self.gen_args.args[index_last_provided_arg].span().shrink_to_hi();
+ let source_map = self.tcx.sess.source_map();
+ if let Ok(first_gen_arg) = source_map.span_to_snippet(first_arg_span) {
+ let sugg = format!("{}, {}", first_gen_arg, suggested_args);
+ debug!("sugg: {:?}", sugg);
+
+ err.span_suggestion_verbose(
+ first_arg_span,
+ &msg,
+ sugg,
+ Applicability::HasPlaceholders,
+ );
+ }
+ }
+ }
+ }
}
/// Suggests to remove redundant argument(s):
@@ -237,12 +610,91 @@ impl<'tcx> WrongNumberOfGenericArgs<'_, 'tcx> {
/// type Map = HashMap<String, String, String, String>;
/// ```
fn suggest_removing_args_or_generics(&self, err: &mut DiagnosticBuilder<'_>) {
- assert!(self.provided > 0);
+ let num_provided_lt_args = self.num_provided_lifetime_args();
+ let num_provided_type_const_args = self.num_provided_type_or_const_args();
+ let num_provided_args = num_provided_lt_args + num_provided_type_const_args;
+ assert!(num_provided_args > 0);
+
+ let num_redundant_lt_args = self.num_excess_lifetime_args();
+ let num_redundant_type_or_const_args = self.num_excess_type_or_const_args();
+ let num_redundant_args = num_redundant_lt_args + num_redundant_type_or_const_args;
+
+ let redundant_lifetime_args = num_redundant_lt_args > 0;
+ let redundant_type_or_const_args = num_redundant_type_or_const_args > 0;
+
+ let remove_entire_generics = num_redundant_args >= self.gen_args.args.len();
+
+ let remove_lifetime_args = |err: &mut DiagnosticBuilder<'_>| {
+ let idx_first_redundant_lt_args = self.num_expected_lifetime_args();
+ let span_lo_redundant_lt_args =
+ self.gen_args.args[idx_first_redundant_lt_args].span().shrink_to_lo();
+ let span_hi_redundant_lt_args = self.gen_args.args
+ [idx_first_redundant_lt_args + num_redundant_lt_args - 1]
+ .span()
+ .shrink_to_hi();
+ let eat_comma =
+ idx_first_redundant_lt_args + num_redundant_lt_args - 1 != self.gen_args.args.len();
+
+ let span_redundant_lt_args = if eat_comma {
+ let span_hi = self.gen_args.args
+ [idx_first_redundant_lt_args + num_redundant_lt_args - 1]
+ .span()
+ .shrink_to_hi();
+ span_lo_redundant_lt_args.to(span_hi)
+ } else {
+ span_lo_redundant_lt_args.to(span_hi_redundant_lt_args)
+ };
+ debug!("span_redundant_lt_args: {:?}", span_redundant_lt_args);
+
+ let msg_lifetimes = format!(
+ "remove {} {} argument{}",
+ if num_redundant_args == 1 { "this" } else { "these" },
+ "lifetime",
+ pluralize!(num_redundant_lt_args),
+ );
+
+ err.span_suggestion(
+ span_redundant_lt_args,
+ &msg_lifetimes,
+ String::new(),
+ Applicability::MaybeIncorrect,
+ );
+ };
+
+ let remove_type_or_const_args = |err: &mut DiagnosticBuilder<'_>| {
+ let idx_first_redundant_type_or_const_args = self.get_lifetime_args_offset()
+ + num_redundant_lt_args
+ + self.num_expected_type_or_const_args();
+
+ let span_lo_redundant_type_or_const_args =
+ self.gen_args.args[idx_first_redundant_type_or_const_args].span().shrink_to_lo();
- let redundant_args_count = self.provided - self.expected_max;
- let remove_entire_generics = redundant_args_count >= self.gen_args.args.len();
+ let span_hi_redundant_type_or_const_args = self.gen_args.args
+ [idx_first_redundant_type_or_const_args + num_redundant_type_or_const_args - 1]
+ .span()
+ .shrink_to_hi();
- let (span, msg) = if remove_entire_generics {
+ let span_redundant_type_or_const_args =
+ span_lo_redundant_type_or_const_args.to(span_hi_redundant_type_or_const_args);
+
+ debug!("span_redundant_type_or_const_args: {:?}", span_redundant_type_or_const_args);
+
+ let msg_types_or_consts = format!(
+ "remove {} {} argument{}",
+ if num_redundant_args == 1 { "this" } else { "these" },
+ "generic",
+ pluralize!(num_redundant_type_or_const_args),
+ );
+
+ err.span_suggestion(
+ span_redundant_type_or_const_args,
+ &msg_types_or_consts,
+ String::new(),
+ Applicability::MaybeIncorrect,
+ );
+ };
+
+ if remove_entire_generics {
let sm = self.tcx.sess.source_map();
let span = self
@@ -258,70 +710,16 @@ impl<'tcx> WrongNumberOfGenericArgs<'_, 'tcx> {
if self.gen_args.parenthesized { "parenthetical " } else { "" },
);
- (span, msg)
+ err.span_suggestion(span, &msg, String::new(), Applicability::MaybeIncorrect);
+ } else if redundant_lifetime_args && redundant_type_or_const_args {
+ remove_lifetime_args(err);
+ remove_type_or_const_args(err);
+ } else if redundant_lifetime_args {
+ remove_lifetime_args(err);
} else {
- // When it comes to removing particular argument(s) from the generics, there are two
- // edge cases we have to consider:
- //
- // When the first redundant argument is at the beginning or in the middle of the
- // generics, like so:
- //
- // ```
- // type Map = HashMap<String, String, String, String>;
- // ^^^^^^^^^^^^^^^^
- // | span must start with the argument
- // ```
- //
- // When the last redundant argument is at the ending of the generics, like so:
- //
- // ```
- // type Map = HashMap<String, String, String, String>;
- // ^^^^^^^^^^^^^^^^
- // | span must start with the comma
- // ```
-
- // Index of the first redundant argument
- let from_idx = self.args_offset + self.expected_max;
-
- // Index of the last redundant argument
- let to_idx = self.args_offset + self.provided - 1;
-
- assert!(from_idx <= to_idx);
-
- let (from, comma_eaten) = {
- let first_argument_starts_generics = from_idx == 0;
- let last_argument_ends_generics = to_idx + 1 == self.gen_args.args.len();
-
- if !first_argument_starts_generics && last_argument_ends_generics {
- (self.gen_args.args[from_idx - 1].span().hi(), true)
- } else {
- (self.gen_args.args[from_idx].span().lo(), false)
- }
- };
-
- let to = {
- let hi = self.gen_args.args[to_idx].span().hi();
-
- if comma_eaten {
- hi
- } else {
- self.gen_args.args.get(to_idx + 1).map(|arg| arg.span().lo()).unwrap_or(hi)
- }
- };
-
- let span = Span::new(from, to, self.span.ctxt());
-
- let msg = format!(
- "remove {} {} argument{}",
- if redundant_args_count == 1 { "this" } else { "these" },
- self.kind,
- pluralize!(redundant_args_count),
- );
-
- (span, msg)
- };
-
- err.span_suggestion(span, &msg, String::new(), Applicability::MaybeIncorrect);
+ assert!(redundant_type_or_const_args);
+ remove_type_or_const_args(err);
+ }
}
/// Builds the `type defined here` message.
@@ -334,7 +732,7 @@ impl<'tcx> WrongNumberOfGenericArgs<'_, 'tcx> {
let msg = {
let def_kind = self.tcx.def_kind(self.def_id).descr(self.def_id);
- let (quantifier, bound) = self.quantifier_and_bound();
+ let (quantifier, bound) = self.get_quantifier_and_bound();
let params = if bound == 0 {
String::new()
@@ -362,7 +760,7 @@ impl<'tcx> WrongNumberOfGenericArgs<'_, 'tcx> {
def_kind,
quantifier,
bound,
- self.kind,
+ self.kind(),
pluralize!(bound),
params,
)
diff --git a/src/test/ui/async-await/issues/issue-65159.rs b/src/test/ui/async-await/issues/issue-65159.rs
index ce3fa9180cb9e..1dbf5db6c32ed 100644
--- a/src/test/ui/async-await/issues/issue-65159.rs
+++ b/src/test/ui/async-await/issues/issue-65159.rs
@@ -3,7 +3,7 @@
// edition:2018
async fn copy() -> Result<()>
-//~^ ERROR this enum takes 2 type arguments but only 1 type argument was supplied
+//~^ ERROR this enum takes 2 generic arguments
{
Ok(())
//~^ ERROR type annotations needed
diff --git a/src/test/ui/async-await/issues/issue-65159.stderr b/src/test/ui/async-await/issues/issue-65159.stderr
index bcb4c292e2626..51fc34c48186c 100644
--- a/src/test/ui/async-await/issues/issue-65159.stderr
+++ b/src/test/ui/async-await/issues/issue-65159.stderr
@@ -1,17 +1,17 @@
-error[E0107]: this enum takes 2 type arguments but only 1 type argument was supplied
+error[E0107]: this enum takes 2 generic arguments but 1 generic argument was supplied
--> $DIR/issue-65159.rs:5:20
|
LL | async fn copy() -> Result<()>
- | ^^^^^^ -- supplied 1 type argument
+ | ^^^^^^ -- supplied 1 generic argument
| |
- | expected 2 type arguments
+ | expected 2 generic arguments
|
-note: enum defined here, with 2 type parameters: `T`, `E`
+note: enum defined here, with 2 generic parameters: `T`, `E`
--> $SRC_DIR/core/src/result.rs:LL:COL
|
LL | pub enum Result<T, E> {
| ^^^^^^ - -
-help: add missing type argument
+help: add missing generic argument
|
LL | async fn copy() -> Result<(), E>
| ^^^
diff --git a/src/test/ui/borrowck/issue-82126-mismatched-subst-and-hir.rs b/src/test/ui/borrowck/issue-82126-mismatched-subst-and-hir.rs
index 2e6b88a4beba8..569769b8213bf 100644
--- a/src/test/ui/borrowck/issue-82126-mismatched-subst-and-hir.rs
+++ b/src/test/ui/borrowck/issue-82126-mismatched-subst-and-hir.rs
@@ -15,7 +15,7 @@ impl MarketMultiplier {
async fn buy_lock(generator: &Mutex<MarketMultiplier>) -> LockedMarket<'_> {
//~^ ERROR this struct takes 0 lifetime arguments but 1 lifetime argument was supplied
- //~^^ ERROR this struct takes 1 type argument but 0 type arguments were supplied
+ //~^^ ERROR this struct takes 1 generic argument but 0 generic arguments were supplied
LockedMarket(generator.lock().unwrap().buy())
//~^ ERROR cannot return value referencing temporary value
}
diff --git a/src/test/ui/borrowck/issue-82126-mismatched-subst-and-hir.stderr b/src/test/ui/borrowck/issue-82126-mismatched-subst-and-hir.stderr
index b6844f50488e1..0d506a0956d21 100644
--- a/src/test/ui/borrowck/issue-82126-mismatched-subst-and-hir.stderr
+++ b/src/test/ui/borrowck/issue-82126-mismatched-subst-and-hir.stderr
@@ -12,18 +12,18 @@ note: struct defined here, with 0 lifetime parameters
LL | struct LockedMarket<T>(T);
| ^^^^^^^^^^^^
-error[E0107]: this struct takes 1 type argument but 0 type arguments were supplied
+error[E0107]: this struct takes 1 generic argument but 0 generic arguments were supplied
--> $DIR/issue-82126-mismatched-subst-and-hir.rs:16:59
|
LL | async fn buy_lock(generator: &Mutex<MarketMultiplier>) -> LockedMarket<'_> {
- | ^^^^^^^^^^^^ expected 1 type argument
+ | ^^^^^^^^^^^^ expected 1 generic argument
|
-note: struct defined here, with 1 type parameter: `T`
+note: struct defined here, with 1 generic parameter: `T`
--> $DIR/issue-82126-mismatched-subst-and-hir.rs:23:8
|
LL | struct LockedMarket<T>(T);
| ^^^^^^^^^^^^ -
-help: add missing type argument
+help: add missing generic argument
|
LL | async fn buy_lock(generator: &Mutex<MarketMultiplier>) -> LockedMarket<'_, T> {
| ^^^
diff --git a/src/test/ui/const-generics/incorrect-number-of-const-args.full.stderr b/src/test/ui/const-generics/incorrect-number-of-const-args.full.stderr
index dd7e63480eb20..9deda56cd0df2 100644
--- a/src/test/ui/const-generics/incorrect-number-of-const-args.full.stderr
+++ b/src/test/ui/const-generics/incorrect-number-of-const-args.full.stderr
@@ -1,30 +1,30 @@
-error[E0107]: this function takes 2 const arguments but only 1 const argument was supplied
+error[E0107]: this function takes 2 generic arguments but 1 generic argument was supplied
--> $DIR/incorrect-number-of-const-args.rs:11:5
|
LL | foo::<0>();
- | ^^^ - supplied 1 const argument
+ | ^^^ - supplied 1 generic argument
| |
- | expected 2 const arguments
+ | expected 2 generic arguments
|
-note: function defined here, with 2 const parameters: `X`, `Y`
+note: function defined here, with 2 generic parameters: `X`, `Y`
--> $DIR/incorrect-number-of-const-args.rs:6:4
|
LL | fn foo<const X: usize, const Y: usize>() -> usize {
| ^^^ - -
-help: add missing const argument
+help: add missing generic argument
|
LL | foo::<0, Y>();
| ^^^
-error[E0107]: this function takes 2 const arguments but 3 const arguments were supplied
+error[E0107]: this function takes 2 generic arguments but 3 generic arguments were supplied
--> $DIR/incorrect-number-of-const-args.rs:14:5
|
LL | foo::<0, 0, 0>();
- | ^^^ --- help: remove this const argument
+ | ^^^ - help: remove this generic argument
| |
- | expected 2 const arguments
+ | expected 2 generic arguments
|
-note: function defined here, with 2 const parameters: `X`, `Y`
+note: function defined here, with 2 generic parameters: `X`, `Y`
--> $DIR/incorrect-number-of-const-args.rs:6:4
|
LL | fn foo<const X: usize, const Y: usize>() -> usize {
diff --git a/src/test/ui/const-generics/incorrect-number-of-const-args.min.stderr b/src/test/ui/const-generics/incorrect-number-of-const-args.min.stderr
index dd7e63480eb20..9deda56cd0df2 100644
--- a/src/test/ui/const-generics/incorrect-number-of-const-args.min.stderr
+++ b/src/test/ui/const-generics/incorrect-number-of-const-args.min.stderr
@@ -1,30 +1,30 @@
-error[E0107]: this function takes 2 const arguments but only 1 const argument was supplied
+error[E0107]: this function takes 2 generic arguments but 1 generic argument was supplied
--> $DIR/incorrect-number-of-const-args.rs:11:5
|
LL | foo::<0>();
- | ^^^ - supplied 1 const argument
+ | ^^^ - supplied 1 generic argument
| |
- | expected 2 const arguments
+ | expected 2 generic arguments
|
-note: function defined here, with 2 const parameters: `X`, `Y`
+note: function defined here, with 2 generic parameters: `X`, `Y`
--> $DIR/incorrect-number-of-const-args.rs:6:4
|
LL | fn foo<const X: usize, const Y: usize>() -> usize {
| ^^^ - -
-help: add missing const argument
+help: add missing generic argument
|
LL | foo::<0, Y>();
| ^^^
-error[E0107]: this function takes 2 const arguments but 3 const arguments were supplied
+error[E0107]: this function takes 2 generic arguments but 3 generic arguments were supplied
--> $DIR/incorrect-number-of-const-args.rs:14:5
|
LL | foo::<0, 0, 0>();
- | ^^^ --- help: remove this const argument
+ | ^^^ - help: remove this generic argument
| |
- | expected 2 const arguments
+ | expected 2 generic arguments
|
-note: function defined here, with 2 const parameters: `X`, `Y`
+note: function defined here, with 2 generic parameters: `X`, `Y`
--> $DIR/incorrect-number-of-const-args.rs:6:4
|
LL | fn foo<const X: usize, const Y: usize>() -> usize {
diff --git a/src/test/ui/const-generics/incorrect-number-of-const-args.rs b/src/test/ui/const-generics/incorrect-number-of-const-args.rs
index 3114e716845bf..305559d93fdad 100644
--- a/src/test/ui/const-generics/incorrect-number-of-const-args.rs
+++ b/src/test/ui/const-generics/incorrect-number-of-const-args.rs
@@ -9,8 +9,8 @@ fn foo<const X: usize, const Y: usize>() -> usize {
fn main() {
foo::<0>();
- //~^ ERROR this function takes 2 const arguments but only 1 const argument was supplied
+ //~^ ERROR this function takes 2
foo::<0, 0, 0>();
- //~^ ERROR this function takes 2 const arguments but 3 const arguments were supplied
+ //~^ ERROR this function takes 2
}
diff --git a/src/test/ui/const-generics/invalid-const-arg-for-type-param.rs b/src/test/ui/const-generics/invalid-const-arg-for-type-param.rs
index b67a1f153ffef..7d4dc98f396b4 100644
--- a/src/test/ui/const-generics/invalid-const-arg-for-type-param.rs
+++ b/src/test/ui/const-generics/invalid-const-arg-for-type-param.rs
@@ -4,11 +4,11 @@ struct S;
fn main() {
let _: u32 = 5i32.try_into::<32>().unwrap();
- //~^ ERROR this associated function takes 0 const arguments but 1 const argument was supplied
+ //~^ ERROR this associated function takes
S.f::<0>();
//~^ ERROR no method named `f`
S::<0>;
- //~^ ERROR this struct takes 0 const arguments but 1 const argument was supplied
+ //~^ ERROR this struct takes 0
}
diff --git a/src/test/ui/const-generics/invalid-const-arg-for-type-param.stderr b/src/test/ui/const-generics/invalid-const-arg-for-type-param.stderr
index a75da91caa84f..aa5cebd873e31 100644
--- a/src/test/ui/const-generics/invalid-const-arg-for-type-param.stderr
+++ b/src/test/ui/const-generics/invalid-const-arg-for-type-param.stderr
@@ -1,12 +1,12 @@
-error[E0107]: this associated function takes 0 const arguments but 1 const argument was supplied
+error[E0107]: this associated function takes 0 generic arguments but 1 generic argument was supplied
--> $DIR/invalid-const-arg-for-type-param.rs:6:23
|
LL | let _: u32 = 5i32.try_into::<32>().unwrap();
| ^^^^^^^^------ help: remove these generics
| |
- | expected 0 const arguments
+ | expected 0 generic arguments
|
-note: associated function defined here, with 0 const parameters
+note: associated function defined here, with 0 generic parameters
--> $SRC_DIR/core/src/convert/mod.rs:LL:COL
|
LL | fn try_into(self) -> Result<T, Self::Error>;
@@ -21,15 +21,15 @@ LL | struct S;
LL | S.f::<0>();
| ^ method not found in `S`
-error[E0107]: this struct takes 0 const arguments but 1 const argument was supplied
+error[E0107]: this struct takes 0 generic arguments but 1 generic argument was supplied
--> $DIR/invalid-const-arg-for-type-param.rs:12:5
|
LL | S::<0>;
| ^----- help: remove these generics
| |
- | expected 0 const arguments
+ | expected 0 generic arguments
|
-note: struct defined here, with 0 const parameters
+note: struct defined here, with 0 generic parameters
--> $DIR/invalid-const-arg-for-type-param.rs:3:8
|
LL | struct S;
diff --git a/src/test/ui/const-generics/invalid-constant-in-args.stderr b/src/test/ui/const-generics/invalid-constant-in-args.stderr
index 57c1af36d61cc..1400d2bf5a7ba 100644
--- a/src/test/ui/const-generics/invalid-constant-in-args.stderr
+++ b/src/test/ui/const-generics/invalid-constant-in-args.stderr
@@ -2,7 +2,7 @@ error[E0107]: this struct takes 1 generic argument but 2 generic arguments were
--> $DIR/invalid-constant-in-args.rs:4:12
|
LL | let _: Cell<&str, "a"> = Cell::new("");
- | ^^^^ ----- help: remove this generic argument
+ | ^^^^ --- help: remove this generic argument
| |
| expected 1 generic argument
|
diff --git a/src/test/ui/const-generics/issues/issue-76595.rs b/src/test/ui/const-generics/issues/issue-76595.rs
index d95d675ddad76..2d7051c3a245c 100644
--- a/src/test/ui/const-generics/issues/issue-76595.rs
+++ b/src/test/ui/const-generics/issues/issue-76595.rs
@@ -13,5 +13,5 @@ fn test<T, const P: usize>() where Bool<{core::mem::size_of::<T>() > 4}>: True {
fn main() {
test::<2>();
- //~^ ERROR this function takes 2 generic arguments but only 1 generic argument was supplied
+ //~^ ERROR this function takes 2 generic arguments
}
diff --git a/src/test/ui/const-generics/issues/issue-76595.stderr b/src/test/ui/const-generics/issues/issue-76595.stderr
index 9d95e5a014de4..01a0f6bcba9d8 100644
--- a/src/test/ui/const-generics/issues/issue-76595.stderr
+++ b/src/test/ui/const-generics/issues/issue-76595.stderr
@@ -1,4 +1,4 @@
-error[E0107]: this function takes 2 generic arguments but only 1 generic argument was supplied
+error[E0107]: this function takes 2 generic arguments but 1 generic argument was supplied
--> $DIR/issue-76595.rs:15:5
|
LL | test::<2>();
diff --git a/src/test/ui/constructor-lifetime-args.rs b/src/test/ui/constructor-lifetime-args.rs
index d038269382be5..a824a44c9c222 100644
--- a/src/test/ui/constructor-lifetime-args.rs
+++ b/src/test/ui/constructor-lifetime-args.rs
@@ -15,12 +15,12 @@ enum E<'a, 'b> {
fn main() {
S(&0, &0); // OK
S::<'static>(&0, &0);
- //~^ ERROR this struct takes 2 lifetime arguments but only 1 lifetime argument was supplied
+ //~^ ERROR this struct takes 2 lifetime arguments
S::<'static, 'static, 'static>(&0, &0);
- //~^ ERROR this struct takes 2 lifetime arguments but 3 lifetime arguments were supplied
+ //~^ ERROR this struct takes 2 lifetime arguments
E::V(&0); // OK
E::V::<'static>(&0);
- //~^ ERROR this enum takes 2 lifetime arguments but only 1 lifetime argument was supplied
+ //~^ ERROR this enum takes 2 lifetime arguments
E::V::<'static, 'static, 'static>(&0);
- //~^ ERROR this enum takes 2 lifetime arguments but 3 lifetime arguments were supplied
+ //~^ ERROR this enum takes 2 lifetime arguments
}
diff --git a/src/test/ui/constructor-lifetime-args.stderr b/src/test/ui/constructor-lifetime-args.stderr
index 378b07694e6fe..f33aa4953e4f5 100644
--- a/src/test/ui/constructor-lifetime-args.stderr
+++ b/src/test/ui/constructor-lifetime-args.stderr
@@ -1,4 +1,4 @@
-error[E0107]: this struct takes 2 lifetime arguments but only 1 lifetime argument was supplied
+error[E0107]: this struct takes 2 lifetime arguments but 1 lifetime argument was supplied
--> $DIR/constructor-lifetime-args.rs:17:5
|
LL | S::<'static>(&0, &0);
@@ -20,7 +20,7 @@ error[E0107]: this struct takes 2 lifetime arguments but 3 lifetime arguments we
--> $DIR/constructor-lifetime-args.rs:19:5
|
LL | S::<'static, 'static, 'static>(&0, &0);
- | ^ --------- help: remove this lifetime argument
+ | ^ ------- help: remove this lifetime argument
| |
| expected 2 lifetime arguments
|
@@ -30,7 +30,7 @@ note: struct defined here, with 2 lifetime parameters: `'a`, `'b`
LL | struct S<'a, 'b>(&'a u8, &'b u8);
| ^ -- --
-error[E0107]: this enum takes 2 lifetime arguments but only 1 lifetime argument was supplied
+error[E0107]: this enum takes 2 lifetime arguments but 1 lifetime argument was supplied
--> $DIR/constructor-lifetime-args.rs:22:8
|
LL | E::V::<'static>(&0);
@@ -52,7 +52,7 @@ error[E0107]: this enum takes 2 lifetime arguments but 3 lifetime arguments were
--> $DIR/constructor-lifetime-args.rs:24:8
|
LL | E::V::<'static, 'static, 'static>(&0);
- | ^ --------- help: remove this lifetime argument
+ | ^ ------- help: remove this lifetime argument
| |
| expected 2 lifetime arguments
|
diff --git a/src/test/ui/error-codes/E0107.rs b/src/test/ui/error-codes/E0107.rs
index c3dde72599b71..f7f6afa860e0b 100644
--- a/src/test/ui/error-codes/E0107.rs
+++ b/src/test/ui/error-codes/E0107.rs
@@ -9,15 +9,15 @@ enum Bar {
struct Baz<'a, 'b, 'c> {
buzz: Buzz<'a>,
- //~^ ERROR this struct takes 2 lifetime arguments but only 1 lifetime argument was supplied
+ //~^ ERROR this struct takes 2 lifetime arguments
//~| HELP add missing lifetime argument
bar: Bar<'a>,
- //~^ ERROR this enum takes 0 lifetime arguments but 1 lifetime argument was supplied
+ //~^ ERROR this enum takes 0 lifetime arguments
//~| HELP remove these generics
foo2: Foo<'a, 'b, 'c>,
- //~^ ERROR this struct takes 1 lifetime argument but 3 lifetime arguments were supplied
+ //~^ ERROR this struct takes 1 lifetime argument
//~| HELP remove these lifetime arguments
}
diff --git a/src/test/ui/error-codes/E0107.stderr b/src/test/ui/error-codes/E0107.stderr
index 30a2768d06058..299776b08f2da 100644
--- a/src/test/ui/error-codes/E0107.stderr
+++ b/src/test/ui/error-codes/E0107.stderr
@@ -1,4 +1,4 @@
-error[E0107]: this struct takes 2 lifetime arguments but only 1 lifetime argument was supplied
+error[E0107]: this struct takes 2 lifetime arguments but 1 lifetime argument was supplied
--> $DIR/E0107.rs:11:11
|
LL | buzz: Buzz<'a>,
@@ -13,7 +13,7 @@ LL | struct Buzz<'a, 'b>(&'a str, &'b str);
| ^^^^ -- --
help: add missing lifetime argument
|
-LL | buzz: Buzz<'a, 'b>,
+LL | buzz: Buzz<'a, 'a>,
| ^^^^
error[E0107]: this enum takes 0 lifetime arguments but 1 lifetime argument was supplied
@@ -34,7 +34,7 @@ error[E0107]: this struct takes 1 lifetime argument but 3 lifetime arguments wer
--> $DIR/E0107.rs:19:11
|
LL | foo2: Foo<'a, 'b, 'c>,
- | ^^^ -------- help: remove these lifetime arguments
+ | ^^^ ------ help: remove these lifetime arguments
| |
| expected 1 lifetime argument
|
diff --git a/src/test/ui/generic-associated-types/gat-trait-path-missing-lifetime.rs b/src/test/ui/generic-associated-types/gat-trait-path-missing-lifetime.rs
index e69e355ba48e5..484790501b98e 100644
--- a/src/test/ui/generic-associated-types/gat-trait-path-missing-lifetime.rs
+++ b/src/test/ui/generic-associated-types/gat-trait-path-missing-lifetime.rs
@@ -3,14 +3,14 @@
trait X {
type Y<'a>;
- //~^ ERROR missing generics for
- //~| ERROR missing generics for
fn foo<'a>(t : Self::Y<'a>) -> Self::Y<'a> { t }
}
impl<T> X for T {
fn foo<'a, T1: X<Y = T1>>(t : T1) -> T1::Y<'a> {
+ //~^ ERROR missing generics for associated type
+ //~^^ ERROR missing generics for associated type
t
}
}
diff --git a/src/test/ui/generic-associated-types/gat-trait-path-missing-lifetime.stderr b/src/test/ui/generic-associated-types/gat-trait-path-missing-lifetime.stderr
index 9c6e2ce3e17a3..56b5551cd3fde 100644
--- a/src/test/ui/generic-associated-types/gat-trait-path-missing-lifetime.stderr
+++ b/src/test/ui/generic-associated-types/gat-trait-path-missing-lifetime.stderr
@@ -8,36 +8,36 @@ LL | #![feature(generic_associated_types)]
= note: see issue #44265 <https://github.com/rust-lang/rust/issues/44265> for more information
error[E0107]: missing generics for associated type `X::Y`
- --> $DIR/gat-trait-path-missing-lifetime.rs:5:8
+ --> $DIR/gat-trait-path-missing-lifetime.rs:11:20
|
-LL | type Y<'a>;
- | ^ expected 1 lifetime argument
+LL | fn foo<'a, T1: X<Y = T1>>(t : T1) -> T1::Y<'a> {
+ | ^ expected 1 lifetime argument
|
note: associated type defined here, with 1 lifetime parameter: `'a`
--> $DIR/gat-trait-path-missing-lifetime.rs:5:8
|
LL | type Y<'a>;
| ^ --
-help: use angle brackets to add missing lifetime argument
+help: add missing lifetime argument
|
-LL | type Y<'a><'a>;
- | ^^^^
+LL | fn foo<'a, T1: X<Y<'a> = T1>>(t : T1) -> T1::Y<'a> {
+ | ^^^^^
error[E0107]: missing generics for associated type `X::Y`
- --> $DIR/gat-trait-path-missing-lifetime.rs:5:8
+ --> $DIR/gat-trait-path-missing-lifetime.rs:11:20
|
-LL | type Y<'a>;
- | ^ expected 1 lifetime argument
+LL | fn foo<'a, T1: X<Y = T1>>(t : T1) -> T1::Y<'a> {
+ | ^ expected 1 lifetime argument
|
note: associated type defined here, with 1 lifetime parameter: `'a`
--> $DIR/gat-trait-path-missing-lifetime.rs:5:8
|
LL | type Y<'a>;
| ^ --
-help: use angle brackets to add missing lifetime argument
+help: add missing lifetime argument
|
-LL | type Y<'a><'a>;
- | ^^^^
+LL | fn foo<'a, T1: X<Y<'a> = T1>>(t : T1) -> T1::Y<'a> {
+ | ^^^^^
error: aborting due to 2 previous errors; 1 warning emitted
diff --git a/src/test/ui/generic-associated-types/gat-trait-path-parenthesised-args.rs b/src/test/ui/generic-associated-types/gat-trait-path-parenthesised-args.rs
index 40ed42c9ce017..f1af6860284cb 100644
--- a/src/test/ui/generic-associated-types/gat-trait-path-parenthesised-args.rs
+++ b/src/test/ui/generic-associated-types/gat-trait-path-parenthesised-args.rs
@@ -3,13 +3,13 @@
trait X {
type Y<'a>;
- //~^ ERROR this associated type
- //~| ERROR this associated type
}
fn foo<'a>(arg: Box<dyn X<Y('a) = &'a ()>>) {}
//~^ ERROR: lifetime in trait object type must be followed by `+`
//~| ERROR: parenthesized generic arguments cannot be used
+ //~| ERROR this associated type takes 0 generic arguments but 1 generic argument
+ //~| ERROR this associated type takes 1 lifetime argument but 0 lifetime arguments
//~| WARNING: trait objects without an explicit `dyn` are deprecated
//~| WARNING: this was previously accepted by the compiler
diff --git a/src/test/ui/generic-associated-types/gat-trait-path-parenthesised-args.stderr b/src/test/ui/generic-associated-types/gat-trait-path-parenthesised-args.stderr
index 0e95c54d8114f..72855a742561c 100644
--- a/src/test/ui/generic-associated-types/gat-trait-path-parenthesised-args.stderr
+++ b/src/test/ui/generic-associated-types/gat-trait-path-parenthesised-args.stderr
@@ -1,11 +1,11 @@
error: lifetime in trait object type must be followed by `+`
- --> $DIR/gat-trait-path-parenthesised-args.rs:10:29
+ --> $DIR/gat-trait-path-parenthesised-args.rs:8:29
|
LL | fn foo<'a>(arg: Box<dyn X<Y('a) = &'a ()>>) {}
| ^^
error: parenthesized generic arguments cannot be used in associated type constraints
- --> $DIR/gat-trait-path-parenthesised-args.rs:10:27
+ --> $DIR/gat-trait-path-parenthesised-args.rs:8:27
|
LL | fn foo<'a>(arg: Box<dyn X<Y('a) = &'a ()>>) {}
| ^^^^^
@@ -20,7 +20,7 @@ LL | #![feature(generic_associated_types)]
= note: see issue #44265 <https://github.com/rust-lang/rust/issues/44265> for more information
warning: trait objects without an explicit `dyn` are deprecated
- --> $DIR/gat-trait-path-parenthesised-args.rs:10:29
+ --> $DIR/gat-trait-path-parenthesised-args.rs:8:29
|
LL | fn foo<'a>(arg: Box<dyn X<Y('a) = &'a ()>>) {}
| ^^ help: use `dyn`: `dyn 'a`
@@ -30,10 +30,10 @@ LL | fn foo<'a>(arg: Box<dyn X<Y('a) = &'a ()>>) {}
= note: for more information, see issue #80165 <https://github.com/rust-lang/rust/issues/80165>
error[E0107]: this associated type takes 1 lifetime argument but 0 lifetime arguments were supplied
- --> $DIR/gat-trait-path-parenthesised-args.rs:5:8
+ --> $DIR/gat-trait-path-parenthesised-args.rs:8:27
|
-LL | type Y<'a>;
- | ^ expected 1 lifetime argument
+LL | fn foo<'a>(arg: Box<dyn X<Y('a) = &'a ()>>) {}
+ | ^ expected 1 lifetime argument
|
note: associated type defined here, with 1 lifetime parameter: `'a`
--> $DIR/gat-trait-path-parenthesised-args.rs:5:8
@@ -42,24 +42,18 @@ LL | type Y<'a>;
| ^ --
help: add missing lifetime argument
|
-LL | fn foo<'a>(arg: Box<dyn X<Y('a'a) = &'a ()>>) {}
- | ^^
+LL | fn foo<'a>(arg: Box<dyn X<Y('a, 'a) = &'a ()>>) {}
+ | ^^^
-error[E0107]: this associated type takes 0 type arguments but 1 type argument was supplied
- --> $DIR/gat-trait-path-parenthesised-args.rs:5:8
+error[E0107]: this associated type takes 0 generic arguments but 1 generic argument was supplied
+ --> $DIR/gat-trait-path-parenthesised-args.rs:8:27
|
-LL | type Y<'a>;
- | ________^-
- | | |
- | | expected 0 type arguments
-LL | |
-LL | |
-LL | | }
-LL | |
-LL | | fn foo<'a>(arg: Box<dyn X<Y('a) = &'a ()>>) {}
- | |_________________________________________- help: remove these generics
+LL | fn foo<'a>(arg: Box<dyn X<Y('a) = &'a ()>>) {}
+ | ^-------------- help: remove these generics
+ | |
+ | expected 0 generic arguments
|
-note: associated type defined here, with 0 type parameters
+note: associated type defined here, with 0 generic parameters
--> $DIR/gat-trait-path-parenthesised-args.rs:5:8
|
LL | type Y<'a>;
diff --git a/src/test/ui/generic-associated-types/issue-71176.rs b/src/test/ui/generic-associated-types/issue-71176.rs
index 470476bf476a0..c767bef1552ed 100644
--- a/src/test/ui/generic-associated-types/issue-71176.rs
+++ b/src/test/ui/generic-associated-types/issue-71176.rs
@@ -3,7 +3,6 @@
trait Provider {
type A<'a>;
- //~^ ERROR: missing generics for associated type
}
impl Provider for () {
@@ -12,6 +11,7 @@ impl Provider for () {
struct Holder<B> {
inner: Box<dyn Provider<A = B>>,
+ //~^ ERROR: missing generics for associated type
}
fn main() {
diff --git a/src/test/ui/generic-associated-types/issue-71176.stderr b/src/test/ui/generic-associated-types/issue-71176.stderr
index dd19dd4ad8e83..2df800d065f40 100644
--- a/src/test/ui/generic-associated-types/issue-71176.stderr
+++ b/src/test/ui/generic-associated-types/issue-71176.stderr
@@ -1,18 +1,18 @@
error[E0107]: missing generics for associated type `Provider::A`
- --> $DIR/issue-71176.rs:5:10
+ --> $DIR/issue-71176.rs:13:27
|
-LL | type A<'a>;
- | ^ expected 1 lifetime argument
+LL | inner: Box<dyn Provider<A = B>>,
+ | ^ expected 1 lifetime argument
|
note: associated type defined here, with 1 lifetime parameter: `'a`
--> $DIR/issue-71176.rs:5:10
|
LL | type A<'a>;
| ^ --
-help: use angle brackets to add missing lifetime argument
+help: add missing lifetime argument
|
-LL | type A<'a><'a>;
- | ^^^^
+LL | inner: Box<dyn Provider<A<'a> = B>>,
+ | ^^^^^
error: aborting due to previous error
diff --git a/src/test/ui/generic-associated-types/issue-76535.rs b/src/test/ui/generic-associated-types/issue-76535.rs
index 9643c82db7732..3db3c38216aaa 100644
--- a/src/test/ui/generic-associated-types/issue-76535.rs
+++ b/src/test/ui/generic-associated-types/issue-76535.rs
@@ -5,7 +5,6 @@ pub trait SubTrait {}
pub trait SuperTrait {
type SubType<'a>: SubTrait;
- //~^ ERROR missing generics for associated
fn get_sub<'a>(&'a mut self) -> Self::SubType<'a>;
}
@@ -36,6 +35,7 @@ impl SuperTrait for SuperStruct {
fn main() {
let sub: Box<dyn SuperTrait<SubType = SubStruct>> = Box::new(SuperStruct::new(0));
- //~^ ERROR the trait `SuperTrait` cannot be made into an object
- //~^^ ERROR the trait `SuperTrait` cannot be made into an object
+ //~^ ERROR missing generics for associated type
+ //~^^ ERROR the trait
+ //~| ERROR the trait
}
diff --git a/src/test/ui/generic-associated-types/issue-76535.stderr b/src/test/ui/generic-associated-types/issue-76535.stderr
index d31560f12f0bb..d9829e5960558 100644
--- a/src/test/ui/generic-associated-types/issue-76535.stderr
+++ b/src/test/ui/generic-associated-types/issue-76535.stderr
@@ -8,23 +8,23 @@ LL | #![feature(generic_associated_types)]
= note: see issue #44265 <https://github.com/rust-lang/rust/issues/44265> for more information
error[E0107]: missing generics for associated type `SuperTrait::SubType`
- --> $DIR/issue-76535.rs:7:10
+ --> $DIR/issue-76535.rs:37:33
|
-LL | type SubType<'a>: SubTrait;
- | ^^^^^^^ expected 1 lifetime argument
+LL | let sub: Box<dyn SuperTrait<SubType = SubStruct>> = Box::new(SuperStruct::new(0));
+ | ^^^^^^^ expected 1 lifetime argument
|
note: associated type defined here, with 1 lifetime parameter: `'a`
--> $DIR/issue-76535.rs:7:10
|
LL | type SubType<'a>: SubTrait;
| ^^^^^^^ --
-help: use angle brackets to add missing lifetime argument
+help: add missing lifetime argument
|
-LL | type SubType<'a><'a>: SubTrait;
- | ^^^^
+LL | let sub: Box<dyn SuperTrait<SubType<'a> = SubStruct>> = Box::new(SuperStruct::new(0));
+ | ^^^^^^^^^^^
error[E0038]: the trait `SuperTrait` cannot be made into an object
- --> $DIR/issue-76535.rs:38:14
+ --> $DIR/issue-76535.rs:37:14
|
LL | let sub: Box<dyn SuperTrait<SubType = SubStruct>> = Box::new(SuperStruct::new(0));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `SuperTrait` cannot be made into an object
@@ -39,7 +39,7 @@ LL | type SubType<'a>: SubTrait;
| ^^^^^^^ ...because it contains the generic associated type `SubType`
error[E0038]: the trait `SuperTrait` cannot be made into an object
- --> $DIR/issue-76535.rs:38:57
+ --> $DIR/issue-76535.rs:37:57
|
LL | let sub: Box<dyn SuperTrait<SubType = SubStruct>> = Box::new(SuperStruct::new(0));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `SuperTrait` cannot be made into an object
diff --git a/src/test/ui/generic-associated-types/issue-78671.rs b/src/test/ui/generic-associated-types/issue-78671.rs
index 4e47d3c665505..310dd51ea0c82 100644
--- a/src/test/ui/generic-associated-types/issue-78671.rs
+++ b/src/test/ui/generic-associated-types/issue-78671.rs
@@ -3,11 +3,11 @@
trait CollectionFamily {
type Member<T>;
- //~^ ERROR: missing generics for associated type
}
fn floatify() {
Box::new(Family) as &dyn CollectionFamily<Member=usize>
- //~^ the trait `CollectionFamily` cannot be made into an object
+ //~^ ERROR: missing generics for associated type
+ //~| ERROR: the trait `CollectionFamily` cannot be made into an object
}
struct Family;
diff --git a/src/test/ui/generic-associated-types/issue-78671.stderr b/src/test/ui/generic-associated-types/issue-78671.stderr
index c9febfb59af62..0a231d22b6268 100644
--- a/src/test/ui/generic-associated-types/issue-78671.stderr
+++ b/src/test/ui/generic-associated-types/issue-78671.stderr
@@ -1,21 +1,21 @@
error[E0107]: missing generics for associated type `CollectionFamily::Member`
- --> $DIR/issue-78671.rs:5:10
+ --> $DIR/issue-78671.rs:8:47
|
-LL | type Member<T>;
- | ^^^^^^ expected 1 type argument
+LL | Box::new(Family) as &dyn CollectionFamily<Member=usize>
+ | ^^^^^^ expected 1 generic argument
|
-note: associated type defined here, with 1 type parameter: `T`
+note: associated type defined here, with 1 generic parameter: `T`
--> $DIR/issue-78671.rs:5:10
|
LL | type Member<T>;
| ^^^^^^ -
-help: use angle brackets to add missing type argument
+help: add missing generic argument
|
-LL | type Member<T><T>;
- | ^^^
+LL | Box::new(Family) as &dyn CollectionFamily<Member<T>=usize>
+ | ^^^^^^^^^
error[E0038]: the trait `CollectionFamily` cannot be made into an object
- --> $DIR/issue-78671.rs:9:25
+ --> $DIR/issue-78671.rs:8:25
|
LL | Box::new(Family) as &dyn CollectionFamily<Member=usize>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `CollectionFamily` cannot be made into an object
diff --git a/src/test/ui/generic-associated-types/issue-79422.rs b/src/test/ui/generic-associated-types/issue-79422.rs
index b2ba3c24abbe1..216e426ada265 100644
--- a/src/test/ui/generic-associated-types/issue-79422.rs
+++ b/src/test/ui/generic-associated-types/issue-79422.rs
@@ -19,7 +19,6 @@ impl<'a, T> RefCont<'a, T> for Box<T> {
trait MapLike<K, V> {
type VRefCont<'a>: RefCont<'a, V>;
- //~^ ERROR missing generics
fn get<'a>(&'a self, key: &K) -> Option<Self::VRefCont<'a>>;
}
@@ -42,6 +41,7 @@ impl<K, V: Default> MapLike<K, V> for Source {
fn main() {
let m = Box::new(std::collections::BTreeMap::<u8, u8>::new())
as Box<dyn MapLike<u8, u8, VRefCont = dyn RefCont<'_, u8>>>;
- //~^^ the trait `MapLike` cannot be made into an object
- //~^^ the trait `MapLike` cannot be made into an object
+ //~^ ERROR missing generics for associated type
+ //~^^ ERROR the trait
+ //~^^^^ ERROR the trait
}
diff --git a/src/test/ui/generic-associated-types/issue-79422.stderr b/src/test/ui/generic-associated-types/issue-79422.stderr
index 4973ae19729ac..11b4a519d5188 100644
--- a/src/test/ui/generic-associated-types/issue-79422.stderr
+++ b/src/test/ui/generic-associated-types/issue-79422.stderr
@@ -1,21 +1,21 @@
error[E0107]: missing generics for associated type `MapLike::VRefCont`
- --> $DIR/issue-79422.rs:21:10
+ --> $DIR/issue-79422.rs:43:36
|
-LL | type VRefCont<'a>: RefCont<'a, V>;
- | ^^^^^^^^ expected 1 lifetime argument
+LL | as Box<dyn MapLike<u8, u8, VRefCont = dyn RefCont<'_, u8>>>;
+ | ^^^^^^^^ expected 1 lifetime argument
|
note: associated type defined here, with 1 lifetime parameter: `'a`
--> $DIR/issue-79422.rs:21:10
|
LL | type VRefCont<'a>: RefCont<'a, V>;
| ^^^^^^^^ --
-help: use angle brackets to add missing lifetime argument
+help: add missing lifetime argument
|
-LL | type VRefCont<'a><'a>: RefCont<'a, V>;
- | ^^^^
+LL | as Box<dyn MapLike<u8, u8, VRefCont<'a> = dyn RefCont<'_, u8>>>;
+ | ^^^^^^^^^^^^
error[E0038]: the trait `MapLike` cannot be made into an object
- --> $DIR/issue-79422.rs:44:12
+ --> $DIR/issue-79422.rs:43:12
|
LL | as Box<dyn MapLike<u8, u8, VRefCont = dyn RefCont<'_, u8>>>;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `MapLike` cannot be made into an object
@@ -30,7 +30,7 @@ LL | type VRefCont<'a>: RefCont<'a, V>;
| ^^^^^^^^ ...because it contains the generic associated type `VRefCont`
error[E0038]: the trait `MapLike` cannot be made into an object
- --> $DIR/issue-79422.rs:43:13
+ --> $DIR/issue-79422.rs:42:13
|
LL | let m = Box::new(std::collections::BTreeMap::<u8, u8>::new())
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `MapLike` cannot be made into an object
diff --git a/src/test/ui/generic-associated-types/issue-79636-1.rs b/src/test/ui/generic-associated-types/issue-79636-1.rs
index 17f9387e29204..412a9f8257c8a 100644
--- a/src/test/ui/generic-associated-types/issue-79636-1.rs
+++ b/src/test/ui/generic-associated-types/issue-79636-1.rs
@@ -4,7 +4,6 @@
trait Monad {
type Unwrapped;
type Wrapped<B>;
- //~^ ERROR: missing generics for associated type `Monad::Wrapped`
fn bind<B, F>(self, f: F) -> Self::Wrapped<B> {
todo!()
@@ -15,6 +14,7 @@ fn join<MOuter, MInner, A>(outer: MOuter) -> MOuter::Wrapped<A>
where
MOuter: Monad<Unwrapped = MInner>,
MInner: Monad<Unwrapped = A, Wrapped = MOuter::Wrapped<A>>,
+ //~^ ERROR: missing generics for associated type `Monad::Wrapped`
{
outer.bind(|inner| inner)
}
diff --git a/src/test/ui/generic-associated-types/issue-79636-1.stderr b/src/test/ui/generic-associated-types/issue-79636-1.stderr
index 58eeb43f70d66..b7a0ef0a6d674 100644
--- a/src/test/ui/generic-associated-types/issue-79636-1.stderr
+++ b/src/test/ui/generic-associated-types/issue-79636-1.stderr
@@ -1,18 +1,18 @@
error[E0107]: missing generics for associated type `Monad::Wrapped`
- --> $DIR/issue-79636-1.rs:6:10
+ --> $DIR/issue-79636-1.rs:16:34
|
-LL | type Wrapped<B>;
- | ^^^^^^^ expected 1 type argument
+LL | MInner: Monad<Unwrapped = A, Wrapped = MOuter::Wrapped<A>>,
+ | ^^^^^^^ expected 1 generic argument
|
-note: associated type defined here, with 1 type parameter: `B`
+note: associated type defined here, with 1 generic parameter: `B`
--> $DIR/issue-79636-1.rs:6:10
|
LL | type Wrapped<B>;
| ^^^^^^^ -
-help: use angle brackets to add missing type argument
+help: add missing generic argument
|
-LL | type Wrapped<B><B>;
- | ^^^
+LL | MInner: Monad<Unwrapped = A, Wrapped<B> = MOuter::Wrapped<A>>,
+ | ^^^^^^^^^^
error: aborting due to previous error
diff --git a/src/test/ui/generic-associated-types/issue-79636-2.rs b/src/test/ui/generic-associated-types/issue-79636-2.rs
index 5a6542193752b..ef39378e78d68 100644
--- a/src/test/ui/generic-associated-types/issue-79636-2.rs
+++ b/src/test/ui/generic-associated-types/issue-79636-2.rs
@@ -3,7 +3,6 @@
trait SomeTrait {
type Wrapped<A>: SomeTrait;
- //~^ ERROR: missing generics for associated type `SomeTrait::Wrapped`
fn f() -> ();
}
@@ -11,6 +10,7 @@ trait SomeTrait {
fn program<W>() -> ()
where
W: SomeTrait<Wrapped = W>,
+ //~^ ERROR: missing generics for associated type `SomeTrait::Wrapped`
{
return W::f();
}
diff --git a/src/test/ui/generic-associated-types/issue-79636-2.stderr b/src/test/ui/generic-associated-types/issue-79636-2.stderr
index d5e3c56ebb9ef..d5ba1aaeed5e3 100644
--- a/src/test/ui/generic-associated-types/issue-79636-2.stderr
+++ b/src/test/ui/generic-associated-types/issue-79636-2.stderr
@@ -1,18 +1,18 @@
error[E0107]: missing generics for associated type `SomeTrait::Wrapped`
- --> $DIR/issue-79636-2.rs:5:10
+ --> $DIR/issue-79636-2.rs:12:18
|
-LL | type Wrapped<A>: SomeTrait;
- | ^^^^^^^ expected 1 type argument
+LL | W: SomeTrait<Wrapped = W>,
+ | ^^^^^^^ expected 1 generic argument
|
-note: associated type defined here, with 1 type parameter: `A`
+note: associated type defined here, with 1 generic parameter: `A`
--> $DIR/issue-79636-2.rs:5:10
|
LL | type Wrapped<A>: SomeTrait;
| ^^^^^^^ -
-help: use angle brackets to add missing type argument
+help: add missing generic argument
|
-LL | type Wrapped<A><A>: SomeTrait;
- | ^^^
+LL | W: SomeTrait<Wrapped<A> = W>,
+ | ^^^^^^^^^^
error: aborting due to previous error
diff --git a/src/test/ui/generic-associated-types/issue-80433.rs b/src/test/ui/generic-associated-types/issue-80433.rs
index ea65f05de23d7..fd81804f234e5 100644
--- a/src/test/ui/generic-associated-types/issue-80433.rs
+++ b/src/test/ui/generic-associated-types/issue-80433.rs
@@ -8,7 +8,6 @@ struct E<T> {
trait TestMut {
type Output<'a>;
- //~^ ERROR missing generics
fn test_mut<'a>(&'a mut self) -> Self::Output<'a>;
}
@@ -23,6 +22,7 @@ where
}
fn test_simpler<'a>(dst: &'a mut impl TestMut<Output = &'a mut f32>)
+ //~^ ERROR missing generics for associated type
{
for n in 0i16..100 {
*dst.test_mut() = n.into();
diff --git a/src/test/ui/generic-associated-types/issue-80433.stderr b/src/test/ui/generic-associated-types/issue-80433.stderr
index 5398920fafdb0..31483ff0cd63d 100644
--- a/src/test/ui/generic-associated-types/issue-80433.stderr
+++ b/src/test/ui/generic-associated-types/issue-80433.stderr
@@ -1,18 +1,18 @@
error[E0107]: missing generics for associated type `TestMut::Output`
- --> $DIR/issue-80433.rs:10:10
+ --> $DIR/issue-80433.rs:24:47
|
-LL | type Output<'a>;
- | ^^^^^^ expected 1 lifetime argument
+LL | fn test_simpler<'a>(dst: &'a mut impl TestMut<Output = &'a mut f32>)
+ | ^^^^^^ expected 1 lifetime argument
|
note: associated type defined here, with 1 lifetime parameter: `'a`
--> $DIR/issue-80433.rs:10:10
|
LL | type Output<'a>;
| ^^^^^^ --
-help: use angle brackets to add missing lifetime argument
+help: add missing lifetime argument
|
-LL | type Output<'a><'a>;
- | ^^^^
+LL | fn test_simpler<'a>(dst: &'a mut impl TestMut<Output<'a> = &'a mut f32>)
+ | ^^^^^^^^^^
error: aborting due to previous error
diff --git a/src/test/ui/generic-associated-types/issue-81712-cyclic-traits.rs b/src/test/ui/generic-associated-types/issue-81712-cyclic-traits.rs
index 934870afc119c..b5512ee6d6290 100644
--- a/src/test/ui/generic-associated-types/issue-81712-cyclic-traits.rs
+++ b/src/test/ui/generic-associated-types/issue-81712-cyclic-traits.rs
@@ -12,10 +12,10 @@ trait B {
}
trait C {
type DType<T>: D<T, CType = Self>;
- //~^ ERROR: missing generics for associated type `C::DType` [E0107]
}
trait D<T> {
type CType: C<DType = Self>;
+ //~^ ERROR missing generics for associated type
}
fn main() {}
diff --git a/src/test/ui/generic-associated-types/issue-81712-cyclic-traits.stderr b/src/test/ui/generic-associated-types/issue-81712-cyclic-traits.stderr
index 75f68cd314893..4a7b96db30a9b 100644
--- a/src/test/ui/generic-associated-types/issue-81712-cyclic-traits.stderr
+++ b/src/test/ui/generic-associated-types/issue-81712-cyclic-traits.stderr
@@ -1,18 +1,18 @@
error[E0107]: missing generics for associated type `C::DType`
- --> $DIR/issue-81712-cyclic-traits.rs:14:10
+ --> $DIR/issue-81712-cyclic-traits.rs:17:19
|
-LL | type DType<T>: D<T, CType = Self>;
- | ^^^^^ expected 1 type argument
+LL | type CType: C<DType = Self>;
+ | ^^^^^ expected 1 generic argument
|
-note: associated type defined here, with 1 type parameter: `T`
+note: associated type defined here, with 1 generic parameter: `T`
--> $DIR/issue-81712-cyclic-traits.rs:14:10
|
LL | type DType<T>: D<T, CType = Self>;
| ^^^^^ -
-help: use angle brackets to add missing type argument
+help: add missing generic argument
|
-LL | type DType<T><T>: D<T, CType = Self>;
- | ^^^
+LL | type CType: C<DType<T> = Self>;
+ | ^^^^^^^^
error: aborting due to previous error
diff --git a/src/test/ui/generic-associated-types/issue-81862.rs b/src/test/ui/generic-associated-types/issue-81862.rs
new file mode 100644
index 0000000000000..02f843b07e23d
--- /dev/null
+++ b/src/test/ui/generic-associated-types/issue-81862.rs
@@ -0,0 +1,13 @@
+#![allow(incomplete_features)]
+#![feature(generic_associated_types)]
+
+trait StreamingIterator {
+ type Item<'a>;
+ fn next(&mut self) -> Option<Self::Item>;
+ //~^ ERROR missing generics for associated type
+}
+
+fn main() {}
+
+// call stack from back to front:
+// create_substs_for_assoc_ty -> qpath_to_ty -> res_to_ty -> ast_ty_to_ty -> ty_of_fn
diff --git a/src/test/ui/generic-associated-types/issue-81862.stderr b/src/test/ui/generic-associated-types/issue-81862.stderr
new file mode 100644
index 0000000000000..d7b904165c0ec
--- /dev/null
+++ b/src/test/ui/generic-associated-types/issue-81862.stderr
@@ -0,0 +1,19 @@
+error[E0107]: missing generics for associated type `StreamingIterator::Item`
+ --> $DIR/issue-81862.rs:6:40
+ |
+LL | fn next(&mut self) -> Option<Self::Item>;
+ | ^^^^ expected 1 lifetime argument
+ |
+note: associated type defined here, with 1 lifetime parameter: `'a`
+ --> $DIR/issue-81862.rs:5:10
+ |
+LL | type Item<'a>;
+ | ^^^^ --
+help: add missing lifetime argument
+ |
+LL | fn next(&mut self) -> Option<Self::Item<'_>>;
+ | ^^^^^^^^
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0107`.
diff --git a/src/test/ui/generic-associated-types/missing_lifetime_args.rs b/src/test/ui/generic-associated-types/missing_lifetime_args.rs
new file mode 100644
index 0000000000000..de24361dfde32
--- /dev/null
+++ b/src/test/ui/generic-associated-types/missing_lifetime_args.rs
@@ -0,0 +1,23 @@
+#![feature(generic_associated_types)]
+//~^ WARNING the feature `generic_associated_types`
+
+trait X {
+ type Y<'a, 'b>;
+}
+
+struct Foo<'a, 'b, 'c> {
+ a: &'a u32,
+ b: &'b str,
+ c: &'c str,
+}
+
+fn foo<'c, 'd>(_arg: Box<dyn X<Y = (&'c u32, &'d u32)>>) {}
+//~^ ERROR missing generics for associated type
+
+fn bar<'a, 'b, 'c>(_arg: Foo<'a, 'b>) {}
+//~^ ERROR this struct takes 3 lifetime arguments but 2 lifetime
+
+fn f<'a>(_arg: Foo<'a>) {}
+//~^ ERROR this struct takes 3 lifetime arguments but 1 lifetime
+
+fn main() {}
diff --git a/src/test/ui/generic-associated-types/missing_lifetime_args.stderr b/src/test/ui/generic-associated-types/missing_lifetime_args.stderr
new file mode 100644
index 0000000000000..73829594c826a
--- /dev/null
+++ b/src/test/ui/generic-associated-types/missing_lifetime_args.stderr
@@ -0,0 +1,64 @@
+warning: the feature `generic_associated_types` is incomplete and may not be safe to use and/or cause compiler crashes
+ --> $DIR/missing_lifetime_args.rs:1:12
+ |
+LL | #![feature(generic_associated_types)]
+ | ^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = note: `#[warn(incomplete_features)]` on by default
+ = note: see issue #44265 <https://github.com/rust-lang/rust/issues/44265> for more information
+
+error[E0107]: missing generics for associated type `X::Y`
+ --> $DIR/missing_lifetime_args.rs:14:32
+ |
+LL | fn foo<'c, 'd>(_arg: Box<dyn X<Y = (&'c u32, &'d u32)>>) {}
+ | ^ expected 2 lifetime arguments
+ |
+note: associated type defined here, with 2 lifetime parameters: `'a`, `'b`
+ --> $DIR/missing_lifetime_args.rs:5:10
+ |
+LL | type Y<'a, 'b>;
+ | ^ -- --
+help: add missing lifetime arguments
+ |
+LL | fn foo<'c, 'd>(_arg: Box<dyn X<Y<'c, 'd> = (&'c u32, &'d u32)>>) {}
+ | ^^^^^^^^^
+
+error[E0107]: this struct takes 3 lifetime arguments but 2 lifetime arguments were supplied
+ --> $DIR/missing_lifetime_args.rs:17:26
+ |
+LL | fn bar<'a, 'b, 'c>(_arg: Foo<'a, 'b>) {}
+ | ^^^ -- -- supplied 2 lifetime arguments
+ | |
+ | expected 3 lifetime arguments
+ |
+note: struct defined here, with 3 lifetime parameters: `'a`, `'b`, `'c`
+ --> $DIR/missing_lifetime_args.rs:8:8
+ |
+LL | struct Foo<'a, 'b, 'c> {
+ | ^^^ -- -- --
+help: add missing lifetime argument
+ |
+LL | fn bar<'a, 'b, 'c>(_arg: Foo<'a, 'b, 'a>) {}
+ | ^^^^
+
+error[E0107]: this struct takes 3 lifetime arguments but 1 lifetime argument was supplied
+ --> $DIR/missing_lifetime_args.rs:20:16
+ |
+LL | fn f<'a>(_arg: Foo<'a>) {}
+ | ^^^ -- supplied 1 lifetime argument
+ | |
+ | expected 3 lifetime arguments
+ |
+note: struct defined here, with 3 lifetime parameters: `'a`, `'b`, `'c`
+ --> $DIR/missing_lifetime_args.rs:8:8
+ |
+LL | struct Foo<'a, 'b, 'c> {
+ | ^^^ -- -- --
+help: add missing lifetime arguments
+ |
+LL | fn f<'a>(_arg: Foo<'a, 'b, 'c>) {}
+ | ^^^^^^^^
+
+error: aborting due to 3 previous errors; 1 warning emitted
+
+For more information about this error, try `rustc --explain E0107`.
diff --git a/src/test/ui/generic-associated-types/missing_lifetime_const.rs b/src/test/ui/generic-associated-types/missing_lifetime_const.rs
new file mode 100644
index 0000000000000..37cb7cab121ba
--- /dev/null
+++ b/src/test/ui/generic-associated-types/missing_lifetime_const.rs
@@ -0,0 +1,13 @@
+#![feature(generic_associated_types)]
+//~^ WARNING the feature
+
+trait Foo {
+ type Assoc<'a, const N: usize>;
+}
+
+fn foo<T: Foo>() {
+ let _: <T as Foo>::Assoc<3>;
+ //~^ ERROR this associated type
+}
+
+fn main() {}
diff --git a/src/test/ui/generic-associated-types/missing_lifetime_const.stderr b/src/test/ui/generic-associated-types/missing_lifetime_const.stderr
new file mode 100644
index 0000000000000..6c66312e7b160
--- /dev/null
+++ b/src/test/ui/generic-associated-types/missing_lifetime_const.stderr
@@ -0,0 +1,28 @@
+warning: the feature `generic_associated_types` is incomplete and may not be safe to use and/or cause compiler crashes
+ --> $DIR/missing_lifetime_const.rs:1:12
+ |
+LL | #![feature(generic_associated_types)]
+ | ^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = note: `#[warn(incomplete_features)]` on by default
+ = note: see issue #44265 <https://github.com/rust-lang/rust/issues/44265> for more information
+
+error[E0107]: this associated type takes 1 lifetime argument but 0 lifetime arguments were supplied
+ --> $DIR/missing_lifetime_const.rs:9:24
+ |
+LL | let _: <T as Foo>::Assoc<3>;
+ | ^^^^^ expected 1 lifetime argument
+ |
+note: associated type defined here, with 1 lifetime parameter: `'a`
+ --> $DIR/missing_lifetime_const.rs:5:10
+ |
+LL | type Assoc<'a, const N: usize>;
+ | ^^^^^ --
+help: add missing lifetime argument
+ |
+LL | let _: <T as Foo>::Assoc<'a, 3>;
+ | ^^^
+
+error: aborting due to previous error; 1 warning emitted
+
+For more information about this error, try `rustc --explain E0107`.
diff --git a/src/test/ui/generic-associated-types/parameter_number_and_kind.rs b/src/test/ui/generic-associated-types/parameter_number_and_kind.rs
index 9d7ef88b7679d..3f92c031e18d0 100644
--- a/src/test/ui/generic-associated-types/parameter_number_and_kind.rs
+++ b/src/test/ui/generic-associated-types/parameter_number_and_kind.rs
@@ -12,9 +12,9 @@ trait Foo {
type FOk<T> = Self::E<'static, T>;
type FErr1 = Self::E<'static, 'static>;
//~^ ERROR this associated type takes 1 lifetime argument but 2 lifetime arguments were supplied
- //~| ERROR this associated type takes 1 type argument but 0 type arguments were supplied
+ //~| ERROR this associated type takes 1
type FErr2<T> = Self::E<'static, T, u32>;
- //~^ ERROR this associated type takes 1 type argument but 2 type arguments were supplied
+ //~^ ERROR this associated type takes 1
}
fn main() {}
diff --git a/src/test/ui/generic-associated-types/parameter_number_and_kind.stderr b/src/test/ui/generic-associated-types/parameter_number_and_kind.stderr
index d021889c08424..b6f600964c9a3 100644
--- a/src/test/ui/generic-associated-types/parameter_number_and_kind.stderr
+++ b/src/test/ui/generic-associated-types/parameter_number_and_kind.stderr
@@ -2,7 +2,7 @@ error[E0107]: this associated type takes 1 lifetime argument but 2 lifetime argu
--> $DIR/parameter_number_and_kind.rs:13:24
|
LL | type FErr1 = Self::E<'static, 'static>;
- | ^ --------- help: remove this lifetime argument
+ | ^ ------- help: remove this lifetime argument
| |
| expected 1 lifetime argument
|
@@ -12,31 +12,31 @@ note: associated type defined here, with 1 lifetime parameter: `'a`
LL | type E<'a, T>;
| ^ --
-error[E0107]: this associated type takes 1 type argument but 0 type arguments were supplied
+error[E0107]: this associated type takes 1 generic argument but 0 generic arguments were supplied
--> $DIR/parameter_number_and_kind.rs:13:24
|
LL | type FErr1 = Self::E<'static, 'static>;
- | ^ expected 1 type argument
+ | ^ expected 1 generic argument
|
-note: associated type defined here, with 1 type parameter: `T`
+note: associated type defined here, with 1 generic parameter: `T`
--> $DIR/parameter_number_and_kind.rs:10:10
|
LL | type E<'a, T>;
| ^ -
-help: add missing type argument
+help: add missing generic argument
|
LL | type FErr1 = Self::E<'static, 'static, T>;
| ^^^
-error[E0107]: this associated type takes 1 type argument but 2 type arguments were supplied
+error[E0107]: this associated type takes 1 generic argument but 2 generic arguments were supplied
--> $DIR/parameter_number_and_kind.rs:16:27
|
LL | type FErr2<T> = Self::E<'static, T, u32>;
- | ^ ----- help: remove this type argument
+ | ^ --- help: remove this generic argument
| |
- | expected 1 type argument
+ | expected 1 generic argument
|
-note: associated type defined here, with 1 type parameter: `T`
+note: associated type defined here, with 1 generic parameter: `T`
--> $DIR/parameter_number_and_kind.rs:10:10
|
LL | type E<'a, T>;
diff --git a/src/test/ui/generic-associated-types/parse/trait-path-type-error-once-implemented.rs b/src/test/ui/generic-associated-types/parse/trait-path-type-error-once-implemented.rs
index 2d38770bcdff8..d7a0ef4916a18 100644
--- a/src/test/ui/generic-associated-types/parse/trait-path-type-error-once-implemented.rs
+++ b/src/test/ui/generic-associated-types/parse/trait-path-type-error-once-implemented.rs
@@ -3,12 +3,12 @@
trait X {
type Y<'a>;
- //~^ ERROR this associated type
- //~| ERROR this associated type
}
const _: () = {
fn f2<'a>(arg : Box<dyn X<Y<1> = &'a ()>>) {}
+ //~^ ERROR this associated type takes 1 lifetime argument but 0 lifetime arguments
+ //~| ERROR this associated type takes 0 generic arguments but 1 generic argument
};
fn main() {}
diff --git a/src/test/ui/generic-associated-types/parse/trait-path-type-error-once-implemented.stderr b/src/test/ui/generic-associated-types/parse/trait-path-type-error-once-implemented.stderr
index 60b8fb9bcaa23..5685e5208c6d8 100644
--- a/src/test/ui/generic-associated-types/parse/trait-path-type-error-once-implemented.stderr
+++ b/src/test/ui/generic-associated-types/parse/trait-path-type-error-once-implemented.stderr
@@ -8,10 +8,10 @@ LL | #![feature(generic_associated_types)]
= note: see issue #44265 <https://github.com/rust-lang/rust/issues/44265> for more information
error[E0107]: this associated type takes 1 lifetime argument but 0 lifetime arguments were supplied
- --> $DIR/trait-path-type-error-once-implemented.rs:5:10
+ --> $DIR/trait-path-type-error-once-implemented.rs:9:29
|
-LL | type Y<'a>;
- | ^ expected 1 lifetime argument
+LL | fn f2<'a>(arg : Box<dyn X<Y<1> = &'a ()>>) {}
+ | ^ expected 1 lifetime argument
|
note: associated type defined here, with 1 lifetime parameter: `'a`
--> $DIR/trait-path-type-error-once-implemented.rs:5:10
@@ -20,25 +20,18 @@ LL | type Y<'a>;
| ^ --
help: add missing lifetime argument
|
-LL | fn f2<'a>(arg : Box<dyn X<Y<'a1> = &'a ()>>) {}
- | ^^
+LL | fn f2<'a>(arg : Box<dyn X<Y<'a, 1> = &'a ()>>) {}
+ | ^^^
-error[E0107]: this associated type takes 0 const arguments but 1 const argument was supplied
- --> $DIR/trait-path-type-error-once-implemented.rs:5:10
+error[E0107]: this associated type takes 0 generic arguments but 1 generic argument was supplied
+ --> $DIR/trait-path-type-error-once-implemented.rs:9:29
+ |
+LL | fn f2<'a>(arg : Box<dyn X<Y<1> = &'a ()>>) {}
+ | ^--- help: remove these generics
+ | |
+ | expected 0 generic arguments
|
-LL | type Y<'a>;
- | __________^-
- | | |
- | | expected 0 const arguments
-LL | |
-LL | |
-LL | | }
-LL | |
-LL | | const _: () = {
-LL | | fn f2<'a>(arg : Box<dyn X<Y<1> = &'a ()>>) {}
- | |________________________________- help: remove these generics
- |
-note: associated type defined here, with 0 const parameters
+note: associated type defined here, with 0 generic parameters
--> $DIR/trait-path-type-error-once-implemented.rs:5:10
|
LL | type Y<'a>;
diff --git a/src/test/ui/generics/bad-mid-path-type-params.rs b/src/test/ui/generics/bad-mid-path-type-params.rs
index c42ce602e9987..23a5d1525d995 100644
--- a/src/test/ui/generics/bad-mid-path-type-params.rs
+++ b/src/test/ui/generics/bad-mid-path-type-params.rs
@@ -28,17 +28,17 @@ impl Trait<isize> for S2 {
fn foo<'a>() {
let _ = S::new::<isize,f64>(1, 1.0);
- //~^ ERROR this associated function takes 1 type argument but 2 type arguments were supplied
+ //~^ ERROR this associated function takes 1
let _ = S::<'a,isize>::new::<f64>(1, 1.0);
//~^ ERROR this struct takes 0 lifetime arguments but 1 lifetime argument was supplied
let _: S2 = Trait::new::<isize,f64>(1, 1.0);
- //~^ ERROR this associated function takes 1 type argument but 2 type arguments were supplied
+ //~^ ERROR this associated function takes 1
let _: S2 = Trait::<'a,isize>::new::<f64,f64>(1, 1.0);
//~^ ERROR this trait takes 0 lifetime arguments but 1 lifetime argument was supplied
- //~| ERROR this associated function takes 1 type argument but 2 type arguments were supplied
+ //~| ERROR this associated function takes 1
}
fn main() {}
diff --git a/src/test/ui/generics/bad-mid-path-type-params.stderr b/src/test/ui/generics/bad-mid-path-type-params.stderr
index dd96856e56324..aee2b60159f10 100644
--- a/src/test/ui/generics/bad-mid-path-type-params.stderr
+++ b/src/test/ui/generics/bad-mid-path-type-params.stderr
@@ -1,12 +1,12 @@
-error[E0107]: this associated function takes 1 type argument but 2 type arguments were supplied
+error[E0107]: this associated function takes 1 generic argument but 2 generic arguments were supplied
--> $DIR/bad-mid-path-type-params.rs:30:16
|
LL | let _ = S::new::<isize,f64>(1, 1.0);
- | ^^^ ---- help: remove this type argument
+ | ^^^ --- help: remove this generic argument
| |
- | expected 1 type argument
+ | expected 1 generic argument
|
-note: associated function defined here, with 1 type parameter: `U`
+note: associated function defined here, with 1 generic parameter: `U`
--> $DIR/bad-mid-path-type-params.rs:6:8
|
LL | fn new<U>(x: T, _: U) -> S<T> {
@@ -16,7 +16,7 @@ error[E0107]: this struct takes 0 lifetime arguments but 1 lifetime argument was
--> $DIR/bad-mid-path-type-params.rs:33:13
|
LL | let _ = S::<'a,isize>::new::<f64>(1, 1.0);
- | ^ --- help: remove this lifetime argument
+ | ^ -- help: remove this lifetime argument
| |
| expected 0 lifetime arguments
|
@@ -26,15 +26,15 @@ note: struct defined here, with 0 lifetime parameters
LL | struct S<T> {
| ^
-error[E0107]: this associated function takes 1 type argument but 2 type arguments were supplied
+error[E0107]: this associated function takes 1 generic argument but 2 generic arguments were supplied
--> $DIR/bad-mid-path-type-params.rs:36:24
|
LL | let _: S2 = Trait::new::<isize,f64>(1, 1.0);
- | ^^^ ---- help: remove this type argument
+ | ^^^ --- help: remove this generic argument
| |
- | expected 1 type argument
+ | expected 1 generic argument
|
-note: associated function defined here, with 1 type parameter: `U`
+note: associated function defined here, with 1 generic parameter: `U`
--> $DIR/bad-mid-path-type-params.rs:14:8
|
LL | fn new<U>(x: T, y: U) -> Self;
@@ -44,7 +44,7 @@ error[E0107]: this trait takes 0 lifetime arguments but 1 lifetime argument was
--> $DIR/bad-mid-path-type-params.rs:39:17
|
LL | let _: S2 = Trait::<'a,isize>::new::<f64,f64>(1, 1.0);
- | ^^^^^ --- help: remove this lifetime argument
+ | ^^^^^ -- help: remove this lifetime argument
| |
| expected 0 lifetime arguments
|
@@ -54,15 +54,15 @@ note: trait defined here, with 0 lifetime parameters
LL | trait Trait<T> {
| ^^^^^
-error[E0107]: this associated function takes 1 type argument but 2 type arguments were supplied
+error[E0107]: this associated function takes 1 generic argument but 2 generic arguments were supplied
--> $DIR/bad-mid-path-type-params.rs:39:36
|
LL | let _: S2 = Trait::<'a,isize>::new::<f64,f64>(1, 1.0);
- | ^^^ ---- help: remove this type argument
+ | ^^^ --- help: remove this generic argument
| |
- | expected 1 type argument
+ | expected 1 generic argument
|
-note: associated function defined here, with 1 type parameter: `U`
+note: associated function defined here, with 1 generic parameter: `U`
--> $DIR/bad-mid-path-type-params.rs:14:8
|
LL | fn new<U>(x: T, y: U) -> Self;
diff --git a/src/test/ui/generics/generic-arg-mismatch-recover.rs b/src/test/ui/generics/generic-arg-mismatch-recover.rs
index 0e0d1daec5f31..2cf7f1d657b18 100644
--- a/src/test/ui/generics/generic-arg-mismatch-recover.rs
+++ b/src/test/ui/generics/generic-arg-mismatch-recover.rs
@@ -8,5 +8,5 @@ fn main() {
Bar::<'static, 'static, ()>(&());
//~^ ERROR this struct takes 1 lifetime argument but 2 lifetime arguments were supplied
- //~| ERROR this struct takes 0 type arguments but 1 type argument was supplied
+ //~| ERROR this struct takes 0
}
diff --git a/src/test/ui/generics/generic-arg-mismatch-recover.stderr b/src/test/ui/generics/generic-arg-mismatch-recover.stderr
index ca73b82737d64..45fea925f27cf 100644
--- a/src/test/ui/generics/generic-arg-mismatch-recover.stderr
+++ b/src/test/ui/generics/generic-arg-mismatch-recover.stderr
@@ -2,7 +2,7 @@ error[E0107]: this struct takes 1 lifetime argument but 2 lifetime arguments wer
--> $DIR/generic-arg-mismatch-recover.rs:6:5
|
LL | Foo::<'static, 'static, ()>(&0);
- | ^^^ --------- help: remove this lifetime argument
+ | ^^^ ------- help: remove this lifetime argument
| |
| expected 1 lifetime argument
|
@@ -16,7 +16,7 @@ error[E0107]: this struct takes 1 lifetime argument but 2 lifetime arguments wer
--> $DIR/generic-arg-mismatch-recover.rs:9:5
|
LL | Bar::<'static, 'static, ()>(&());
- | ^^^ --------- help: remove this lifetime argument
+ | ^^^ ------- help: remove this lifetime argument
| |
| expected 1 lifetime argument
|
@@ -26,15 +26,15 @@ note: struct defined here, with 1 lifetime parameter: `'a`
LL | struct Bar<'a>(&'a ());
| ^^^ --
-error[E0107]: this struct takes 0 type arguments but 1 type argument was supplied
+error[E0107]: this struct takes 0 generic arguments but 1 generic argument was supplied
--> $DIR/generic-arg-mismatch-recover.rs:9:5
|
LL | Bar::<'static, 'static, ()>(&());
- | ^^^ ---- help: remove this type argument
+ | ^^^ -- help: remove this generic argument
| |
- | expected 0 type arguments
+ | expected 0 generic arguments
|
-note: struct defined here, with 0 type parameters
+note: struct defined here, with 0 generic parameters
--> $DIR/generic-arg-mismatch-recover.rs:3:8
|
LL | struct Bar<'a>(&'a ());
diff --git a/src/test/ui/generics/generic-impl-less-params-with-defaults.rs b/src/test/ui/generics/generic-impl-less-params-with-defaults.rs
index 01964f652ee09..66afbb58ad490 100644
--- a/src/test/ui/generics/generic-impl-less-params-with-defaults.rs
+++ b/src/test/ui/generics/generic-impl-less-params-with-defaults.rs
@@ -9,5 +9,5 @@ impl<A, B, C> Foo<A, B, C> {
fn main() {
Foo::<isize>::new();
- //~^ ERROR this struct takes at least 2 type arguments but only 1 type argument was supplied
+ //~^ ERROR this struct takes at least 2 generic arguments but 1 generic argument
}
diff --git a/src/test/ui/generics/generic-impl-less-params-with-defaults.stderr b/src/test/ui/generics/generic-impl-less-params-with-defaults.stderr
index a8a17876ee0fd..2c7ffde7ddb97 100644
--- a/src/test/ui/generics/generic-impl-less-params-with-defaults.stderr
+++ b/src/test/ui/generics/generic-impl-less-params-with-defaults.stderr
@@ -1,17 +1,17 @@
-error[E0107]: this struct takes at least 2 type arguments but only 1 type argument was supplied
+error[E0107]: this struct takes at least 2 generic arguments but 1 generic argument was supplied
--> $DIR/generic-impl-less-params-with-defaults.rs:11:5
|
LL | Foo::<isize>::new();
- | ^^^ ----- supplied 1 type argument
+ | ^^^ ----- supplied 1 generic argument
| |
- | expected at least 2 type arguments
+ | expected at least 2 generic arguments
|
-note: struct defined here, with at least 2 type parameters: `A`, `B`
+note: struct defined here, with at least 2 generic parameters: `A`, `B`
--> $DIR/generic-impl-less-params-with-defaults.rs:3:8
|
LL | struct Foo<A, B, C = (A, B)>(
| ^^^ - -
-help: add missing type argument
+help: add missing generic argument
|
LL | Foo::<isize, B>::new();
| ^^^
diff --git a/src/test/ui/generics/generic-impl-more-params-with-defaults.rs b/src/test/ui/generics/generic-impl-more-params-with-defaults.rs
index 24c41a9088b99..a283323742a0f 100644
--- a/src/test/ui/generics/generic-impl-more-params-with-defaults.rs
+++ b/src/test/ui/generics/generic-impl-more-params-with-defaults.rs
@@ -11,5 +11,5 @@ impl<T, A> Vec<T, A> {
fn main() {
Vec::<isize, Heap, bool>::new();
- //~^ ERROR this struct takes at most 2 type arguments but 3 type arguments were supplied
+ //~^ ERROR this struct takes at most 2 generic arguments but 3 generic arguments were supplied
}
diff --git a/src/test/ui/generics/generic-impl-more-params-with-defaults.stderr b/src/test/ui/generics/generic-impl-more-params-with-defaults.stderr
index 8ba86afe91ea0..059289533dadc 100644
--- a/src/test/ui/generics/generic-impl-more-params-with-defaults.stderr
+++ b/src/test/ui/generics/generic-impl-more-params-with-defaults.stderr
@@ -1,12 +1,12 @@
-error[E0107]: this struct takes at most 2 type arguments but 3 type arguments were supplied
+error[E0107]: this struct takes at most 2 generic arguments but 3 generic arguments were supplied
--> $DIR/generic-impl-more-params-with-defaults.rs:13:5
|
LL | Vec::<isize, Heap, bool>::new();
- | ^^^ ------ help: remove this type argument
+ | ^^^ ---- help: remove this generic argument
| |
- | expected at most 2 type arguments
+ | expected at most 2 generic arguments
|
-note: struct defined here, with at most 2 type parameters: `T`, `A`
+note: struct defined here, with at most 2 generic parameters: `T`, `A`
--> $DIR/generic-impl-more-params-with-defaults.rs:5:8
|
LL | struct Vec<T, A = Heap>(
diff --git a/src/test/ui/generics/generic-type-less-params-with-defaults.stderr b/src/test/ui/generics/generic-type-less-params-with-defaults.stderr
index 93f7a24d87741..7c0836375e38e 100644
--- a/src/test/ui/generics/generic-type-less-params-with-defaults.stderr
+++ b/src/test/ui/generics/generic-type-less-params-with-defaults.stderr
@@ -2,17 +2,17 @@ error[E0107]: missing generics for struct `Vec`
--> $DIR/generic-type-less-params-with-defaults.rs:9:12
|
LL | let _: Vec;
- | ^^^ expected at least 1 type argument
+ | ^^^ expected at least 1 generic argument
|
-note: struct defined here, with at least 1 type parameter: `T`
+note: struct defined here, with at least 1 generic parameter: `T`
--> $DIR/generic-type-less-params-with-defaults.rs:5:8
|
LL | struct Vec<T, A = Heap>(
| ^^^ -
-help: use angle brackets to add missing type argument
+help: add missing generic argument
|
LL | let _: Vec<T>;
- | ^^^
+ | ^^^^^^
error: aborting due to previous error
diff --git a/src/test/ui/generics/generic-type-more-params-with-defaults.rs b/src/test/ui/generics/generic-type-more-params-with-defaults.rs
index c421774ebbadd..3dab03297c9df 100644
--- a/src/test/ui/generics/generic-type-more-params-with-defaults.rs
+++ b/src/test/ui/generics/generic-type-more-params-with-defaults.rs
@@ -7,5 +7,5 @@ struct Vec<T, A = Heap>(
fn main() {
let _: Vec<isize, Heap, bool>;
- //~^ ERROR this struct takes at most 2 type arguments but 3 type arguments were supplied
+ //~^ ERROR this struct takes at most 2 generic arguments but 3 generic arguments
}
diff --git a/src/test/ui/generics/generic-type-more-params-with-defaults.stderr b/src/test/ui/generics/generic-type-more-params-with-defaults.stderr
index e331481390b66..500880cfb8678 100644
--- a/src/test/ui/generics/generic-type-more-params-with-defaults.stderr
+++ b/src/test/ui/generics/generic-type-more-params-with-defaults.stderr
@@ -1,12 +1,12 @@
-error[E0107]: this struct takes at most 2 type arguments but 3 type arguments were supplied
+error[E0107]: this struct takes at most 2 generic arguments but 3 generic arguments were supplied
--> $DIR/generic-type-more-params-with-defaults.rs:9:12
|
LL | let _: Vec<isize, Heap, bool>;
- | ^^^ ------ help: remove this type argument
+ | ^^^ ---- help: remove this generic argument
| |
- | expected at most 2 type arguments
+ | expected at most 2 generic arguments
|
-note: struct defined here, with at most 2 type parameters: `T`, `A`
+note: struct defined here, with at most 2 generic parameters: `T`, `A`
--> $DIR/generic-type-more-params-with-defaults.rs:5:8
|
LL | struct Vec<T, A = Heap>(
diff --git a/src/test/ui/generics/wrong-number-of-args.rs b/src/test/ui/generics/wrong-number-of-args.rs
index 2994ca3c7595c..f061c5814594e 100644
--- a/src/test/ui/generics/wrong-number-of-args.rs
+++ b/src/test/ui/generics/wrong-number-of-args.rs
@@ -4,18 +4,18 @@ mod no_generics {
type A = Ty;
type B = Ty<'static>;
- //~^ ERROR this struct takes 0 lifetime arguments but 1 lifetime argument was supplied
+ //~^ ERROR this struct takes 0 lifetime arguments but 1 lifetime argument
//~| HELP remove these generics
type C = Ty<'static, usize>;
- //~^ ERROR this struct takes 0 lifetime arguments but 1 lifetime argument was supplied
- //~| ERROR this struct takes 0 type arguments but 1 type argument was supplied
+ //~^ ERROR this struct takes 0 lifetime arguments but 1 lifetime argument
+ //~| ERROR this struct takes 0 generic arguments but 1 generic argument
//~| HELP remove this lifetime argument
- //~| HELP remove this type argument
+ //~| HELP remove this generic argument
type D = Ty<'static, usize, { 0 }>;
- //~^ ERROR this struct takes 0 lifetime arguments but 1 lifetime argument was supplied
- //~| ERROR this struct takes 0 generic arguments but 2 generic arguments were supplied
+ //~^ ERROR this struct takes 0 lifetime arguments but 1 lifetime argument
+ //~| ERROR this struct takes 0 generic arguments but 2 generic arguments
//~| HELP remove this lifetime argument
//~| HELP remove these generic arguments
}
@@ -25,31 +25,31 @@ mod type_and_type {
type A = Ty;
//~^ ERROR missing generics for struct `type_and_type::Ty`
- //~| HELP use angle brackets
+ //~| HELP add missing
type B = Ty<usize>;
- //~^ ERROR this struct takes 2 type arguments but only 1 type argument was supplied
- //~| HELP add missing type argument
+ //~^ ERROR this struct takes 2 generic arguments but 1 generic argument
+ //~| HELP add missing
type C = Ty<usize, String>;
type D = Ty<usize, String, char>;
- //~^ ERROR this struct takes 2 type arguments but 3 type arguments were supplied
- //~| HELP remove this type argument
+ //~^ ERROR this struct takes 2 generic arguments but 3 generic arguments
+ //~| HELP remove this
}
mod lifetime_and_type {
struct Ty<'a, T>;
type A = Ty;
- //~^ ERROR missing generics for struct `lifetime_and_type::Ty`
+ //~^ ERROR missing generics for struct
//~| ERROR missing lifetime specifier
+ //~| HELP add missing
//~| HELP consider introducing
- //~| HELP use angle brackets
type B = Ty<'static>;
- //~^ ERROR this struct takes 1 type argument but 0 type arguments were supplied
- //~| HELP add missing type argument
+ //~^ ERROR this struct takes 1 generic argument but 0 generic arguments
+ //~| HELP add missing
type C = Ty<usize>;
//~^ ERROR missing lifetime specifier
@@ -63,18 +63,18 @@ mod type_and_type_and_type {
type A = Ty;
//~^ ERROR missing generics for struct `type_and_type_and_type::Ty`
- //~| HELP use angle brackets
+ //~| HELP add missing
type B = Ty<usize>;
- //~^ ERROR this struct takes at least 2 type arguments but only 1 type argument was supplied
- //~| HELP add missing type argument
+ //~^ ERROR this struct takes at least 2
+ //~| HELP add missing
type C = Ty<usize, String>;
type D = Ty<usize, String, char>;
type E = Ty<usize, String, char, f64>;
- //~^ ERROR this struct takes at most 3 type arguments but 4 type arguments were supplied
+ //~^ ERROR this struct takes at most 3
//~| HELP remove
}
@@ -94,7 +94,7 @@ mod r#trait {
}
type A = Box<dyn NonGeneric<usize>>;
- //~^ ERROR this trait takes 0 type arguments but 1 type argument was supplied
+ //~^ ERROR this trait takes 0 generic arguments but 1 generic argument
//~| HELP remove
type B = Box<dyn GenericLifetime>;
@@ -107,10 +107,10 @@ mod r#trait {
type D = Box<dyn GenericType>;
//~^ ERROR missing generics for trait `GenericType`
- //~| HELP use angle brackets
+ //~| HELP add missing
type E = Box<dyn GenericType<String, usize>>;
- //~^ ERROR this trait takes 1 type argument but 2 type arguments were supplied
+ //~^ ERROR this trait takes 1 generic argument but 2 generic arguments
//~| HELP remove
}
@@ -120,40 +120,40 @@ mod stdlib {
type A = HashMap;
//~^ ERROR missing generics for struct `HashMap`
- //~| HELP use angle brackets
+ //~| HELP add missing
type B = HashMap<String>;
- //~^ ERROR this struct takes at least 2 type arguments but only 1 type argument was supplied
- //~| HELP add missing type argument
+ //~^ ERROR this struct takes at least
+ //~| HELP add missing
type C = HashMap<'static>;
- //~^ ERROR this struct takes 0 lifetime arguments but 1 lifetime argument was supplied
+ //~^ ERROR this struct takes 0 lifetime arguments but 1 lifetime argument
//~| HELP remove these generics
- //~| ERROR this struct takes at least 2 type arguments but 0 type arguments were supplied
- //~| HELP add missing type arguments
+ //~| ERROR this struct takes at least 2
+ //~| HELP add missing
type D = HashMap<usize, String, char, f64>;
- //~^ ERROR this struct takes at most 3 type arguments but 4 type arguments were supplied
- //~| HELP remove this type argument
+ //~^ ERROR this struct takes at most 3
+ //~| HELP remove this
}
mod result {
type A = Result;
//~^ ERROR missing generics for enum `Result`
- //~| HELP use angle brackets
+ //~| HELP add missing
type B = Result<String>;
- //~^ ERROR this enum takes 2 type arguments but only 1 type argument was supplied
- //~| HELP add missing type argument
+ //~^ ERROR this enum takes 2 generic arguments but 1 generic argument
+ //~| HELP add missing
type C = Result<'static>;
- //~^ ERROR this enum takes 0 lifetime arguments but 1 lifetime argument was supplied
+ //~^ ERROR this enum takes 0 lifetime arguments but 1 lifetime argument
//~| HELP remove these generics
- //~| ERROR this enum takes 2 type arguments but 0 type arguments were supplied
- //~| HELP add missing type arguments
+ //~| ERROR this enum takes 2 generic arguments but 0 generic arguments
+ //~| HELP add missing
type D = Result<usize, String, char>;
- //~^ ERROR this enum takes 2 type arguments but 3 type arguments were supplied
+ //~^ ERROR this enum takes 2 generic arguments but 3 generic arguments
//~| HELP remove
}
}
diff --git a/src/test/ui/generics/wrong-number-of-args.stderr b/src/test/ui/generics/wrong-number-of-args.stderr
index 94fdd355d48ca..45bde4163d0fe 100644
--- a/src/test/ui/generics/wrong-number-of-args.stderr
+++ b/src/test/ui/generics/wrong-number-of-args.stderr
@@ -16,7 +16,7 @@ error[E0107]: this struct takes 0 lifetime arguments but 1 lifetime argument was
--> $DIR/wrong-number-of-args.rs:10:14
|
LL | type C = Ty<'static, usize>;
- | ^^ --------- help: remove this lifetime argument
+ | ^^ ------- help: remove this lifetime argument
| |
| expected 0 lifetime arguments
|
@@ -26,15 +26,15 @@ note: struct defined here, with 0 lifetime parameters
LL | struct Ty;
| ^^
-error[E0107]: this struct takes 0 type arguments but 1 type argument was supplied
+error[E0107]: this struct takes 0 generic arguments but 1 generic argument was supplied
--> $DIR/wrong-number-of-args.rs:10:14
|
LL | type C = Ty<'static, usize>;
- | ^^ ------- help: remove this type argument
+ | ^^ ----- help: remove this generic argument
| |
- | expected 0 type arguments
+ | expected 0 generic arguments
|
-note: struct defined here, with 0 type parameters
+note: struct defined here, with 0 generic parameters
--> $DIR/wrong-number-of-args.rs:2:12
|
LL | struct Ty;
@@ -44,7 +44,7 @@ error[E0107]: this struct takes 0 lifetime arguments but 1 lifetime argument was
--> $DIR/wrong-number-of-args.rs:16:14
|
LL | type D = Ty<'static, usize, { 0 }>;
- | ^^ --------- help: remove this lifetime argument
+ | ^^ ------- help: remove this lifetime argument
| |
| expected 0 lifetime arguments
|
@@ -58,7 +58,7 @@ error[E0107]: this struct takes 0 generic arguments but 2 generic arguments were
--> $DIR/wrong-number-of-args.rs:16:14
|
LL | type D = Ty<'static, usize, { 0 }>;
- | ^^ -------------- help: remove these generic arguments
+ | ^^ ------------ help: remove these generic arguments
| |
| expected 0 generic arguments
|
@@ -72,45 +72,45 @@ error[E0107]: missing generics for struct `type_and_type::Ty`
--> $DIR/wrong-number-of-args.rs:26:14
|
LL | type A = Ty;
- | ^^ expected 2 type arguments
+ | ^^ expected 2 generic arguments
|
-note: struct defined here, with 2 type parameters: `A`, `B`
+note: struct defined here, with 2 generic parameters: `A`, `B`
--> $DIR/wrong-number-of-args.rs:24:12
|
LL | struct Ty<A, B>;
| ^^ - -
-help: use angle brackets to add missing type arguments
+help: add missing generic arguments
|
LL | type A = Ty<A, B>;
- | ^^^^^^
+ | ^^^^^^^^
-error[E0107]: this struct takes 2 type arguments but only 1 type argument was supplied
+error[E0107]: this struct takes 2 generic arguments but 1 generic argument was supplied
--> $DIR/wrong-number-of-args.rs:30:14
|
LL | type B = Ty<usize>;
- | ^^ ----- supplied 1 type argument
+ | ^^ ----- supplied 1 generic argument
| |
- | expected 2 type arguments
+ | expected 2 generic arguments
|
-note: struct defined here, with 2 type parameters: `A`, `B`
+note: struct defined here, with 2 generic parameters: `A`, `B`
--> $DIR/wrong-number-of-args.rs:24:12
|
LL | struct Ty<A, B>;
| ^^ - -
-help: add missing type argument
+help: add missing generic argument
|
LL | type B = Ty<usize, B>;
| ^^^
-error[E0107]: this struct takes 2 type arguments but 3 type arguments were supplied
+error[E0107]: this struct takes 2 generic arguments but 3 generic arguments were supplied
--> $DIR/wrong-number-of-args.rs:36:14
|
LL | type D = Ty<usize, String, char>;
- | ^^ ------ help: remove this type argument
+ | ^^ ---- help: remove this generic argument
| |
- | expected 2 type arguments
+ | expected 2 generic arguments
|
-note: struct defined here, with 2 type parameters: `A`, `B`
+note: struct defined here, with 2 generic parameters: `A`, `B`
--> $DIR/wrong-number-of-args.rs:24:12
|
LL | struct Ty<A, B>;
@@ -120,17 +120,17 @@ error[E0107]: missing generics for struct `lifetime_and_type::Ty`
--> $DIR/wrong-number-of-args.rs:44:14
|
LL | type A = Ty;
- | ^^ expected 1 type argument
+ | ^^ expected 1 generic argument
|
-note: struct defined here, with 1 type parameter: `T`
+note: struct defined here, with 1 generic parameter: `T`
--> $DIR/wrong-number-of-args.rs:42:12
|
LL | struct Ty<'a, T>;
| ^^ -
-help: use angle brackets to add missing type argument
+help: add missing generic argument
|
LL | type A = Ty<T>;
- | ^^^
+ | ^^^^^
error[E0106]: missing lifetime specifier
--> $DIR/wrong-number-of-args.rs:44:14
@@ -143,18 +143,18 @@ help: consider introducing a named lifetime parameter
LL | type A<'a> = Ty<'a>;
| ^^^^ ^^^^^^
-error[E0107]: this struct takes 1 type argument but 0 type arguments were supplied
+error[E0107]: this struct takes 1 generic argument but 0 generic arguments were supplied
--> $DIR/wrong-number-of-args.rs:50:14
|
LL | type B = Ty<'static>;
- | ^^ expected 1 type argument
+ | ^^ expected 1 generic argument
|
-note: struct defined here, with 1 type parameter: `T`
+note: struct defined here, with 1 generic parameter: `T`
--> $DIR/wrong-number-of-args.rs:42:12
|
LL | struct Ty<'a, T>;
| ^^ -
-help: add missing type argument
+help: add missing generic argument
|
LL | type B = Ty<'static, T>;
| ^^^
@@ -174,59 +174,59 @@ error[E0107]: missing generics for struct `type_and_type_and_type::Ty`
--> $DIR/wrong-number-of-args.rs:64:14
|
LL | type A = Ty;
- | ^^ expected at least 2 type arguments
+ | ^^ expected at least 2 generic arguments
|
-note: struct defined here, with at least 2 type parameters: `A`, `B`
+note: struct defined here, with at least 2 generic parameters: `A`, `B`
--> $DIR/wrong-number-of-args.rs:62:12
|
LL | struct Ty<A, B, C = &'static str>;
| ^^ - -
-help: use angle brackets to add missing type arguments
+help: add missing generic arguments
|
LL | type A = Ty<A, B>;
- | ^^^^^^
+ | ^^^^^^^^
-error[E0107]: this struct takes at least 2 type arguments but only 1 type argument was supplied
+error[E0107]: this struct takes at least 2 generic arguments but 1 generic argument was supplied
--> $DIR/wrong-number-of-args.rs:68:14
|
LL | type B = Ty<usize>;
- | ^^ ----- supplied 1 type argument
+ | ^^ ----- supplied 1 generic argument
| |
- | expected at least 2 type arguments
+ | expected at least 2 generic arguments
|
-note: struct defined here, with at least 2 type parameters: `A`, `B`
+note: struct defined here, with at least 2 generic parameters: `A`, `B`
--> $DIR/wrong-number-of-args.rs:62:12
|
LL | struct Ty<A, B, C = &'static str>;
| ^^ - -
-help: add missing type argument
+help: add missing generic argument
|
LL | type B = Ty<usize, B>;
| ^^^
-error[E0107]: this struct takes at most 3 type arguments but 4 type arguments were supplied
+error[E0107]: this struct takes at most 3 generic arguments but 4 generic arguments were supplied
--> $DIR/wrong-number-of-args.rs:76:14
|
LL | type E = Ty<usize, String, char, f64>;
- | ^^ ----- help: remove this type argument
+ | ^^ --- help: remove this generic argument
| |
- | expected at most 3 type arguments
+ | expected at most 3 generic arguments
|
-note: struct defined here, with at most 3 type parameters: `A`, `B`, `C`
+note: struct defined here, with at most 3 generic parameters: `A`, `B`, `C`
--> $DIR/wrong-number-of-args.rs:62:12
|
LL | struct Ty<A, B, C = &'static str>;
| ^^ - - -
-error[E0107]: this trait takes 0 type arguments but 1 type argument was supplied
+error[E0107]: this trait takes 0 generic arguments but 1 generic argument was supplied
--> $DIR/wrong-number-of-args.rs:96:22
|
LL | type A = Box<dyn NonGeneric<usize>>;
| ^^^^^^^^^^------- help: remove these generics
| |
- | expected 0 type arguments
+ | expected 0 generic arguments
|
-note: trait defined here, with 0 type parameters
+note: trait defined here, with 0 generic parameters
--> $DIR/wrong-number-of-args.rs:84:11
|
LL | trait NonGeneric {
@@ -247,7 +247,7 @@ error[E0107]: this trait takes 1 lifetime argument but 2 lifetime arguments were
--> $DIR/wrong-number-of-args.rs:104:22
|
LL | type C = Box<dyn GenericLifetime<'static, 'static>>;
- | ^^^^^^^^^^^^^^^ --------- help: remove this lifetime argument
+ | ^^^^^^^^^^^^^^^ ------- help: remove this lifetime argument
| |
| expected 1 lifetime argument
|
@@ -261,27 +261,27 @@ error[E0107]: missing generics for trait `GenericType`
--> $DIR/wrong-number-of-args.rs:108:22
|
LL | type D = Box<dyn GenericType>;
- | ^^^^^^^^^^^ expected 1 type argument
+ | ^^^^^^^^^^^ expected 1 generic argument
|
-note: trait defined here, with 1 type parameter: `A`
+note: trait defined here, with 1 generic parameter: `A`
--> $DIR/wrong-number-of-args.rs:92:11
|
LL | trait GenericType<A> {
| ^^^^^^^^^^^ -
-help: use angle brackets to add missing type argument
+help: add missing generic argument
|
LL | type D = Box<dyn GenericType<A>>;
- | ^^^
+ | ^^^^^^^^^^^^^^
-error[E0107]: this trait takes 1 type argument but 2 type arguments were supplied
+error[E0107]: this trait takes 1 generic argument but 2 generic arguments were supplied
--> $DIR/wrong-number-of-args.rs:112:22
|
LL | type E = Box<dyn GenericType<String, usize>>;
- | ^^^^^^^^^^^ ------- help: remove this type argument
+ | ^^^^^^^^^^^ ----- help: remove this generic argument
| |
- | expected 1 type argument
+ | expected 1 generic argument
|
-note: trait defined here, with 1 type parameter: `A`
+note: trait defined here, with 1 generic parameter: `A`
--> $DIR/wrong-number-of-args.rs:92:11
|
LL | trait GenericType<A> {
@@ -291,32 +291,32 @@ error[E0107]: missing generics for struct `HashMap`
--> $DIR/wrong-number-of-args.rs:121:18
|
LL | type A = HashMap;
- | ^^^^^^^ expected at least 2 type arguments
+ | ^^^^^^^ expected at least 2 generic arguments
|
-note: struct defined here, with at least 2 type parameters: `K`, `V`
+note: struct defined here, with at least 2 generic parameters: `K`, `V`
--> $SRC_DIR/std/src/collections/hash/map.rs:LL:COL
|
LL | pub struct HashMap<K, V, S = RandomState> {
| ^^^^^^^ - -
-help: use angle brackets to add missing type arguments
+help: add missing generic arguments
|
LL | type A = HashMap<K, V>;
- | ^^^^^^
+ | ^^^^^^^^^^^^^
-error[E0107]: this struct takes at least 2 type arguments but only 1 type argument was supplied
+error[E0107]: this struct takes at least 2 generic arguments but 1 generic argument was supplied
--> $DIR/wrong-number-of-args.rs:125:18
|
LL | type B = HashMap<String>;
- | ^^^^^^^ ------ supplied 1 type argument
+ | ^^^^^^^ ------ supplied 1 generic argument
| |
- | expected at least 2 type arguments
+ | expected at least 2 generic arguments
|
-note: struct defined here, with at least 2 type parameters: `K`, `V`
+note: struct defined here, with at least 2 generic parameters: `K`, `V`
--> $SRC_DIR/std/src/collections/hash/map.rs:LL:COL
|
LL | pub struct HashMap<K, V, S = RandomState> {
| ^^^^^^^ - -
-help: add missing type argument
+help: add missing generic argument
|
LL | type B = HashMap<String, V>;
| ^^^
@@ -335,31 +335,31 @@ note: struct defined here, with 0 lifetime parameters
LL | pub struct HashMap<K, V, S = RandomState> {
| ^^^^^^^
-error[E0107]: this struct takes at least 2 type arguments but 0 type arguments were supplied
+error[E0107]: this struct takes at least 2 generic arguments but 0 generic arguments were supplied
--> $DIR/wrong-number-of-args.rs:129:18
|
LL | type C = HashMap<'static>;
- | ^^^^^^^ expected at least 2 type arguments
+ | ^^^^^^^ expected at least 2 generic arguments
|
-note: struct defined here, with at least 2 type parameters: `K`, `V`
+note: struct defined here, with at least 2 generic parameters: `K`, `V`
--> $SRC_DIR/std/src/collections/hash/map.rs:LL:COL
|
LL | pub struct HashMap<K, V, S = RandomState> {
| ^^^^^^^ - -
-help: add missing type arguments
+help: add missing generic arguments
|
LL | type C = HashMap<'static, K, V>;
| ^^^^^^
-error[E0107]: this struct takes at most 3 type arguments but 4 type arguments were supplied
+error[E0107]: this struct takes at most 3 generic arguments but 4 generic arguments were supplied
--> $DIR/wrong-number-of-args.rs:135:18
|
LL | type D = HashMap<usize, String, char, f64>;
- | ^^^^^^^ ----- help: remove this type argument
+ | ^^^^^^^ --- help: remove this generic argument
| |
- | expected at most 3 type arguments
+ | expected at most 3 generic arguments
|
-note: struct defined here, with at most 3 type parameters: `K`, `V`, `S`
+note: struct defined here, with at most 3 generic parameters: `K`, `V`, `S`
--> $SRC_DIR/std/src/collections/hash/map.rs:LL:COL
|
LL | pub struct HashMap<K, V, S = RandomState> {
@@ -369,32 +369,32 @@ error[E0107]: missing generics for enum `Result`
--> $DIR/wrong-number-of-args.rs:141:18
|
LL | type A = Result;
- | ^^^^^^ expected 2 type arguments
+ | ^^^^^^ expected 2 generic arguments
|
-note: enum defined here, with 2 type parameters: `T`, `E`
+note: enum defined here, with 2 generic parameters: `T`, `E`
--> $SRC_DIR/core/src/result.rs:LL:COL
|
LL | pub enum Result<T, E> {
| ^^^^^^ - -
-help: use angle brackets to add missing type arguments
+help: add missing generic arguments
|
LL | type A = Result<T, E>;
- | ^^^^^^
+ | ^^^^^^^^^^^^
-error[E0107]: this enum takes 2 type arguments but only 1 type argument was supplied
+error[E0107]: this enum takes 2 generic arguments but 1 generic argument was supplied
--> $DIR/wrong-number-of-args.rs:145:18
|
LL | type B = Result<String>;
- | ^^^^^^ ------ supplied 1 type argument
+ | ^^^^^^ ------ supplied 1 generic argument
| |
- | expected 2 type arguments
+ | expected 2 generic arguments
|
-note: enum defined here, with 2 type parameters: `T`, `E`
+note: enum defined here, with 2 generic parameters: `T`, `E`
--> $SRC_DIR/core/src/result.rs:LL:COL
|
LL | pub enum Result<T, E> {
| ^^^^^^ - -
-help: add missing type argument
+help: add missing generic argument
|
LL | type B = Result<String, E>;
| ^^^
@@ -413,31 +413,31 @@ note: enum defined here, with 0 lifetime parameters
LL | pub enum Result<T, E> {
| ^^^^^^
-error[E0107]: this enum takes 2 type arguments but 0 type arguments were supplied
+error[E0107]: this enum takes 2 generic arguments but 0 generic arguments were supplied
--> $DIR/wrong-number-of-args.rs:149:18
|
LL | type C = Result<'static>;
- | ^^^^^^ expected 2 type arguments
+ | ^^^^^^ expected 2 generic arguments
|
-note: enum defined here, with 2 type parameters: `T`, `E`
+note: enum defined here, with 2 generic parameters: `T`, `E`
--> $SRC_DIR/core/src/result.rs:LL:COL
|
LL | pub enum Result<T, E> {
| ^^^^^^ - -
-help: add missing type arguments
+help: add missing generic arguments
|
LL | type C = Result<'static, T, E>;
| ^^^^^^
-error[E0107]: this enum takes 2 type arguments but 3 type arguments were supplied
+error[E0107]: this enum takes 2 generic arguments but 3 generic arguments were supplied
--> $DIR/wrong-number-of-args.rs:155:18
|
LL | type D = Result<usize, String, char>;
- | ^^^^^^ ------ help: remove this type argument
+ | ^^^^^^ ---- help: remove this generic argument
| |
- | expected 2 type arguments
+ | expected 2 generic arguments
|
-note: enum defined here, with 2 type parameters: `T`, `E`
+note: enum defined here, with 2 generic parameters: `T`, `E`
--> $SRC_DIR/core/src/result.rs:LL:COL
|
LL | pub enum Result<T, E> {
diff --git a/src/test/ui/issues/issue-14092.stderr b/src/test/ui/issues/issue-14092.stderr
index 5cacce751c925..1aa278b450f9f 100644
--- a/src/test/ui/issues/issue-14092.stderr
+++ b/src/test/ui/issues/issue-14092.stderr
@@ -2,19 +2,19 @@ error[E0107]: missing generics for struct `Box`
--> $DIR/issue-14092.rs:1:11
|
LL | fn fn1(0: Box) {}
- | ^^^ expected at least 1 type argument
+ | ^^^ expected at least 1 generic argument
|
-note: struct defined here, with at least 1 type parameter: `T`
+note: struct defined here, with at least 1 generic parameter: `T`
--> $SRC_DIR/alloc/src/boxed.rs:LL:COL
|
LL | pub struct Box<
| ^^^
LL | T: ?Sized,
| -
-help: use angle brackets to add missing type argument
+help: add missing generic argument
|
LL | fn fn1(0: Box<T>) {}
- | ^^^
+ | ^^^^^^
error: aborting due to previous error
diff --git a/src/test/ui/issues/issue-18423.stderr b/src/test/ui/issues/issue-18423.stderr
index f9006235234b3..4711a3f3ce07e 100644
--- a/src/test/ui/issues/issue-18423.stderr
+++ b/src/test/ui/issues/issue-18423.stderr
@@ -2,7 +2,7 @@ error[E0107]: this struct takes 0 lifetime arguments but 1 lifetime argument was
--> $DIR/issue-18423.rs:4:8
|
LL | x: Box<'a, isize>
- | ^^^ ---- help: remove this lifetime argument
+ | ^^^ -- help: remove this lifetime argument
| |
| expected 0 lifetime arguments
|
diff --git a/src/test/ui/issues/issue-23024.stderr b/src/test/ui/issues/issue-23024.stderr
index 1b876090ad6f6..5d7ffeb0deb0e 100644
--- a/src/test/ui/issues/issue-23024.stderr
+++ b/src/test/ui/issues/issue-23024.stderr
@@ -11,17 +11,17 @@ error[E0107]: missing generics for trait `Fn`
--> $DIR/issue-23024.rs:9:39
|
LL | println!("{:?}",(vfnfer[0] as dyn Fn)(3));
- | ^^ expected 1 type argument
+ | ^^ expected 1 generic argument
|
-note: trait defined here, with 1 type parameter: `Args`
+note: trait defined here, with 1 generic parameter: `Args`
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
|
LL | pub trait Fn<Args>: FnMut<Args> {
| ^^ ----
-help: use angle brackets to add missing type argument
+help: add missing generic argument
|
LL | println!("{:?}",(vfnfer[0] as dyn Fn<Args>)(3));
- | ^^^^^^
+ | ^^^^^^^^
error[E0191]: the value of the associated type `Output` (from trait `FnOnce`) must be specified
--> $DIR/issue-23024.rs:9:39
diff --git a/src/test/ui/issues/issue-3214.rs b/src/test/ui/issues/issue-3214.rs
index ccfaf23b4b9ff..aa43d06c99b01 100644
--- a/src/test/ui/issues/issue-3214.rs
+++ b/src/test/ui/issues/issue-3214.rs
@@ -4,7 +4,7 @@ fn foo<T>() {
}
impl<T> Drop for Foo<T> {
- //~^ ERROR this struct takes 0 type arguments but 1 type argument was supplied
+ //~^ ERROR this struct takes 0 generic arguments but 1 generic argument
//~| ERROR the type parameter `T` is not constrained by the impl trait, self type, or predicates
fn drop(&mut self) {}
}
diff --git a/src/test/ui/issues/issue-3214.stderr b/src/test/ui/issues/issue-3214.stderr
index 0da095b7fdab8..094da64d76d4d 100644
--- a/src/test/ui/issues/issue-3214.stderr
+++ b/src/test/ui/issues/issue-3214.stderr
@@ -9,15 +9,15 @@ LL | struct Foo {
LL | x: T,
| ^ use of generic parameter from outer function
-error[E0107]: this struct takes 0 type arguments but 1 type argument was supplied
+error[E0107]: this struct takes 0 generic arguments but 1 generic argument was supplied
--> $DIR/issue-3214.rs:6:22
|
LL | impl<T> Drop for Foo<T> {
| ^^^--- help: remove these generics
| |
- | expected 0 type arguments
+ | expected 0 generic arguments
|
-note: struct defined here, with 0 type parameters
+note: struct defined here, with 0 generic parameters
--> $DIR/issue-3214.rs:2:12
|
LL | struct Foo {
diff --git a/src/test/ui/issues/issue-53251.rs b/src/test/ui/issues/issue-53251.rs
index 937271d42f4bd..240826a161d97 100644
--- a/src/test/ui/issues/issue-53251.rs
+++ b/src/test/ui/issues/issue-53251.rs
@@ -9,8 +9,8 @@ macro_rules! impl_add {
$(
fn $n() {
S::f::<i64>();
- //~^ ERROR this associated function takes 0 type arguments but 1 type argument was supplied
- //~| ERROR this associated function takes 0 type arguments but 1 type argument was supplied
+ //~^ ERROR this associated function takes 0 generic
+ //~| ERROR this associated function takes 0 generic
}
)*
}
diff --git a/src/test/ui/issues/issue-53251.stderr b/src/test/ui/issues/issue-53251.stderr
index 1676c508a4dcc..708feffb84d5e 100644
--- a/src/test/ui/issues/issue-53251.stderr
+++ b/src/test/ui/issues/issue-53251.stderr
@@ -1,33 +1,33 @@
-error[E0107]: this associated function takes 0 type arguments but 1 type argument was supplied
+error[E0107]: this associated function takes 0 generic arguments but 1 generic argument was supplied
--> $DIR/issue-53251.rs:11:20
|
LL | S::f::<i64>();
| ^------- help: remove these generics
| |
- | expected 0 type arguments
+ | expected 0 generic arguments
...
LL | impl_add!(a b);
| --------------- in this macro invocation
|
-note: associated function defined here, with 0 type parameters
+note: associated function defined here, with 0 generic parameters
--> $DIR/issue-53251.rs:4:8
|
LL | fn f() {}
| ^
= note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
-error[E0107]: this associated function takes 0 type arguments but 1 type argument was supplied
+error[E0107]: this associated function takes 0 generic arguments but 1 generic argument was supplied
--> $DIR/issue-53251.rs:11:20
|
LL | S::f::<i64>();
| ^------- help: remove these generics
| |
- | expected 0 type arguments
+ | expected 0 generic arguments
...
LL | impl_add!(a b);
| --------------- in this macro invocation
|
-note: associated function defined here, with 0 type parameters
+note: associated function defined here, with 0 generic parameters
--> $DIR/issue-53251.rs:4:8
|
LL | fn f() {}
diff --git a/src/test/ui/issues/issue-60622.rs b/src/test/ui/issues/issue-60622.rs
index 1018c88ae55e3..8e230c615bc93 100644
--- a/src/test/ui/issues/issue-60622.rs
+++ b/src/test/ui/issues/issue-60622.rs
@@ -9,7 +9,7 @@ impl Borked {
fn run_wild<T>(b: &Borked) {
b.a::<'_, T>();
//~^ ERROR cannot specify lifetime arguments explicitly if late bound lifetime parameters are present
- //~| ERROR this associated function takes 0 type arguments but 1 type argument was supplied
+ //~| ERROR this associated function takes 0 generic arguments but 1 generic argument
//~| WARN this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
}
diff --git a/src/test/ui/issues/issue-60622.stderr b/src/test/ui/issues/issue-60622.stderr
index f970a63e4b2fe..b305cc7853537 100644
--- a/src/test/ui/issues/issue-60622.stderr
+++ b/src/test/ui/issues/issue-60622.stderr
@@ -16,15 +16,15 @@ LL | #![deny(warnings)]
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= note: for more information, see issue #42868 <https://github.com/rust-lang/rust/issues/42868>
-error[E0107]: this associated function takes 0 type arguments but 1 type argument was supplied
+error[E0107]: this associated function takes 0 generic arguments but 1 generic argument was supplied
--> $DIR/issue-60622.rs:10:7
|
LL | b.a::<'_, T>();
- | ^ --- help: remove this type argument
+ | ^ - help: remove this generic argument
| |
- | expected 0 type arguments
+ | expected 0 generic arguments
|
-note: associated function defined here, with 0 type parameters
+note: associated function defined here, with 0 generic parameters
--> $DIR/issue-60622.rs:6:8
|
LL | fn a(&self) {}
diff --git a/src/test/ui/methods/method-call-lifetime-args-fail.rs b/src/test/ui/methods/method-call-lifetime-args-fail.rs
index af1738512527c..6bf55844da8f2 100644
--- a/src/test/ui/methods/method-call-lifetime-args-fail.rs
+++ b/src/test/ui/methods/method-call-lifetime-args-fail.rs
@@ -14,7 +14,7 @@ impl S {
fn method_call() {
S.early(); // OK
S.early::<'static>();
- //~^ ERROR this associated function takes 2 lifetime arguments but only 1 lifetime argument was supplied
+ //~^ ERROR this associated function takes 2 lifetime arguments but 1 lifetime argument
S.early::<'static, 'static, 'static>();
//~^ ERROR this associated function takes 2 lifetime arguments but 3 lifetime arguments were supplied
let _: &u8 = S.life_and_type::<'static>();
@@ -61,7 +61,7 @@ fn ufcs() {
S::early(S); // OK
S::early::<'static>(S);
- //~^ ERROR this associated function takes 2 lifetime arguments but only 1 lifetime argument was supplied
+ //~^ ERROR this associated function takes 2 lifetime arguments but 1 lifetime argument
S::early::<'static, 'static, 'static>(S);
//~^ ERROR this associated function takes 2 lifetime arguments but 3 lifetime arguments were supplied
let _: &u8 = S::life_and_type::<'static>(S);
diff --git a/src/test/ui/methods/method-call-lifetime-args-fail.stderr b/src/test/ui/methods/method-call-lifetime-args-fail.stderr
index 2907309c27c7b..ea50815ec1af7 100644
--- a/src/test/ui/methods/method-call-lifetime-args-fail.stderr
+++ b/src/test/ui/methods/method-call-lifetime-args-fail.stderr
@@ -1,4 +1,4 @@
-error[E0107]: this associated function takes 2 lifetime arguments but only 1 lifetime argument was supplied
+error[E0107]: this associated function takes 2 lifetime arguments but 1 lifetime argument was supplied
--> $DIR/method-call-lifetime-args-fail.rs:16:7
|
LL | S.early::<'static>();
@@ -20,7 +20,7 @@ error[E0107]: this associated function takes 2 lifetime arguments but 3 lifetime
--> $DIR/method-call-lifetime-args-fail.rs:18:7
|
LL | S.early::<'static, 'static, 'static>();
- | ^^^^^ --------- help: remove this lifetime argument
+ | ^^^^^ ------- help: remove this lifetime argument
| |
| expected 2 lifetime arguments
|
@@ -198,7 +198,7 @@ note: the late bound lifetime parameter is introduced here
LL | fn late_unused_early<'a, 'b>(self) -> &'b u8 { loop {} }
| ^^
-error[E0107]: this associated function takes 2 lifetime arguments but only 1 lifetime argument was supplied
+error[E0107]: this associated function takes 2 lifetime arguments but 1 lifetime argument was supplied
--> $DIR/method-call-lifetime-args-fail.rs:63:8
|
LL | S::early::<'static>(S);
@@ -220,7 +220,7 @@ error[E0107]: this associated function takes 2 lifetime arguments but 3 lifetime
--> $DIR/method-call-lifetime-args-fail.rs:65:8
|
LL | S::early::<'static, 'static, 'static>(S);
- | ^^^^^ --------- help: remove this lifetime argument
+ | ^^^^^ ------- help: remove this lifetime argument
| |
| expected 2 lifetime arguments
|
diff --git a/src/test/ui/seq-args.rs b/src/test/ui/seq-args.rs
index 9a3c495602a69..a5ebeecd3116c 100644
--- a/src/test/ui/seq-args.rs
+++ b/src/test/ui/seq-args.rs
@@ -2,12 +2,12 @@ fn main() {
trait Seq { }
impl<T> Seq<T> for Vec<T> {
- //~^ ERROR this trait takes 0 type arguments but 1 type argument was supplied
+ //~^ ERROR this trait takes 0 generic arguments but 1 generic argument
/* ... */
}
impl Seq<bool> for u32 {
- //~^ ERROR this trait takes 0 type arguments but 1 type argument was supplied
+ //~^ ERROR this trait takes 0 generic arguments but 1 generic argument
/* Treat the integer as a sequence of bits */
}
}
diff --git a/src/test/ui/seq-args.stderr b/src/test/ui/seq-args.stderr
index 0e89fefc69ddc..c404d95748b5c 100644
--- a/src/test/ui/seq-args.stderr
+++ b/src/test/ui/seq-args.stderr
@@ -1,26 +1,26 @@
-error[E0107]: this trait takes 0 type arguments but 1 type argument was supplied
+error[E0107]: this trait takes 0 generic arguments but 1 generic argument was supplied
--> $DIR/seq-args.rs:4:13
|
LL | impl<T> Seq<T> for Vec<T> {
| ^^^--- help: remove these generics
| |
- | expected 0 type arguments
+ | expected 0 generic arguments
|
-note: trait defined here, with 0 type parameters
+note: trait defined here, with 0 generic parameters
--> $DIR/seq-args.rs:2:11
|
LL | trait Seq { }
| ^^^
-error[E0107]: this trait takes 0 type arguments but 1 type argument was supplied
+error[E0107]: this trait takes 0 generic arguments but 1 generic argument was supplied
--> $DIR/seq-args.rs:9:10
|
LL | impl Seq<bool> for u32 {
| ^^^------ help: remove these generics
| |
- | expected 0 type arguments
+ | expected 0 generic arguments
|
-note: trait defined here, with 0 type parameters
+note: trait defined here, with 0 generic parameters
--> $DIR/seq-args.rs:2:11
|
LL | trait Seq { }
diff --git a/src/test/ui/structs/structure-constructor-type-mismatch.rs b/src/test/ui/structs/structure-constructor-type-mismatch.rs
index efc6304a6f742..a03ef590cb3a1 100644
--- a/src/test/ui/structs/structure-constructor-type-mismatch.rs
+++ b/src/test/ui/structs/structure-constructor-type-mismatch.rs
@@ -45,13 +45,13 @@ fn main() {
y: 8,
};
- let pt3 = PointF::<i32> { //~ ERROR this type alias takes 0 type arguments but 1 type argument was supplied
+ let pt3 = PointF::<i32> { //~ ERROR this type alias takes 0 generic arguments but 1 generic argument
x: 9, //~ ERROR mismatched types
y: 10, //~ ERROR mismatched types
};
match (Point { x: 1, y: 2 }) {
- PointF::<u32> { .. } => {} //~ ERROR this type alias takes 0 type arguments but 1 type argument was supplied
+ PointF::<u32> { .. } => {} //~ ERROR this type alias takes 0 generic arguments but 1 generic argument
//~^ ERROR mismatched types
}
diff --git a/src/test/ui/structs/structure-constructor-type-mismatch.stderr b/src/test/ui/structs/structure-constructor-type-mismatch.stderr
index 6438127868133..3d64fc601df98 100644
--- a/src/test/ui/structs/structure-constructor-type-mismatch.stderr
+++ b/src/test/ui/structs/structure-constructor-type-mismatch.stderr
@@ -52,15 +52,15 @@ LL | x: 7,
| expected `f32`, found integer
| help: use a float literal: `7.0`
-error[E0107]: this type alias takes 0 type arguments but 1 type argument was supplied
+error[E0107]: this type alias takes 0 generic arguments but 1 generic argument was supplied
--> $DIR/structure-constructor-type-mismatch.rs:48:15
|
LL | let pt3 = PointF::<i32> {
| ^^^^^^------- help: remove these generics
| |
- | expected 0 type arguments
+ | expected 0 generic arguments
|
-note: type alias defined here, with 0 type parameters
+note: type alias defined here, with 0 generic parameters
--> $DIR/structure-constructor-type-mismatch.rs:6:6
|
LL | type PointF = Point<f32>;
@@ -84,15 +84,15 @@ LL | y: 10,
| expected `f32`, found integer
| help: use a float literal: `10.0`
-error[E0107]: this type alias takes 0 type arguments but 1 type argument was supplied
+error[E0107]: this type alias takes 0 generic arguments but 1 generic argument was supplied
--> $DIR/structure-constructor-type-mismatch.rs:54:9
|
LL | PointF::<u32> { .. } => {}
| ^^^^^^------- help: remove these generics
| |
- | expected 0 type arguments
+ | expected 0 generic arguments
|
-note: type alias defined here, with 0 type parameters
+note: type alias defined here, with 0 generic parameters
--> $DIR/structure-constructor-type-mismatch.rs:6:6
|
LL | type PointF = Point<f32>;
diff --git a/src/test/ui/suggestions/missing-lifetime-specifier.rs b/src/test/ui/suggestions/missing-lifetime-specifier.rs
index 761922beb17d5..4aaac2d95d447 100644
--- a/src/test/ui/suggestions/missing-lifetime-specifier.rs
+++ b/src/test/ui/suggestions/missing-lifetime-specifier.rs
@@ -16,44 +16,44 @@ trait Tar<'t, 'k, I> {}
thread_local! {
static a: RefCell<HashMap<i32, Vec<Vec<Foo>>>> = RefCell::new(HashMap::new());
- //~^ ERROR missing lifetime specifier
- //~| ERROR missing lifetime specifier
+ //~^ ERROR missing lifetime specifiers
+ //~| ERROR missing lifetime specifiers
}
thread_local! {
static b: RefCell<HashMap<i32, Vec<Vec<&Bar>>>> = RefCell::new(HashMap::new());
- //~^ ERROR missing lifetime specifier
- //~| ERROR missing lifetime specifier
- //~| ERROR missing lifetime specifier
- //~| ERROR missing lifetime specifier
+ //~^ ERROR missing lifetime specifier
+ //~| ERROR missing lifetime specifier
+ //~| ERROR missing lifetime specifier
+ //~| ERROR missing lifetime specifier
}
thread_local! {
static c: RefCell<HashMap<i32, Vec<Vec<Qux<i32>>>>> = RefCell::new(HashMap::new());
- //~^ ERROR missing lifetime specifier
- //~| ERROR missing lifetime specifier
+ //~^ ERROR missing lifetime
+ //~| ERROR missing lifetime
}
thread_local! {
static d: RefCell<HashMap<i32, Vec<Vec<&Tar<i32>>>>> = RefCell::new(HashMap::new());
- //~^ ERROR missing lifetime specifier
- //~| ERROR missing lifetime specifier
- //~| ERROR missing lifetime specifier
- //~| ERROR missing lifetime specifier
+ //~^ ERROR missing lifetime
+ //~| ERROR missing lifetime
+ //~| ERROR missing lifetime
+ //~| ERROR missing lifetime
}
thread_local! {
static e: RefCell<HashMap<i32, Vec<Vec<Qux<'static, i32>>>>> = RefCell::new(HashMap::new());
- //~^ ERROR this union takes 2 lifetime arguments but only 1 lifetime argument was supplied
- //~| ERROR this union takes 2 lifetime arguments but only 1 lifetime argument was supplied
- //~| ERROR this union takes 2 lifetime arguments but only 1 lifetime argument was supplied
- //~| ERROR this union takes 2 lifetime arguments but only 1 lifetime argument was supplied
+ //~^ ERROR this union takes 2 lifetime arguments but 1 lifetime argument
+ //~| ERROR this union takes 2 lifetime arguments but 1 lifetime argument was supplied
+ //~| ERROR this union takes 2 lifetime arguments but 1 lifetime argument was supplied
+ //~| ERROR this union takes 2 lifetime arguments but 1 lifetime argument was supplied
}
thread_local! {
static f: RefCell<HashMap<i32, Vec<Vec<&Tar<'static, i32>>>>> = RefCell::new(HashMap::new());
- //~^ ERROR this trait takes 2 lifetime arguments but only 1 lifetime argument was supplied
- //~| ERROR this trait takes 2 lifetime arguments but only 1 lifetime argument was supplied
- //~| ERROR this trait takes 2 lifetime arguments but only 1 lifetime argument was supplied
- //~| ERROR this trait takes 2 lifetime arguments but only 1 lifetime argument was supplied
- //~| ERROR missing lifetime specifier
- //~| ERROR missing lifetime specifier
+ //~^ ERROR this trait takes 2 lifetime arguments but 1 lifetime argument was supplied
+ //~| ERROR this trait takes 2 lifetime arguments but 1 lifetime argument was supplied
+ //~| ERROR this trait takes 2 lifetime arguments but 1 lifetime argument was supplied
+ //~| ERROR this trait takes 2 lifetime arguments but 1 lifetime argument was supplied
+ //~| ERROR missing lifetime
+ //~| ERROR missing lifetime
}
fn main() {}
diff --git a/src/test/ui/suggestions/missing-lifetime-specifier.stderr b/src/test/ui/suggestions/missing-lifetime-specifier.stderr
index 489926ea78a9d..8ddd2f7d52221 100644
--- a/src/test/ui/suggestions/missing-lifetime-specifier.stderr
+++ b/src/test/ui/suggestions/missing-lifetime-specifier.stderr
@@ -142,7 +142,7 @@ help: consider using the `'static` lifetime
LL | static d: RefCell<HashMap<i32, Vec<Vec<&Tar<'static, 'static, i32>>>>> = RefCell::new(HashMap::new());
| ^^^^^^^^^^^^^^^^^
-error[E0107]: this union takes 2 lifetime arguments but only 1 lifetime argument was supplied
+error[E0107]: this union takes 2 lifetime arguments but 1 lifetime argument was supplied
--> $DIR/missing-lifetime-specifier.rs:43:44
|
LL | static e: RefCell<HashMap<i32, Vec<Vec<Qux<'static, i32>>>>> = RefCell::new(HashMap::new());
@@ -157,10 +157,10 @@ LL | pub union Qux<'t, 'k, I> {
| ^^^ -- --
help: add missing lifetime argument
|
-LL | static e: RefCell<HashMap<i32, Vec<Vec<Qux<'static, 'k, i32>>>>> = RefCell::new(HashMap::new());
+LL | static e: RefCell<HashMap<i32, Vec<Vec<Qux<'static, '_, i32>>>>> = RefCell::new(HashMap::new());
| ^^^^
-error[E0107]: this union takes 2 lifetime arguments but only 1 lifetime argument was supplied
+error[E0107]: this union takes 2 lifetime arguments but 1 lifetime argument was supplied
--> $DIR/missing-lifetime-specifier.rs:43:44
|
LL | static e: RefCell<HashMap<i32, Vec<Vec<Qux<'static, i32>>>>> = RefCell::new(HashMap::new());
@@ -178,7 +178,7 @@ help: add missing lifetime argument
LL | static e: RefCell<HashMap<i32, Vec<Vec<Qux<'static, 'k, i32>>>>> = RefCell::new(HashMap::new());
| ^^^^
-error[E0107]: this union takes 2 lifetime arguments but only 1 lifetime argument was supplied
+error[E0107]: this union takes 2 lifetime arguments but 1 lifetime argument was supplied
--> $DIR/missing-lifetime-specifier.rs:43:44
|
LL | static e: RefCell<HashMap<i32, Vec<Vec<Qux<'static, i32>>>>> = RefCell::new(HashMap::new());
@@ -196,7 +196,7 @@ help: add missing lifetime argument
LL | static e: RefCell<HashMap<i32, Vec<Vec<Qux<'static, 'k, i32>>>>> = RefCell::new(HashMap::new());
| ^^^^
-error[E0107]: this union takes 2 lifetime arguments but only 1 lifetime argument was supplied
+error[E0107]: this union takes 2 lifetime arguments but 1 lifetime argument was supplied
--> $DIR/missing-lifetime-specifier.rs:43:44
|
LL | static e: RefCell<HashMap<i32, Vec<Vec<Qux<'static, i32>>>>> = RefCell::new(HashMap::new());
@@ -211,10 +211,10 @@ LL | pub union Qux<'t, 'k, I> {
| ^^^ -- --
help: add missing lifetime argument
|
-LL | static e: RefCell<HashMap<i32, Vec<Vec<Qux<'static, 'k, i32>>>>> = RefCell::new(HashMap::new());
+LL | static e: RefCell<HashMap<i32, Vec<Vec<Qux<'static, '_, i32>>>>> = RefCell::new(HashMap::new());
| ^^^^
-error[E0107]: this trait takes 2 lifetime arguments but only 1 lifetime argument was supplied
+error[E0107]: this trait takes 2 lifetime arguments but 1 lifetime argument was supplied
--> $DIR/missing-lifetime-specifier.rs:50:45
|
LL | static f: RefCell<HashMap<i32, Vec<Vec<&Tar<'static, i32>>>>> = RefCell::new(HashMap::new());
@@ -229,7 +229,7 @@ LL | trait Tar<'t, 'k, I> {}
| ^^^ -- --
help: add missing lifetime argument
|
-LL | static f: RefCell<HashMap<i32, Vec<Vec<&Tar<'static, 'k, i32>>>>> = RefCell::new(HashMap::new());
+LL | static f: RefCell<HashMap<i32, Vec<Vec<&Tar<'static, '_, i32>>>>> = RefCell::new(HashMap::new());
| ^^^^
error[E0106]: missing lifetime specifier
@@ -244,7 +244,7 @@ help: consider using the `'static` lifetime
LL | static f: RefCell<HashMap<i32, Vec<Vec<&'static Tar<'static, i32>>>>> = RefCell::new(HashMap::new());
| ^^^^^^^^
-error[E0107]: this trait takes 2 lifetime arguments but only 1 lifetime argument was supplied
+error[E0107]: this trait takes 2 lifetime arguments but 1 lifetime argument was supplied
--> $DIR/missing-lifetime-specifier.rs:50:45
|
LL | static f: RefCell<HashMap<i32, Vec<Vec<&Tar<'static, i32>>>>> = RefCell::new(HashMap::new());
@@ -274,7 +274,7 @@ help: consider using the `'static` lifetime
LL | static f: RefCell<HashMap<i32, Vec<Vec<&'static Tar<'static, i32>>>>> = RefCell::new(HashMap::new());
| ^^^^^^^^
-error[E0107]: this trait takes 2 lifetime arguments but only 1 lifetime argument was supplied
+error[E0107]: this trait takes 2 lifetime arguments but 1 lifetime argument was supplied
--> $DIR/missing-lifetime-specifier.rs:50:45
|
LL | static f: RefCell<HashMap<i32, Vec<Vec<&Tar<'static, i32>>>>> = RefCell::new(HashMap::new());
@@ -292,7 +292,7 @@ help: add missing lifetime argument
LL | static f: RefCell<HashMap<i32, Vec<Vec<&Tar<'static, 'k, i32>>>>> = RefCell::new(HashMap::new());
| ^^^^
-error[E0107]: this trait takes 2 lifetime arguments but only 1 lifetime argument was supplied
+error[E0107]: this trait takes 2 lifetime arguments but 1 lifetime argument was supplied
--> $DIR/missing-lifetime-specifier.rs:50:45
|
LL | static f: RefCell<HashMap<i32, Vec<Vec<&Tar<'static, i32>>>>> = RefCell::new(HashMap::new());
@@ -307,7 +307,7 @@ LL | trait Tar<'t, 'k, I> {}
| ^^^ -- --
help: add missing lifetime argument
|
-LL | static f: RefCell<HashMap<i32, Vec<Vec<&Tar<'static, 'k, i32>>>>> = RefCell::new(HashMap::new());
+LL | static f: RefCell<HashMap<i32, Vec<Vec<&Tar<'static, '_, i32>>>>> = RefCell::new(HashMap::new());
| ^^^^
error: aborting due to 22 previous errors
diff --git a/src/test/ui/suggestions/use-type-argument-instead-of-assoc-type.rs b/src/test/ui/suggestions/use-type-argument-instead-of-assoc-type.rs
index 05e2d38c43b53..8b6e8cfd720be 100644
--- a/src/test/ui/suggestions/use-type-argument-instead-of-assoc-type.rs
+++ b/src/test/ui/suggestions/use-type-argument-instead-of-assoc-type.rs
@@ -6,7 +6,7 @@ pub trait T<X, Y> {
pub struct Foo {
i: Box<dyn T<usize, usize, usize, usize, B=usize>>,
//~^ ERROR must be specified
- //~| ERROR this trait takes 2 type arguments but 4 type arguments were supplied
+ //~| ERROR this trait takes 2 generic arguments but 4 generic arguments were supplied
}
diff --git a/src/test/ui/suggestions/use-type-argument-instead-of-assoc-type.stderr b/src/test/ui/suggestions/use-type-argument-instead-of-assoc-type.stderr
index 2d06591f4c7bd..f1248643105eb 100644
--- a/src/test/ui/suggestions/use-type-argument-instead-of-assoc-type.stderr
+++ b/src/test/ui/suggestions/use-type-argument-instead-of-assoc-type.stderr
@@ -1,12 +1,12 @@
-error[E0107]: this trait takes 2 type arguments but 4 type arguments were supplied
+error[E0107]: this trait takes 2 generic arguments but 4 generic arguments were supplied
--> $DIR/use-type-argument-instead-of-assoc-type.rs:7:16
|
LL | i: Box<dyn T<usize, usize, usize, usize, B=usize>>,
- | ^ -------------- help: remove these type arguments
+ | ^ ------------ help: remove these generic arguments
| |
- | expected 2 type arguments
+ | expected 2 generic arguments
|
-note: trait defined here, with 2 type parameters: `X`, `Y`
+note: trait defined here, with 2 generic parameters: `X`, `Y`
--> $DIR/use-type-argument-instead-of-assoc-type.rs:1:11
|
LL | pub trait T<X, Y> {
diff --git a/src/test/ui/tag-type-args.stderr b/src/test/ui/tag-type-args.stderr
index c9888dc54dc52..7523a931dd58f 100644
--- a/src/test/ui/tag-type-args.stderr
+++ b/src/test/ui/tag-type-args.stderr
@@ -2,17 +2,17 @@ error[E0107]: missing generics for enum `Quux`
--> $DIR/tag-type-args.rs:3:11
|
LL | fn foo(c: Quux) { assert!((false)); }
- | ^^^^ expected 1 type argument
+ | ^^^^ expected 1 generic argument
|
-note: enum defined here, with 1 type parameter: `T`
+note: enum defined here, with 1 generic parameter: `T`
--> $DIR/tag-type-args.rs:1:6
|
LL | enum Quux<T> { Bar }
| ^^^^ -
-help: use angle brackets to add missing type argument
+help: add missing generic argument
|
LL | fn foo(c: Quux<T>) { assert!((false)); }
- | ^^^
+ | ^^^^^^^
error: aborting due to previous error
diff --git a/src/test/ui/traits/object/vs-lifetime.rs b/src/test/ui/traits/object/vs-lifetime.rs
index e49d276a55a92..14ae67cffd703 100644
--- a/src/test/ui/traits/object/vs-lifetime.rs
+++ b/src/test/ui/traits/object/vs-lifetime.rs
@@ -10,7 +10,7 @@ fn main() {
//~^ at least one trait is required for an object type
let _: S<'static, 'static>;
//~^ ERROR this struct takes 1 lifetime argument but 2 lifetime arguments were supplied
- //~| ERROR this struct takes 1 type argument but 0 type arguments were supplied
+ //~| ERROR this struct takes 1 generic argument but 0 generic arguments were supplied
let _: S<dyn 'static +, 'static>;
//~^ ERROR type provided when a lifetime was expected
//~| ERROR at least one trait is required for an object type
diff --git a/src/test/ui/traits/object/vs-lifetime.stderr b/src/test/ui/traits/object/vs-lifetime.stderr
index 6673472e4a967..40f5fcbceaf0b 100644
--- a/src/test/ui/traits/object/vs-lifetime.stderr
+++ b/src/test/ui/traits/object/vs-lifetime.stderr
@@ -8,7 +8,7 @@ error[E0107]: this struct takes 1 lifetime argument but 2 lifetime arguments wer
--> $DIR/vs-lifetime.rs:11:12
|
LL | let _: S<'static, 'static>;
- | ^ --------- help: remove this lifetime argument
+ | ^ ------- help: remove this lifetime argument
| |
| expected 1 lifetime argument
|
@@ -18,18 +18,18 @@ note: struct defined here, with 1 lifetime parameter: `'a`
LL | struct S<'a, T>(&'a u8, T);
| ^ --
-error[E0107]: this struct takes 1 type argument but 0 type arguments were supplied
+error[E0107]: this struct takes 1 generic argument but 0 generic arguments were supplied
--> $DIR/vs-lifetime.rs:11:12
|
LL | let _: S<'static, 'static>;
- | ^ expected 1 type argument
+ | ^ expected 1 generic argument
|
-note: struct defined here, with 1 type parameter: `T`
+note: struct defined here, with 1 generic parameter: `T`
--> $DIR/vs-lifetime.rs:4:8
|
LL | struct S<'a, T>(&'a u8, T);
| ^ -
-help: add missing type argument
+help: add missing generic argument
|
LL | let _: S<'static, 'static, T>;
| ^^^
diff --git a/src/test/ui/traits/test-2.rs b/src/test/ui/traits/test-2.rs
index a33773144c21b..183c779607c95 100644
--- a/src/test/ui/traits/test-2.rs
+++ b/src/test/ui/traits/test-2.rs
@@ -7,9 +7,9 @@ impl bar for u32 { fn dup(&self) -> u32 { *self } fn blah<X>(&self) {} }
fn main() {
10.dup::<i32>();
- //~^ ERROR this associated function takes 0 type arguments but 1 type argument was supplied
+ //~^ ERROR this associated function takes 0 generic arguments but 1
10.blah::<i32, i32>();
- //~^ ERROR this associated function takes 1 type argument but 2 type arguments were supplied
+ //~^ ERROR this associated function takes 1 generic argument but 2
(box 10 as Box<dyn bar>).dup();
//~^ ERROR E0038
//~| ERROR E0038
diff --git a/src/test/ui/traits/test-2.stderr b/src/test/ui/traits/test-2.stderr
index 12b55c3a4fdf9..0289424510f97 100644
--- a/src/test/ui/traits/test-2.stderr
+++ b/src/test/ui/traits/test-2.stderr
@@ -1,26 +1,26 @@
-error[E0107]: this associated function takes 0 type arguments but 1 type argument was supplied
+error[E0107]: this associated function takes 0 generic arguments but 1 generic argument was supplied
--> $DIR/test-2.rs:9:8
|
LL | 10.dup::<i32>();
| ^^^------- help: remove these generics
| |
- | expected 0 type arguments
+ | expected 0 generic arguments
|
-note: associated function defined here, with 0 type parameters
+note: associated function defined here, with 0 generic parameters
--> $DIR/test-2.rs:4:16
|
LL | trait bar { fn dup(&self) -> Self; fn blah<X>(&self); }
| ^^^
-error[E0107]: this associated function takes 1 type argument but 2 type arguments were supplied
+error[E0107]: this associated function takes 1 generic argument but 2 generic arguments were supplied
--> $DIR/test-2.rs:11:8
|
LL | 10.blah::<i32, i32>();
- | ^^^^ ----- help: remove this type argument
+ | ^^^^ --- help: remove this generic argument
| |
- | expected 1 type argument
+ | expected 1 generic argument
|
-note: associated function defined here, with 1 type parameter: `X`
+note: associated function defined here, with 1 generic parameter: `X`
--> $DIR/test-2.rs:4:39
|
LL | trait bar { fn dup(&self) -> Self; fn blah<X>(&self); }
diff --git a/src/test/ui/type-alias-enum-variants/enum-variant-generic-args.rs b/src/test/ui/type-alias-enum-variants/enum-variant-generic-args.rs
index f204035248a6f..6bc4f528faaf9 100644
--- a/src/test/ui/type-alias-enum-variants/enum-variant-generic-args.rs
+++ b/src/test/ui/type-alias-enum-variants/enum-variant-generic-args.rs
@@ -62,10 +62,10 @@ fn main() {
AliasFixed::TSVariant::<()>(());
//~^ ERROR type arguments are not allowed for this type [E0109]
AliasFixed::<()>::TSVariant(());
- //~^ ERROR this type alias takes 0 type arguments but 1 type argument was supplied [E0107]
+ //~^ ERROR this type alias takes 0 generic arguments but 1 generic argument was supplied [E0107]
AliasFixed::<()>::TSVariant::<()>(());
//~^ ERROR type arguments are not allowed for this type [E0109]
- //~| ERROR this type alias takes 0 type arguments but 1 type argument was supplied [E0107]
+ //~| ERROR this type alias takes 0 generic arguments but 1 generic argument was supplied [E0107]
// Struct variant
@@ -80,10 +80,10 @@ fn main() {
AliasFixed::SVariant::<()> { v: () };
//~^ ERROR type arguments are not allowed for this type [E0109]
AliasFixed::<()>::SVariant { v: () };
- //~^ ERROR this type alias takes 0 type arguments but 1 type argument was supplied [E0107]
+ //~^ ERROR this type alias takes 0 generic arguments but 1 generic argument was supplied [E0107]
AliasFixed::<()>::SVariant::<()> { v: () };
//~^ ERROR type arguments are not allowed for this type [E0109]
- //~| ERROR this type alias takes 0 type arguments but 1 type argument was supplied [E0107]
+ //~| ERROR this type alias takes 0 generic arguments but 1 generic argument was supplied [E0107]
// Unit variant
@@ -98,8 +98,8 @@ fn main() {
AliasFixed::UVariant::<()>;
//~^ ERROR type arguments are not allowed for this type [E0109]
AliasFixed::<()>::UVariant;
- //~^ ERROR this type alias takes 0 type arguments but 1 type argument was supplied [E0107]
+ //~^ ERROR this type alias takes 0 generic arguments but 1 generic argument was supplied [E0107]
AliasFixed::<()>::UVariant::<()>;
//~^ ERROR type arguments are not allowed for this type [E0109]
- //~| ERROR this type alias takes 0 type arguments but 1 type argument was supplied [E0107]
+ //~| ERROR this type alias takes 0 generic arguments but 1 generic argument was supplied [E0107]
}
diff --git a/src/test/ui/type-alias-enum-variants/enum-variant-generic-args.stderr b/src/test/ui/type-alias-enum-variants/enum-variant-generic-args.stderr
index e83db3b0d512b..a384d5f561c94 100644
--- a/src/test/ui/type-alias-enum-variants/enum-variant-generic-args.stderr
+++ b/src/test/ui/type-alias-enum-variants/enum-variant-generic-args.stderr
@@ -166,29 +166,29 @@ error[E0109]: type arguments are not allowed for this type
LL | AliasFixed::TSVariant::<()>(());
| ^^ type argument not allowed
-error[E0107]: this type alias takes 0 type arguments but 1 type argument was supplied
+error[E0107]: this type alias takes 0 generic arguments but 1 generic argument was supplied
--> $DIR/enum-variant-generic-args.rs:64:5
|
LL | AliasFixed::<()>::TSVariant(());
| ^^^^^^^^^^------ help: remove these generics
| |
- | expected 0 type arguments
+ | expected 0 generic arguments
|
-note: type alias defined here, with 0 type parameters
+note: type alias defined here, with 0 generic parameters
--> $DIR/enum-variant-generic-args.rs:9:6
|
LL | type AliasFixed = Enum<()>;
| ^^^^^^^^^^
-error[E0107]: this type alias takes 0 type arguments but 1 type argument was supplied
+error[E0107]: this type alias takes 0 generic arguments but 1 generic argument was supplied
--> $DIR/enum-variant-generic-args.rs:66:5
|
LL | AliasFixed::<()>::TSVariant::<()>(());
| ^^^^^^^^^^------ help: remove these generics
| |
- | expected 0 type arguments
+ | expected 0 generic arguments
|
-note: type alias defined here, with 0 type parameters
+note: type alias defined here, with 0 generic parameters
--> $DIR/enum-variant-generic-args.rs:9:6
|
LL | type AliasFixed = Enum<()>;
@@ -224,29 +224,29 @@ error[E0109]: type arguments are not allowed for this type
LL | AliasFixed::SVariant::<()> { v: () };
| ^^ type argument not allowed
-error[E0107]: this type alias takes 0 type arguments but 1 type argument was supplied
+error[E0107]: this type alias takes 0 generic arguments but 1 generic argument was supplied
--> $DIR/enum-variant-generic-args.rs:82:5
|
LL | AliasFixed::<()>::SVariant { v: () };
| ^^^^^^^^^^------ help: remove these generics
| |
- | expected 0 type arguments
+ | expected 0 generic arguments
|
-note: type alias defined here, with 0 type parameters
+note: type alias defined here, with 0 generic parameters
--> $DIR/enum-variant-generic-args.rs:9:6
|
LL | type AliasFixed = Enum<()>;
| ^^^^^^^^^^
-error[E0107]: this type alias takes 0 type arguments but 1 type argument was supplied
+error[E0107]: this type alias takes 0 generic arguments but 1 generic argument was supplied
--> $DIR/enum-variant-generic-args.rs:84:5
|
LL | AliasFixed::<()>::SVariant::<()> { v: () };
| ^^^^^^^^^^------ help: remove these generics
| |
- | expected 0 type arguments
+ | expected 0 generic arguments
|
-note: type alias defined here, with 0 type parameters
+note: type alias defined here, with 0 generic parameters
--> $DIR/enum-variant-generic-args.rs:9:6
|
LL | type AliasFixed = Enum<()>;
@@ -282,29 +282,29 @@ error[E0109]: type arguments are not allowed for this type
LL | AliasFixed::UVariant::<()>;
| ^^ type argument not allowed
-error[E0107]: this type alias takes 0 type arguments but 1 type argument was supplied
+error[E0107]: this type alias takes 0 generic arguments but 1 generic argument was supplied
--> $DIR/enum-variant-generic-args.rs:100:5
|
LL | AliasFixed::<()>::UVariant;
| ^^^^^^^^^^------ help: remove these generics
| |
- | expected 0 type arguments
+ | expected 0 generic arguments
|
-note: type alias defined here, with 0 type parameters
+note: type alias defined here, with 0 generic parameters
--> $DIR/enum-variant-generic-args.rs:9:6
|
LL | type AliasFixed = Enum<()>;
| ^^^^^^^^^^
-error[E0107]: this type alias takes 0 type arguments but 1 type argument was supplied
+error[E0107]: this type alias takes 0 generic arguments but 1 generic argument was supplied
--> $DIR/enum-variant-generic-args.rs:102:5
|
LL | AliasFixed::<()>::UVariant::<()>;
| ^^^^^^^^^^------ help: remove these generics
| |
- | expected 0 type arguments
+ | expected 0 generic arguments
|
-note: type alias defined here, with 0 type parameters
+note: type alias defined here, with 0 generic parameters
--> $DIR/enum-variant-generic-args.rs:9:6
|
LL | type AliasFixed = Enum<()>;
diff --git a/src/test/ui/type/ascription/issue-34255-1.stderr b/src/test/ui/type/ascription/issue-34255-1.stderr
index fc474e1ec3b75..00449af6a459f 100644
--- a/src/test/ui/type/ascription/issue-34255-1.stderr
+++ b/src/test/ui/type/ascription/issue-34255-1.stderr
@@ -14,17 +14,17 @@ error[E0107]: missing generics for struct `Vec`
--> $DIR/issue-34255-1.rs:7:22
|
LL | input_cells: Vec::new()
- | ^^^ expected at least 1 type argument
+ | ^^^ expected at least 1 generic argument
|
-note: struct defined here, with at least 1 type parameter: `T`
+note: struct defined here, with at least 1 generic parameter: `T`
--> $SRC_DIR/alloc/src/vec/mod.rs:LL:COL
|
LL | pub struct Vec<T, #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global> {
| ^^^ -
-help: use angle brackets to add missing type argument
+help: add missing generic argument
|
LL | input_cells: Vec<T>::new()
- | ^^^
+ | ^^^^^^
error: aborting due to 3 previous errors
diff --git a/src/test/ui/typeck/issue-75883.rs b/src/test/ui/typeck/issue-75883.rs
index 3a59ca049ba3e..8cd34f48835ed 100644
--- a/src/test/ui/typeck/issue-75883.rs
+++ b/src/test/ui/typeck/issue-75883.rs
@@ -4,7 +4,7 @@ pub struct UI {}
impl UI {
pub fn run() -> Result<_> {
- //~^ ERROR: this enum takes 2 type arguments but only 1 type argument was supplied
+ //~^ ERROR: this enum takes 2 generic arguments but 1 generic argument was supplied
//~| ERROR: the type placeholder `_` is not allowed within types on item signatures
let mut ui = UI {};
ui.interact();
@@ -13,7 +13,7 @@ impl UI {
}
pub fn interact(&mut self) -> Result<_> {
- //~^ ERROR: this enum takes 2 type arguments but only 1 type argument was supplied
+ //~^ ERROR: this enum takes 2 generic arguments but 1 generic argument was supplied
//~| ERROR: the type placeholder `_` is not allowed within types on item signatures
unimplemented!();
}
diff --git a/src/test/ui/typeck/issue-75883.stderr b/src/test/ui/typeck/issue-75883.stderr
index a6b2eb8f9727c..71f4138c81d56 100644
--- a/src/test/ui/typeck/issue-75883.stderr
+++ b/src/test/ui/typeck/issue-75883.stderr
@@ -1,35 +1,35 @@
-error[E0107]: this enum takes 2 type arguments but only 1 type argument was supplied
+error[E0107]: this enum takes 2 generic arguments but 1 generic argument was supplied
--> $DIR/issue-75883.rs:6:21
|
LL | pub fn run() -> Result<_> {
- | ^^^^^^ - supplied 1 type argument
+ | ^^^^^^ - supplied 1 generic argument
| |
- | expected 2 type arguments
+ | expected 2 generic arguments
|
-note: enum defined here, with 2 type parameters: `T`, `E`
+note: enum defined here, with 2 generic parameters: `T`, `E`
--> $SRC_DIR/core/src/result.rs:LL:COL
|
LL | pub enum Result<T, E> {
| ^^^^^^ - -
-help: add missing type argument
+help: add missing generic argument
|
LL | pub fn run() -> Result<_, E> {
| ^^^
-error[E0107]: this enum takes 2 type arguments but only 1 type argument was supplied
+error[E0107]: this enum takes 2 generic arguments but 1 generic argument was supplied
--> $DIR/issue-75883.rs:15:35
|
LL | pub fn interact(&mut self) -> Result<_> {
- | ^^^^^^ - supplied 1 type argument
+ | ^^^^^^ - supplied 1 generic argument
| |
- | expected 2 type arguments
+ | expected 2 generic arguments
|
-note: enum defined here, with 2 type parameters: `T`, `E`
+note: enum defined here, with 2 generic parameters: `T`, `E`
--> $SRC_DIR/core/src/result.rs:LL:COL
|
LL | pub enum Result<T, E> {
| ^^^^^^ - -
-help: add missing type argument
+help: add missing generic argument
|
LL | pub fn interact(&mut self) -> Result<_, E> {
| ^^^
diff --git a/src/test/ui/typeck/typeck-builtin-bound-type-parameters.rs b/src/test/ui/typeck/typeck-builtin-bound-type-parameters.rs
index f1659d086702e..c463a8ad0c757 100644
--- a/src/test/ui/typeck/typeck-builtin-bound-type-parameters.rs
+++ b/src/test/ui/typeck/typeck-builtin-bound-type-parameters.rs
@@ -1,17 +1,17 @@
fn foo1<T:Copy<U>, U>(x: T) {}
-//~^ ERROR this trait takes 0 type arguments but 1 type argument was supplied
+//~^ ERROR this trait takes 0 generic arguments but 1 generic argument was supplied
trait Trait: Copy<dyn Send> {}
-//~^ ERROR this trait takes 0 type arguments but 1 type argument was supplied
+//~^ ERROR this trait takes 0 generic arguments but 1 generic argument was supplied
struct MyStruct1<T: Copy<T>>;
-//~^ ERROR this trait takes 0 type arguments but 1 type argument was supplied
+//~^ ERROR this trait takes 0 generic arguments but 1 generic argument was supplied
struct MyStruct2<'a, T: Copy<'a>>;
//~^ ERROR this trait takes 0 lifetime arguments but 1 lifetime argument was supplied
fn foo2<'a, T:Copy<'a, U>, U>(x: T) {}
//~^ ERROR this trait takes 0 lifetime arguments but 1 lifetime argument was supplied
-//~| ERROR this trait takes 0 type arguments but 1 type argument was supplied
+//~| ERROR this trait takes 0 generic arguments but 1 generic argument was supplied
fn main() { }
diff --git a/src/test/ui/typeck/typeck-builtin-bound-type-parameters.stderr b/src/test/ui/typeck/typeck-builtin-bound-type-parameters.stderr
index 777bc1c95b0b3..bf74dd7dec004 100644
--- a/src/test/ui/typeck/typeck-builtin-bound-type-parameters.stderr
+++ b/src/test/ui/typeck/typeck-builtin-bound-type-parameters.stderr
@@ -1,40 +1,40 @@
-error[E0107]: this trait takes 0 type arguments but 1 type argument was supplied
+error[E0107]: this trait takes 0 generic arguments but 1 generic argument was supplied
--> $DIR/typeck-builtin-bound-type-parameters.rs:1:11
|
LL | fn foo1<T:Copy<U>, U>(x: T) {}
| ^^^^--- help: remove these generics
| |
- | expected 0 type arguments
+ | expected 0 generic arguments
|
-note: trait defined here, with 0 type parameters
+note: trait defined here, with 0 generic parameters
--> $SRC_DIR/core/src/marker.rs:LL:COL
|
LL | pub trait Copy: Clone {
| ^^^^
-error[E0107]: this trait takes 0 type arguments but 1 type argument was supplied
+error[E0107]: this trait takes 0 generic arguments but 1 generic argument was supplied
--> $DIR/typeck-builtin-bound-type-parameters.rs:4:14
|
LL | trait Trait: Copy<dyn Send> {}
| ^^^^---------- help: remove these generics
| |
- | expected 0 type arguments
+ | expected 0 generic arguments
|
-note: trait defined here, with 0 type parameters
+note: trait defined here, with 0 generic parameters
--> $SRC_DIR/core/src/marker.rs:LL:COL
|
LL | pub trait Copy: Clone {
| ^^^^
-error[E0107]: this trait takes 0 type arguments but 1 type argument was supplied
+error[E0107]: this trait takes 0 generic arguments but 1 generic argument was supplied
--> $DIR/typeck-builtin-bound-type-parameters.rs:7:21
|
LL | struct MyStruct1<T: Copy<T>>;
| ^^^^--- help: remove these generics
| |
- | expected 0 type arguments
+ | expected 0 generic arguments
|
-note: trait defined here, with 0 type parameters
+note: trait defined here, with 0 generic parameters
--> $SRC_DIR/core/src/marker.rs:LL:COL
|
LL | pub trait Copy: Clone {
@@ -58,7 +58,7 @@ error[E0107]: this trait takes 0 lifetime arguments but 1 lifetime argument was
--> $DIR/typeck-builtin-bound-type-parameters.rs:13:15
|
LL | fn foo2<'a, T:Copy<'a, U>, U>(x: T) {}
- | ^^^^ ---- help: remove this lifetime argument
+ | ^^^^ -- help: remove this lifetime argument
| |
| expected 0 lifetime arguments
|
@@ -68,15 +68,15 @@ note: trait defined here, with 0 lifetime parameters
LL | pub trait Copy: Clone {
| ^^^^
-error[E0107]: this trait takes 0 type arguments but 1 type argument was supplied
+error[E0107]: this trait takes 0 generic arguments but 1 generic argument was supplied
--> $DIR/typeck-builtin-bound-type-parameters.rs:13:15
|
LL | fn foo2<'a, T:Copy<'a, U>, U>(x: T) {}
- | ^^^^ --- help: remove this type argument
+ | ^^^^ - help: remove this generic argument
| |
- | expected 0 type arguments
+ | expected 0 generic arguments
|
-note: trait defined here, with 0 type parameters
+note: trait defined here, with 0 generic parameters
--> $SRC_DIR/core/src/marker.rs:LL:COL
|
LL | pub trait Copy: Clone {
diff --git a/src/test/ui/typeck/typeck_type_placeholder_lifetime_1.rs b/src/test/ui/typeck/typeck_type_placeholder_lifetime_1.rs
index 8f8917e16afda..43e46c5b6c3d7 100644
--- a/src/test/ui/typeck/typeck_type_placeholder_lifetime_1.rs
+++ b/src/test/ui/typeck/typeck_type_placeholder_lifetime_1.rs
@@ -7,5 +7,5 @@ struct Foo<'a, T:'a> {
pub fn main() {
let c: Foo<_, _> = Foo { r: &5 };
- //~^ ERROR this struct takes 1 type argument but 2 type arguments were supplied
+ //~^ ERROR this struct takes 1 generic argument but 2 generic arguments were supplied
}
diff --git a/src/test/ui/typeck/typeck_type_placeholder_lifetime_1.stderr b/src/test/ui/typeck/typeck_type_placeholder_lifetime_1.stderr
index 01ab8e78d7ca3..a89c6b85c78ed 100644
--- a/src/test/ui/typeck/typeck_type_placeholder_lifetime_1.stderr
+++ b/src/test/ui/typeck/typeck_type_placeholder_lifetime_1.stderr
@@ -1,12 +1,12 @@
-error[E0107]: this struct takes 1 type argument but 2 type arguments were supplied
+error[E0107]: this struct takes 1 generic argument but 2 generic arguments were supplied
--> $DIR/typeck_type_placeholder_lifetime_1.rs:9:12
|
LL | let c: Foo<_, _> = Foo { r: &5 };
- | ^^^ --- help: remove this type argument
+ | ^^^ - help: remove this generic argument
| |
- | expected 1 type argument
+ | expected 1 generic argument
|
-note: struct defined here, with 1 type parameter: `T`
+note: struct defined here, with 1 generic parameter: `T`
--> $DIR/typeck_type_placeholder_lifetime_1.rs:4:8
|
LL | struct Foo<'a, T:'a> {
diff --git a/src/test/ui/typeck/typeck_type_placeholder_lifetime_2.rs b/src/test/ui/typeck/typeck_type_placeholder_lifetime_2.rs
index b491a7e1a9caa..178b8b1229a59 100644
--- a/src/test/ui/typeck/typeck_type_placeholder_lifetime_2.rs
+++ b/src/test/ui/typeck/typeck_type_placeholder_lifetime_2.rs
@@ -7,5 +7,5 @@ struct Foo<'a, T:'a> {
pub fn main() {
let c: Foo<_, usize> = Foo { r: &5 };
- //~^ ERROR this struct takes 1 type argument but 2 type arguments were supplied
+ //~^ ERROR this struct takes 1 generic argument but 2 generic arguments were supplied
}
diff --git a/src/test/ui/typeck/typeck_type_placeholder_lifetime_2.stderr b/src/test/ui/typeck/typeck_type_placeholder_lifetime_2.stderr
index 6d03b833c0f15..f30766bdf0121 100644
--- a/src/test/ui/typeck/typeck_type_placeholder_lifetime_2.stderr
+++ b/src/test/ui/typeck/typeck_type_placeholder_lifetime_2.stderr
@@ -1,12 +1,12 @@
-error[E0107]: this struct takes 1 type argument but 2 type arguments were supplied
+error[E0107]: this struct takes 1 generic argument but 2 generic arguments were supplied
--> $DIR/typeck_type_placeholder_lifetime_2.rs:9:12
|
LL | let c: Foo<_, usize> = Foo { r: &5 };
- | ^^^ ------- help: remove this type argument
+ | ^^^ ----- help: remove this generic argument
| |
- | expected 1 type argument
+ | expected 1 generic argument
|
-note: struct defined here, with 1 type parameter: `T`
+note: struct defined here, with 1 generic parameter: `T`
--> $DIR/typeck_type_placeholder_lifetime_2.rs:4:8
|
LL | struct Foo<'a, T:'a> {
diff --git a/src/test/ui/ufcs/ufcs-qpath-missing-params.rs b/src/test/ui/ufcs/ufcs-qpath-missing-params.rs
index 7d2fbdae6a2b2..766351634bb8a 100644
--- a/src/test/ui/ufcs/ufcs-qpath-missing-params.rs
+++ b/src/test/ui/ufcs/ufcs-qpath-missing-params.rs
@@ -12,9 +12,9 @@ impl<'a> IntoCow<'a, str> for String {
fn main() {
<String as IntoCow>::into_cow("foo".to_string());
- //~^ ERROR missing generics for trait `IntoCow`
+ //~^ ERROR missing generics for
<String as IntoCow>::into_cow::<str>("foo".to_string());
- //~^ ERROR missing generics for trait `IntoCow`
- //~| ERROR this associated function takes 0 type arguments but 1 type argument was supplied
+ //~^ ERROR this associated function takes 0 generic arguments but 1
+ //~| ERROR missing generics for
}
diff --git a/src/test/ui/ufcs/ufcs-qpath-missing-params.stderr b/src/test/ui/ufcs/ufcs-qpath-missing-params.stderr
index e3fcef3dc1bb2..37aa4d949daea 100644
--- a/src/test/ui/ufcs/ufcs-qpath-missing-params.stderr
+++ b/src/test/ui/ufcs/ufcs-qpath-missing-params.stderr
@@ -2,43 +2,43 @@ error[E0107]: missing generics for trait `IntoCow`
--> $DIR/ufcs-qpath-missing-params.rs:14:16
|
LL | <String as IntoCow>::into_cow("foo".to_string());
- | ^^^^^^^ expected 1 type argument
+ | ^^^^^^^ expected 1 generic argument
|
-note: trait defined here, with 1 type parameter: `B`
+note: trait defined here, with 1 generic parameter: `B`
--> $DIR/ufcs-qpath-missing-params.rs:3:11
|
LL | pub trait IntoCow<'a, B: ?Sized> where B: ToOwned {
| ^^^^^^^ -
-help: use angle brackets to add missing type argument
+help: add missing generic argument
|
LL | <String as IntoCow<B>>::into_cow("foo".to_string());
- | ^^^
+ | ^^^^^^^^^^
error[E0107]: missing generics for trait `IntoCow`
--> $DIR/ufcs-qpath-missing-params.rs:17:16
|
LL | <String as IntoCow>::into_cow::<str>("foo".to_string());
- | ^^^^^^^ expected 1 type argument
+ | ^^^^^^^ expected 1 generic argument
|
-note: trait defined here, with 1 type parameter: `B`
+note: trait defined here, with 1 generic parameter: `B`
--> $DIR/ufcs-qpath-missing-params.rs:3:11
|
LL | pub trait IntoCow<'a, B: ?Sized> where B: ToOwned {
| ^^^^^^^ -
-help: use angle brackets to add missing type argument
+help: add missing generic argument
|
LL | <String as IntoCow<B>>::into_cow::<str>("foo".to_string());
- | ^^^
+ | ^^^^^^^^^^
-error[E0107]: this associated function takes 0 type arguments but 1 type argument was supplied
+error[E0107]: this associated function takes 0 generic arguments but 1 generic argument was supplied
--> $DIR/ufcs-qpath-missing-params.rs:17:26
|
LL | <String as IntoCow>::into_cow::<str>("foo".to_string());
| ^^^^^^^^------- help: remove these generics
| |
- | expected 0 type arguments
+ | expected 0 generic arguments
|
-note: associated function defined here, with 0 type parameters
+note: associated function defined here, with 0 generic parameters
--> $DIR/ufcs-qpath-missing-params.rs:4:8
|
LL | fn into_cow(self) -> Cow<'a, B>;
diff --git a/src/test/ui/unboxed-closures/unboxed-closure-sugar-used-on-struct-1.stderr b/src/test/ui/unboxed-closures/unboxed-closure-sugar-used-on-struct-1.stderr
index d81975abbe992..d0d27a5b75955 100644
--- a/src/test/ui/unboxed-closures/unboxed-closure-sugar-used-on-struct-1.stderr
+++ b/src/test/ui/unboxed-closures/unboxed-closure-sugar-used-on-struct-1.stderr
@@ -8,17 +8,17 @@ error[E0107]: missing generics for struct `Bar`
--> $DIR/unboxed-closure-sugar-used-on-struct-1.rs:8:16
|
LL | let x: Box<Bar()> = panic!();
- | ^^^ expected 1 type argument
+ | ^^^ expected 1 generic argument
|
-note: struct defined here, with 1 type parameter: `A`
+note: struct defined here, with 1 generic parameter: `A`
--> $DIR/unboxed-closure-sugar-used-on-struct-1.rs:3:8
|
LL | struct Bar<A> {
| ^^^ -
-help: use angle brackets to add missing type argument
+help: add missing generic argument
|
LL | let x: Box<Bar<A>()> = panic!();
- | ^^^
+ | ^^^^^^
error: aborting due to 2 previous errors
diff --git a/src/test/ui/unboxed-closures/unboxed-closure-sugar-used-on-struct.stderr b/src/test/ui/unboxed-closures/unboxed-closure-sugar-used-on-struct.stderr
index 80d7c2402b6cf..0abf46cee9269 100644
--- a/src/test/ui/unboxed-closures/unboxed-closure-sugar-used-on-struct.stderr
+++ b/src/test/ui/unboxed-closures/unboxed-closure-sugar-used-on-struct.stderr
@@ -8,17 +8,17 @@ error[E0107]: missing generics for struct `Bar`
--> $DIR/unboxed-closure-sugar-used-on-struct.rs:7:15
|
LL | fn foo(b: Box<Bar()>) {
- | ^^^ expected 1 type argument
+ | ^^^ expected 1 generic argument
|
-note: struct defined here, with 1 type parameter: `A`
+note: struct defined here, with 1 generic parameter: `A`
--> $DIR/unboxed-closure-sugar-used-on-struct.rs:3:8
|
LL | struct Bar<A> {
| ^^^ -
-help: use angle brackets to add missing type argument
+help: add missing generic argument
|
LL | fn foo(b: Box<Bar<A>()>) {
- | ^^^
+ | ^^^^^^
error: aborting due to 2 previous errors
diff --git a/src/test/ui/unboxed-closures/unboxed-closure-sugar-wrong-number-number-type-parameters-3.rs b/src/test/ui/unboxed-closures/unboxed-closure-sugar-wrong-number-number-type-parameters-3.rs
index a496b7da2f10a..f26ad8e93a153 100644
--- a/src/test/ui/unboxed-closures/unboxed-closure-sugar-wrong-number-number-type-parameters-3.rs
+++ b/src/test/ui/unboxed-closures/unboxed-closure-sugar-wrong-number-number-type-parameters-3.rs
@@ -3,7 +3,7 @@
trait Three<A,B,C> { fn dummy(&self) -> (A,B,C); }
fn foo(_: &dyn Three())
-//~^ ERROR this trait takes 3 type arguments but only 1 type argument was supplied
+//~^ ERROR this trait takes 3 generic arguments but 1 generic argument
//~| ERROR associated type `Output` not found
{}
diff --git a/src/test/ui/unboxed-closures/unboxed-closure-sugar-wrong-number-number-type-parameters-3.stderr b/src/test/ui/unboxed-closures/unboxed-closure-sugar-wrong-number-number-type-parameters-3.stderr
index ef5e7d222b4b7..ebaacf0a6982d 100644
--- a/src/test/ui/unboxed-closures/unboxed-closure-sugar-wrong-number-number-type-parameters-3.stderr
+++ b/src/test/ui/unboxed-closures/unboxed-closure-sugar-wrong-number-number-type-parameters-3.stderr
@@ -1,12 +1,12 @@
-error[E0107]: this trait takes 3 type arguments but only 1 type argument was supplied
+error[E0107]: this trait takes 3 generic arguments but 1 generic argument was supplied
--> $DIR/unboxed-closure-sugar-wrong-number-number-type-parameters-3.rs:5:16
|
LL | fn foo(_: &dyn Three())
- | ^^^^^-- supplied 1 type argument
+ | ^^^^^-- supplied 1 generic argument
| |
- | expected 3 type arguments
+ | expected 3 generic arguments
|
-note: trait defined here, with 3 type parameters: `A`, `B`, `C`
+note: trait defined here, with 3 generic parameters: `A`, `B`, `C`
--> $DIR/unboxed-closure-sugar-wrong-number-number-type-parameters-3.rs:3:7
|
LL | trait Three<A,B,C> { fn dummy(&self) -> (A,B,C); }
diff --git a/src/test/ui/unboxed-closures/unboxed-closure-sugar-wrong-number-number-type-parameters.rs b/src/test/ui/unboxed-closures/unboxed-closure-sugar-wrong-number-number-type-parameters.rs
index d0c85150efe2b..4465b43a75724 100644
--- a/src/test/ui/unboxed-closures/unboxed-closure-sugar-wrong-number-number-type-parameters.rs
+++ b/src/test/ui/unboxed-closures/unboxed-closure-sugar-wrong-number-number-type-parameters.rs
@@ -3,25 +3,25 @@
trait Zero { fn dummy(&self); }
fn foo1(_: dyn Zero()) {
- //~^ ERROR this trait takes 0 type arguments but 1 type argument was supplied
+ //~^ ERROR this trait takes 0 generic arguments but 1 generic argument
//~| ERROR associated type `Output` not found for `Zero`
}
fn foo2(_: dyn Zero<usize>) {
- //~^ ERROR this trait takes 0 type arguments but 1 type argument was supplied
+ //~^ ERROR this trait takes 0 generic arguments but 1 generic argument
}
fn foo3(_: dyn Zero < usize >) {
- //~^ ERROR this trait takes 0 type arguments but 1 type argument was supplied
+ //~^ ERROR this trait takes 0 generic arguments but 1 generic argument
}
fn foo4(_: dyn Zero(usize)) {
- //~^ ERROR this trait takes 0 type arguments but 1 type argument was supplied
+ //~^ ERROR this trait takes 0 generic arguments but 1 generic argument
//~| ERROR associated type `Output` not found for `Zero`
}
fn foo5(_: dyn Zero ( usize )) {
- //~^ ERROR this trait takes 0 type arguments but 1 type argument was supplied
+ //~^ ERROR this trait takes 0 generic arguments but 1 generic argument
//~| ERROR associated type `Output` not found for `Zero`
}
diff --git a/src/test/ui/unboxed-closures/unboxed-closure-sugar-wrong-number-number-type-parameters.stderr b/src/test/ui/unboxed-closures/unboxed-closure-sugar-wrong-number-number-type-parameters.stderr
index 2e620a5563f55..9601e64c1895b 100644
--- a/src/test/ui/unboxed-closures/unboxed-closure-sugar-wrong-number-number-type-parameters.stderr
+++ b/src/test/ui/unboxed-closures/unboxed-closure-sugar-wrong-number-number-type-parameters.stderr
@@ -1,12 +1,12 @@
-error[E0107]: this trait takes 0 type arguments but 1 type argument was supplied
+error[E0107]: this trait takes 0 generic arguments but 1 generic argument was supplied
--> $DIR/unboxed-closure-sugar-wrong-number-number-type-parameters.rs:5:16
|
LL | fn foo1(_: dyn Zero()) {
| ^^^^-- help: remove these parenthetical generics
| |
- | expected 0 type arguments
+ | expected 0 generic arguments
|
-note: trait defined here, with 0 type parameters
+note: trait defined here, with 0 generic parameters
--> $DIR/unboxed-closure-sugar-wrong-number-number-type-parameters.rs:3:7
|
LL | trait Zero { fn dummy(&self); }
@@ -18,43 +18,43 @@ error[E0220]: associated type `Output` not found for `Zero`
LL | fn foo1(_: dyn Zero()) {
| ^^^^^^ associated type `Output` not found
-error[E0107]: this trait takes 0 type arguments but 1 type argument was supplied
+error[E0107]: this trait takes 0 generic arguments but 1 generic argument was supplied
--> $DIR/unboxed-closure-sugar-wrong-number-number-type-parameters.rs:10:16
|
LL | fn foo2(_: dyn Zero<usize>) {
| ^^^^------- help: remove these generics
| |
- | expected 0 type arguments
+ | expected 0 generic arguments
|
-note: trait defined here, with 0 type parameters
+note: trait defined here, with 0 generic parameters
--> $DIR/unboxed-closure-sugar-wrong-number-number-type-parameters.rs:3:7
|
LL | trait Zero { fn dummy(&self); }
| ^^^^
-error[E0107]: this trait takes 0 type arguments but 1 type argument was supplied
+error[E0107]: this trait takes 0 generic arguments but 1 generic argument was supplied
--> $DIR/unboxed-closure-sugar-wrong-number-number-type-parameters.rs:14:16
|
LL | fn foo3(_: dyn Zero < usize >) {
| ^^^^-------------- help: remove these generics
| |
- | expected 0 type arguments
+ | expected 0 generic arguments
|
-note: trait defined here, with 0 type parameters
+note: trait defined here, with 0 generic parameters
--> $DIR/unboxed-closure-sugar-wrong-number-number-type-parameters.rs:3:7
|
LL | trait Zero { fn dummy(&self); }
| ^^^^
-error[E0107]: this trait takes 0 type arguments but 1 type argument was supplied
+error[E0107]: this trait takes 0 generic arguments but 1 generic argument was supplied
--> $DIR/unboxed-closure-sugar-wrong-number-number-type-parameters.rs:18:16
|
LL | fn foo4(_: dyn Zero(usize)) {
| ^^^^------- help: remove these parenthetical generics
| |
- | expected 0 type arguments
+ | expected 0 generic arguments
|
-note: trait defined here, with 0 type parameters
+note: trait defined here, with 0 generic parameters
--> $DIR/unboxed-closure-sugar-wrong-number-number-type-parameters.rs:3:7
|
LL | trait Zero { fn dummy(&self); }
@@ -66,15 +66,15 @@ error[E0220]: associated type `Output` not found for `Zero`
LL | fn foo4(_: dyn Zero(usize)) {
| ^^^^^^^^^^^ associated type `Output` not found
-error[E0107]: this trait takes 0 type arguments but 1 type argument was supplied
+error[E0107]: this trait takes 0 generic arguments but 1 generic argument was supplied
--> $DIR/unboxed-closure-sugar-wrong-number-number-type-parameters.rs:23:16
|
LL | fn foo5(_: dyn Zero ( usize )) {
| ^^^^-------------- help: remove these parenthetical generics
| |
- | expected 0 type arguments
+ | expected 0 generic arguments
|
-note: trait defined here, with 0 type parameters
+note: trait defined here, with 0 generic parameters
--> $DIR/unboxed-closure-sugar-wrong-number-number-type-parameters.rs:3:7
|
LL | trait Zero { fn dummy(&self); }
diff --git a/src/test/ui/unboxed-closures/unboxed-closure-sugar-wrong-trait.rs b/src/test/ui/unboxed-closures/unboxed-closure-sugar-wrong-trait.rs
index 5a47942e5afc6..4bcf90552f906 100644
--- a/src/test/ui/unboxed-closures/unboxed-closure-sugar-wrong-trait.rs
+++ b/src/test/ui/unboxed-closures/unboxed-closure-sugar-wrong-trait.rs
@@ -3,7 +3,7 @@
trait Trait {}
fn f<F:Trait(isize) -> isize>(x: F) {}
-//~^ ERROR this trait takes 0 type arguments but 1 type argument was supplied
+//~^ ERROR this trait takes 0 generic arguments but 1 generic argument
//~| ERROR associated type `Output` not found for `Trait`
fn main() {}
diff --git a/src/test/ui/unboxed-closures/unboxed-closure-sugar-wrong-trait.stderr b/src/test/ui/unboxed-closures/unboxed-closure-sugar-wrong-trait.stderr
index b88a316c0c9dc..3ff05fb2331ef 100644
--- a/src/test/ui/unboxed-closures/unboxed-closure-sugar-wrong-trait.stderr
+++ b/src/test/ui/unboxed-closures/unboxed-closure-sugar-wrong-trait.stderr
@@ -1,12 +1,12 @@
-error[E0107]: this trait takes 0 type arguments but 1 type argument was supplied
+error[E0107]: this trait takes 0 generic arguments but 1 generic argument was supplied
--> $DIR/unboxed-closure-sugar-wrong-trait.rs:5:8
|
LL | fn f<F:Trait(isize) -> isize>(x: F) {}
| ^^^^^------- help: remove these parenthetical generics
| |
- | expected 0 type arguments
+ | expected 0 generic arguments
|
-note: trait defined here, with 0 type parameters
+note: trait defined here, with 0 generic parameters
--> $DIR/unboxed-closure-sugar-wrong-trait.rs:3:7
|
LL | trait Trait {}