From e4d9bc66f65fd3d206587c07e33c4877fda073f9 Mon Sep 17 00:00:00 2001 From: b-naber Date: Thu, 18 Feb 2021 21:01:44 +0100 Subject: [PATCH] improve diagnosts for GATs --- compiler/rustc_ast_lowering/src/path.rs | 5 + .../src/middle/resolve_lifetime.rs | 14 + compiler/rustc_middle/src/query/mod.rs | 4 + compiler/rustc_middle/src/ty/context.rs | 6 +- compiler/rustc_middle/src/ty/query/mod.rs | 4 +- compiler/rustc_resolve/src/late/lifetimes.rs | 132 ++- compiler/rustc_typeck/src/astconv/generics.rs | 134 ++- compiler/rustc_typeck/src/astconv/mod.rs | 11 +- .../wrong_number_of_generic_args.rs | 800 +++++++++++++----- src/test/ui/async-await/issues/issue-65159.rs | 2 +- .../ui/async-await/issues/issue-65159.stderr | 10 +- .../issue-82126-mismatched-subst-and-hir.rs | 2 +- ...ssue-82126-mismatched-subst-and-hir.stderr | 8 +- ...incorrect-number-of-const-args.full.stderr | 18 +- .../incorrect-number-of-const-args.min.stderr | 18 +- .../incorrect-number-of-const-args.rs | 4 +- .../invalid-const-arg-for-type-param.rs | 4 +- .../invalid-const-arg-for-type-param.stderr | 12 +- .../invalid-constant-in-args.stderr | 2 +- .../ui/const-generics/issues/issue-76595.rs | 2 +- .../const-generics/issues/issue-76595.stderr | 2 +- src/test/ui/constructor-lifetime-args.rs | 8 +- src/test/ui/constructor-lifetime-args.stderr | 8 +- src/test/ui/error-codes/E0107.rs | 6 +- src/test/ui/error-codes/E0107.stderr | 6 +- .../gat-trait-path-missing-lifetime.rs | 4 +- .../gat-trait-path-missing-lifetime.stderr | 24 +- .../gat-trait-path-parenthesised-args.rs | 4 +- .../gat-trait-path-parenthesised-args.stderr | 36 +- .../generic-associated-types/issue-71176.rs | 2 +- .../issue-71176.stderr | 12 +- .../generic-associated-types/issue-76535.rs | 6 +- .../issue-76535.stderr | 16 +- .../generic-associated-types/issue-78671.rs | 4 +- .../issue-78671.stderr | 16 +- .../generic-associated-types/issue-79422.rs | 6 +- .../issue-79422.stderr | 16 +- .../generic-associated-types/issue-79636-1.rs | 2 +- .../issue-79636-1.stderr | 14 +- .../generic-associated-types/issue-79636-2.rs | 2 +- .../issue-79636-2.stderr | 14 +- .../generic-associated-types/issue-80433.rs | 2 +- .../issue-80433.stderr | 12 +- .../issue-81712-cyclic-traits.rs | 2 +- .../issue-81712-cyclic-traits.stderr | 14 +- .../generic-associated-types/issue-81862.rs | 13 + .../issue-81862.stderr | 19 + .../missing_lifetime_args.rs | 23 + .../missing_lifetime_args.stderr | 64 ++ .../missing_lifetime_const.rs | 13 + .../missing_lifetime_const.stderr | 28 + .../parameter_number_and_kind.rs | 4 +- .../parameter_number_and_kind.stderr | 18 +- .../trait-path-type-error-once-implemented.rs | 4 +- ...it-path-type-error-once-implemented.stderr | 33 +- .../ui/generics/bad-mid-path-type-params.rs | 6 +- .../generics/bad-mid-path-type-params.stderr | 28 +- .../generics/generic-arg-mismatch-recover.rs | 2 +- .../generic-arg-mismatch-recover.stderr | 12 +- .../generic-impl-less-params-with-defaults.rs | 2 +- ...eric-impl-less-params-with-defaults.stderr | 10 +- .../generic-impl-more-params-with-defaults.rs | 2 +- ...eric-impl-more-params-with-defaults.stderr | 8 +- ...eric-type-less-params-with-defaults.stderr | 8 +- .../generic-type-more-params-with-defaults.rs | 2 +- ...eric-type-more-params-with-defaults.stderr | 8 +- src/test/ui/generics/wrong-number-of-args.rs | 74 +- .../ui/generics/wrong-number-of-args.stderr | 174 ++-- src/test/ui/issues/issue-14092.stderr | 8 +- src/test/ui/issues/issue-18423.stderr | 2 +- src/test/ui/issues/issue-23024.stderr | 8 +- src/test/ui/issues/issue-3214.rs | 2 +- src/test/ui/issues/issue-3214.stderr | 6 +- src/test/ui/issues/issue-53251.rs | 4 +- src/test/ui/issues/issue-53251.stderr | 12 +- src/test/ui/issues/issue-60622.rs | 2 +- src/test/ui/issues/issue-60622.stderr | 8 +- .../methods/method-call-lifetime-args-fail.rs | 4 +- .../method-call-lifetime-args-fail.stderr | 8 +- src/test/ui/seq-args.rs | 4 +- src/test/ui/seq-args.stderr | 12 +- .../structure-constructor-type-mismatch.rs | 4 +- ...structure-constructor-type-mismatch.stderr | 12 +- .../suggestions/missing-lifetime-specifier.rs | 44 +- .../missing-lifetime-specifier.stderr | 24 +- ...use-type-argument-instead-of-assoc-type.rs | 2 +- ...type-argument-instead-of-assoc-type.stderr | 8 +- src/test/ui/tag-type-args.stderr | 8 +- src/test/ui/traits/object/vs-lifetime.rs | 2 +- src/test/ui/traits/object/vs-lifetime.stderr | 10 +- src/test/ui/traits/test-2.rs | 4 +- src/test/ui/traits/test-2.stderr | 14 +- .../enum-variant-generic-args.rs | 12 +- .../enum-variant-generic-args.stderr | 36 +- .../ui/type/ascription/issue-34255-1.stderr | 8 +- src/test/ui/typeck/issue-75883.rs | 4 +- src/test/ui/typeck/issue-75883.stderr | 20 +- .../typeck-builtin-bound-type-parameters.rs | 8 +- ...ypeck-builtin-bound-type-parameters.stderr | 28 +- .../typeck_type_placeholder_lifetime_1.rs | 2 +- .../typeck_type_placeholder_lifetime_1.stderr | 8 +- .../typeck_type_placeholder_lifetime_2.rs | 2 +- .../typeck_type_placeholder_lifetime_2.stderr | 8 +- src/test/ui/ufcs/ufcs-qpath-missing-params.rs | 6 +- .../ui/ufcs/ufcs-qpath-missing-params.stderr | 22 +- ...oxed-closure-sugar-used-on-struct-1.stderr | 8 +- ...nboxed-closure-sugar-used-on-struct.stderr | 8 +- ...r-wrong-number-number-type-parameters-3.rs | 2 +- ...ong-number-number-type-parameters-3.stderr | 8 +- ...gar-wrong-number-number-type-parameters.rs | 10 +- ...wrong-number-number-type-parameters.stderr | 30 +- .../unboxed-closure-sugar-wrong-trait.rs | 2 +- .../unboxed-closure-sugar-wrong-trait.stderr | 6 +- 113 files changed, 1585 insertions(+), 850 deletions(-) create mode 100644 src/test/ui/generic-associated-types/issue-81862.rs create mode 100644 src/test/ui/generic-associated-types/issue-81862.stderr create mode 100644 src/test/ui/generic-associated-types/missing_lifetime_args.rs create mode 100644 src/test/ui/generic-associated-types/missing_lifetime_args.stderr create mode 100644 src/test/ui/generic-associated-types/missing_lifetime_const.rs create mode 100644 src/test/ui/generic-associated-types/missing_lifetime_const.stderr 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, ) -> 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), + + // 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> { + 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 { + 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>, + + // maps `PathSegment` `HirId`s to lifetime scopes. + scope_for_path: Option>>, } 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, + /// We use an IndexMap here because we want these lifetimes in order + /// for diagnostics. + lifetimes: FxIndexMap, /// 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, 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, Vec<_>) = c + let (lifetimes, binders): (FxIndexMap, 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 = generics + let lifetimes: FxIndexMap = 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, Vec<_>) = + let (lifetimes, binders): (FxIndexMap, 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 = FxHashMap::default(); + let mut lifetimes: FxIndexMap = 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 = generics + let lifetimes: FxIndexMap = 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::>() + .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::>() + .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::>() - .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; /// ``` 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::>() + .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::>() - .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" + 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; /// ``` 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; - // ^^^^^^^^^^^^^^^^ - // | span must start with the argument - // ``` - // - // When the last redundant argument is at the ending of the generics, like so: - // - // ``` - // type Map = HashMap; - // ^^^^^^^^^^^^^^^^ - // | 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 { | ^^^^^^ - - -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) -> 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); | ^^^^^^^^^^^^ -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) -> 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); | ^^^^^^^^^^^^ - -help: add missing type argument +help: add missing generic argument | LL | async fn buy_lock(generator: &Mutex) -> 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() -> 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() -> 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() -> 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() -> 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() -> 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; @@ -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() where Bool<{core::mem::size_of::() > 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 X for T { fn foo<'a, T1: X>(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 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>(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 = 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>(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 = 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>) {} //~^ 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>) {} | ^^ 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>) {} | ^^^^^ @@ -20,7 +20,7 @@ LL | #![feature(generic_associated_types)] = note: see issue #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>) {} | ^^ help: use `dyn`: `dyn 'a` @@ -30,10 +30,10 @@ LL | fn foo<'a>(arg: Box>) {} = note: for more information, see issue #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>) {} + | ^ 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>) {} - | ^^ +LL | fn foo<'a>(arg: Box>) {} + | ^^^ -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>) {} - | |_________________________________________- help: remove these generics +LL | fn foo<'a>(arg: Box>) {} + | ^-------------- 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 { inner: Box>, + //~^ 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>, + | ^ 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 = 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> = 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 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> = 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 = 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> = 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> = 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; - //~^ ERROR: missing generics for associated type } fn floatify() { Box::new(Family) as &dyn CollectionFamily - //~^ 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; - | ^^^^^^ expected 1 type argument +LL | Box::new(Family) as &dyn CollectionFamily + | ^^^^^^ 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; | ^^^^^^ - -help: use angle brackets to add missing type argument +help: add missing generic argument | -LL | type Member; - | ^^^ +LL | Box::new(Family) as &dyn CollectionFamily=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 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `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 { trait MapLike { type VRefCont<'a>: RefCont<'a, V>; - //~^ ERROR missing generics fn get<'a>(&'a self, key: &K) -> Option>; } @@ -42,6 +41,7 @@ impl MapLike for Source { fn main() { let m = Box::new(std::collections::BTreeMap::::new()) as Box>>; - //~^^ 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>>; + | ^^^^^^^^ 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 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>>; | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `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::::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; - //~^ ERROR: missing generics for associated type `Monad::Wrapped` fn bind(self, f: F) -> Self::Wrapped { todo!() @@ -15,6 +14,7 @@ fn join(outer: MOuter) -> MOuter::Wrapped where MOuter: Monad, MInner: Monad>, + //~^ 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; - | ^^^^^^^ expected 1 type argument +LL | MInner: Monad>, + | ^^^^^^^ 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; | ^^^^^^^ - -help: use angle brackets to add missing type argument +help: add missing generic argument | -LL | type Wrapped; - | ^^^ +LL | MInner: Monad = MOuter::Wrapped>, + | ^^^^^^^^^^ 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: SomeTrait; - //~^ ERROR: missing generics for associated type `SomeTrait::Wrapped` fn f() -> (); } @@ -11,6 +10,7 @@ trait SomeTrait { fn program() -> () where W: SomeTrait, + //~^ 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: SomeTrait; - | ^^^^^^^ expected 1 type argument +LL | W: SomeTrait, + | ^^^^^^^ 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: SomeTrait; | ^^^^^^^ - -help: use angle brackets to add missing type argument +help: add missing generic argument | -LL | type Wrapped: SomeTrait; - | ^^^ +LL | W: SomeTrait = 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 { 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) + //~^ 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) + | ^^^^^^ 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 = &'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: D; - //~^ ERROR: missing generics for associated type `C::DType` [E0107] } trait D { type CType: C; + //~^ 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: D; - | ^^^^^ expected 1 type argument +LL | type CType: C; + | ^^^^^ 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: D; | ^^^^^ - -help: use angle brackets to add missing type argument +help: add missing generic argument | -LL | type DType: D; - | ^^^ +LL | type CType: C = 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; + //~^ 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; + | ^^^^ 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>; + | ^^^^^^^^ + +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>) {} +//~^ 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 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>) {} + | ^ 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 = (&'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() { + let _: ::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 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 _: ::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 _: ::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 = 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 = 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 = 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 = &'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 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 = &'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 = &'a ()>>) {} - | ^^ +LL | fn f2<'a>(arg : Box = &'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 = &'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 = &'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 for S2 { fn foo<'a>() { let _ = S::new::(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::(1, 1.0); //~^ ERROR this struct takes 0 lifetime arguments but 1 lifetime argument was supplied let _: S2 = Trait::new::(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::(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::(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(x: T, _: U) -> S { @@ -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::(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 { | ^ -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::(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(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::(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 { | ^^^^^ -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::(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(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 Foo { fn main() { Foo::::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::::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( | ^^^ - - -help: add missing type argument +help: add missing generic argument | LL | Foo::::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 Vec { fn main() { Vec::::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::::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( 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( | ^^^ - -help: use angle brackets to add missing type argument +help: add missing generic argument | LL | let _: Vec; - | ^^^ + | ^^^^^^ 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( fn main() { let _: Vec; - //~^ 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; - | ^^^ ------ 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( 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; - //~^ 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; type D = Ty; - //~^ 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; //~^ 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; - //~^ 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; type D = Ty; type E = Ty; - //~^ 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>; - //~^ 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; @@ -107,10 +107,10 @@ mod r#trait { type D = Box; //~^ ERROR missing generics for trait `GenericType` - //~| HELP use angle brackets + //~| HELP add missing type E = Box>; - //~^ 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; - //~^ 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; - //~^ 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; - //~^ 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; - //~^ 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; | ^^ - - -help: use angle brackets to add missing type arguments +help: add missing generic arguments | LL | type A = Ty; - | ^^^^^^ + | ^^^^^^^^ -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; - | ^^ ----- 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; | ^^ - - -help: add missing type argument +help: add missing generic argument | LL | type B = Ty; | ^^^ -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; - | ^^ ------ 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; @@ -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; - | ^^^ + | ^^^^^ 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; | ^^ - - -help: use angle brackets to add missing type arguments +help: add missing generic arguments | LL | type A = Ty; - | ^^^^^^ + | ^^^^^^^^ -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; - | ^^ ----- 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; | ^^ - - -help: add missing type argument +help: add missing generic argument | LL | type B = Ty; | ^^^ -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; - | ^^ ----- 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; | ^^ - - - -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>; | ^^^^^^^^^^------- 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>; - | ^^^^^^^^^^^^^^^ --------- 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; - | ^^^^^^^^^^^ 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 { | ^^^^^^^^^^^ - -help: use angle brackets to add missing type argument +help: add missing generic argument | LL | type D = Box>; - | ^^^ + | ^^^^^^^^^^^^^^ -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>; - | ^^^^^^^^^^^ ------- 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 { @@ -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 { | ^^^^^^^ - - -help: use angle brackets to add missing type arguments +help: add missing generic arguments | LL | type A = HashMap; - | ^^^^^^ + | ^^^^^^^^^^^^^ -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; - | ^^^^^^^ ------ 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 { | ^^^^^^^ - - -help: add missing type argument +help: add missing generic argument | LL | type B = HashMap; | ^^^ @@ -335,31 +335,31 @@ note: struct defined here, with 0 lifetime parameters LL | pub struct HashMap { | ^^^^^^^ -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 { | ^^^^^^^ - - -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; - | ^^^^^^^ ----- 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 { @@ -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 { | ^^^^^^ - - -help: use angle brackets to add missing type arguments +help: add missing generic arguments | LL | type A = Result; - | ^^^^^^ + | ^^^^^^^^^^^^ -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; - | ^^^^^^ ------ 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 { | ^^^^^^ - - -help: add missing type argument +help: add missing generic argument | LL | type B = Result; | ^^^ @@ -413,31 +413,31 @@ note: enum defined here, with 0 lifetime parameters LL | pub enum Result { | ^^^^^^ -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 { | ^^^^^^ - - -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; - | ^^^^^^ ------ 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 { 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) {} - | ^^^ + | ^^^^^^ 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: FnMut { | ^^ ---- -help: use angle brackets to add missing type argument +help: add missing generic argument | LL | println!("{:?}",(vfnfer[0] as dyn Fn)(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() { } impl Drop for Foo { - //~^ 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 Drop for Foo { | ^^^--- 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::(); - //~^ 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::(); | ^------- 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::(); | ^------- 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(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 -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 Seq for Vec { - //~^ 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 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 Seq for Vec { | ^^^--- 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 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:: { //~ ERROR this type alias takes 0 type arguments but 1 type argument was supplied + let pt3 = PointF:: { //~ 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:: { .. } => {} //~ ERROR this type alias takes 0 type arguments but 1 type argument was supplied + PointF:: { .. } => {} //~ 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:: { | ^^^^^^------- 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; @@ -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:: { .. } => {} | ^^^^^^------- 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; 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>>> = 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>>> = 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>>>> = RefCell::new(HashMap::new()); - //~^ ERROR missing lifetime specifier - //~| ERROR missing lifetime specifier + //~^ ERROR missing lifetime + //~| ERROR missing lifetime } thread_local! { static d: RefCell>>>> = 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>>>> = 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>>>> = 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>>>> = 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>>>> = RefCell::new(HashMap::new()); @@ -157,10 +157,10 @@ LL | pub union Qux<'t, 'k, I> { | ^^^ -- -- help: add missing lifetime argument | -LL | static e: RefCell>>>> = RefCell::new(HashMap::new()); +LL | static e: RefCell>>>> = 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>>>> = RefCell::new(HashMap::new()); @@ -178,7 +178,7 @@ help: add missing lifetime argument LL | static e: RefCell>>>> = 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>>>> = RefCell::new(HashMap::new()); @@ -196,7 +196,7 @@ help: add missing lifetime argument LL | static e: RefCell>>>> = 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>>>> = RefCell::new(HashMap::new()); @@ -211,10 +211,10 @@ LL | pub union Qux<'t, 'k, I> { | ^^^ -- -- help: add missing lifetime argument | -LL | static e: RefCell>>>> = RefCell::new(HashMap::new()); +LL | static e: RefCell>>>> = 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>>>> = RefCell::new(HashMap::new()); @@ -229,7 +229,7 @@ LL | trait Tar<'t, 'k, I> {} | ^^^ -- -- help: add missing lifetime argument | -LL | static f: RefCell>>>> = RefCell::new(HashMap::new()); +LL | static f: RefCell>>>> = RefCell::new(HashMap::new()); | ^^^^ error[E0106]: missing lifetime specifier @@ -244,7 +244,7 @@ help: consider using the `'static` lifetime LL | static f: RefCell>>>> = 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>>>> = RefCell::new(HashMap::new()); @@ -274,7 +274,7 @@ help: consider using the `'static` lifetime LL | static f: RefCell>>>> = 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>>>> = RefCell::new(HashMap::new()); @@ -292,7 +292,7 @@ help: add missing lifetime argument LL | static f: RefCell>>>> = 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>>>> = RefCell::new(HashMap::new()); @@ -307,7 +307,7 @@ LL | trait Tar<'t, 'k, I> {} | ^^^ -- -- help: add missing lifetime argument | -LL | static f: RefCell>>>> = RefCell::new(HashMap::new()); +LL | static f: RefCell>>>> = 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 { pub struct Foo { i: Box>, //~^ 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>, - | ^ -------------- 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 { 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 { Bar } | ^^^^ - -help: use angle brackets to add missing type argument +help: add missing generic argument | LL | fn foo(c: Quux) { 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; //~^ 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(&self) {} } fn main() { 10.dup::(); - //~^ 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::(); - //~^ 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).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::(); | ^^^------- 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(&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::(); - | ^^^^ ----- 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(&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 { | ^^^ - -help: use angle brackets to add missing type argument +help: add missing generic argument | LL | input_cells: Vec::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 { | ^^^^^^ - - -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 { | ^^^^^^ - - -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, 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 {} -//~^ 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>; -//~^ 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, 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 {} | ^^^^---------- 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>; | ^^^^--- 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() { ::into_cow("foo".to_string()); - //~^ ERROR missing generics for trait `IntoCow` + //~^ ERROR missing generics for ::into_cow::("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 | ::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 | >::into_cow("foo".to_string()); - | ^^^ + | ^^^^^^^^^^ error[E0107]: missing generics for trait `IntoCow` --> $DIR/ufcs-qpath-missing-params.rs:17:16 | LL | ::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 | >::into_cow::("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 | ::into_cow::("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 = 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 { | ^^^ - -help: use angle brackets to add missing type argument +help: add missing generic argument | LL | let x: Box()> = 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) { - | ^^^ 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 { | ^^^ - -help: use angle brackets to add missing type argument +help: add missing generic argument | LL | fn foo(b: Box()>) { - | ^^^ + | ^^^^^^ 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 { 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 { 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) { - //~^ 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) { | ^^^^------- 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 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 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 {}