mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Auto merge of #68434 - varkor:astconv-mismatch-error, r=nikomatsakis

Browse Source 
Move generic arg/param validation to `create_substs_for_generic_args` to resolve various const generics issues

This changes some diagnostics, but I think they're around as helpful as the previous ones, and occur infrequently regardless.

Fixes https://github.com/rust-lang/rust/issues/68257.
Fixes https://github.com/rust-lang/rust/issues/68398.

r? @eddyb
This commit is contained in:
bors 2020-02-27 18:38:19 +00:00
commit 6d69caba11
25 changed files with 349 additions and 233 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
src/librustc/ty/mod.rs
View File

@ -931,7 +931,17 @@ pub enum GenericParamDefKind {
Const,
}
#[derive(Clone, RustcEncodable, RustcDecodable, HashStable)]
impl GenericParamDefKind {
pub fn descr(&self) -> &'static str {
match self {
GenericParamDefKind::Lifetime => "lifetime",
GenericParamDefKind::Type { .. } => "type",
GenericParamDefKind::Const => "constant",
}
}
}
#[derive(Clone, Debug, RustcEncodable, RustcDecodable, HashStable)]
pub struct GenericParamDef {
pub name: Symbol,
pub def_id: DefId,

11
src/librustc/ty/structural_impls.rs
View File

@ -17,17 +17,6 @@
use std::rc::Rc;
use std::sync::Arc;
impl fmt::Debug for ty::GenericParamDef {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let type_name = match self.kind {
ty::GenericParamDefKind::Lifetime => "Lifetime",
ty::GenericParamDefKind::Type { .. } => "Type",
ty::GenericParamDefKind::Const => "Const",
};
write!(f, "{}({}, {:?}, {})", type_name, self.name, self.def_id, self.index)
}
}
impl fmt::Debug for ty::TraitDef {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
ty::tls::with(|tcx| {

82
src/librustc_ast_passes/ast_validation.rs
View File

@ -8,7 +8,7 @@
use rustc_ast_pretty::pprust;
use rustc_data_structures::fx::FxHashMap;
use rustc_errors::{error_code, struct_span_err, Applicability, FatalError};
use rustc_errors::{error_code, struct_span_err, Applicability};
use rustc_parse::validate_attr;
use rustc_session::lint::builtin::PATTERNS_IN_FNS_WITHOUT_BODY;
use rustc_session::lint::LintBuffer;
@ -596,23 +596,15 @@ fn check_item_named(&self, ident: Ident, kind: &str) {
}
}
enum GenericPosition {
Param,
Arg,
}
fn validate_generics_order<'a>(
fn validate_generic_param_order<'a>(
sess: &Session,
handler: &rustc_errors::Handler,
generics: impl Iterator<Item = (ParamKindOrd, Option<&'a [GenericBound]>, Span, Option<String>)>,
pos: GenericPosition,
span: Span,
) {
let mut max_param: Option<ParamKindOrd> = None;
let mut out_of_order = FxHashMap::default();
let mut param_idents = vec![];
let mut found_type = false;
let mut found_const = false;
for (kind, bounds, span, ident) in generics {
if let Some(ident) = ident {
@ -626,11 +618,6 @@ fn validate_generics_order<'a>(
}
Some(_) | None => *max_param = Some(kind),
};
match kind {
ParamKindOrd::Type => found_type = true,
ParamKindOrd::Const => found_const = true,
_ => {}
}
}
let mut ordered_params = "<".to_string();
@ -653,42 +640,26 @@ fn validate_generics_order<'a>(
}
ordered_params += ">";
let pos_str = match pos {
GenericPosition::Param => "parameter",
GenericPosition::Arg => "argument",
};
for (param_ord, (max_param, spans)) in &out_of_order {
let mut err = handler.struct_span_err(
spans.clone(),
&format!(
"{} {pos}s must be declared prior to {} {pos}s",
param_ord,
max_param,
pos = pos_str,
),
);
if let GenericPosition::Param = pos {
err.span_suggestion(
span,
let mut err =
handler.struct_span_err(
spans.clone(),
&format!(
"reorder the {}s: lifetimes, then types{}",
pos_str,
if sess.features_untracked().const_generics { ", then consts" } else { "" },
"{} parameters must be declared prior to {} parameters",
param_ord, max_param,
),
ordered_params.clone(),
Applicability::MachineApplicable,
);
}
err.span_suggestion(
span,
&format!(
"reorder the parameters: lifetimes, then types{}",
if sess.features_untracked().const_generics { ", then consts" } else { "" },
),
ordered_params.clone(),
Applicability::MachineApplicable,
);
err.emit();
}
// FIXME(const_generics): we shouldn't have to abort here at all, but we currently get ICEs
// if we don't. Const parameters and type parameters can currently conflict if they
// are out-of-order.
if !out_of_order.is_empty() && found_type && found_const {
FatalError.raise();
}
}
impl<'a> Visitor<'a> for AstValidator<'a> {
@ -1016,24 +987,6 @@ fn visit_generic_args(&mut self, _: Span, generic_args: &'a GenericArgs) {
match *generic_args {
GenericArgs::AngleBracketed(ref data) => {
walk_list!(self, visit_generic_arg, &data.args);
validate_generics_order(
self.session,
self.err_handler(),
data.args.iter().map(|arg| {
(
match arg {
GenericArg::Lifetime(..) => ParamKindOrd::Lifetime,
GenericArg::Type(..) => ParamKindOrd::Type,
GenericArg::Const(..) => ParamKindOrd::Const,
},
None,
arg.span(),
None,
)
}),
GenericPosition::Arg,
generic_args.span(),
);
// Type bindings such as `Item = impl Debug` in `Iterator<Item = Debug>`
// are allowed to contain nested `impl Trait`.
@ -1070,7 +1023,7 @@ fn visit_generics(&mut self, generics: &'a Generics) {
}
}
validate_generics_order(
validate_generic_param_order(
self.session,
self.err_handler(),
generics.params.iter().map(|param| {
@ -1085,7 +1038,6 @@ fn visit_generics(&mut self, generics: &'a Generics) {
};
(kind, Some(&*param.bounds), param.ident.span, ident)
}),
GenericPosition::Param,
generics.span,
);

1
src/librustc_error_codes/error_codes.rs
View File

@ -417,6 +417,7 @@
E0744: include_str!("./error_codes/E0744.md"),
E0745: include_str!("./error_codes/E0745.md"),
E0746: include_str!("./error_codes/E0746.md"),
E0747: include_str!("./error_codes/E0747.md"),
;
// E0006, // merged with E0005
// E0008, // cannot bind by-move into a pattern guard

20
src/librustc_error_codes/error_codes/E0747.md Normal file
View File

@ -0,0 +1,20 @@
Generic arguments must be provided in the same order as the corresponding
generic parameters are declared.
Erroneous code example:
```compile_fail,E0747
struct S<'a, T>(&'a T);
type X = S<(), 'static>; // error: the type argument is provided before the
// lifetime argument
```
The argument order should be changed to match the parameter declaration
order, as in the following.
```
struct S<'a, T>(&'a T);
type X = S<'static, ()>; // ok
```

8
src/librustc_hir/hir.rs
View File

@ -298,6 +298,14 @@ pub fn is_const(&self) -> bool {
_ => false,
}
}
pub fn descr(&self) -> &'static str {
match self {
GenericArg::Lifetime(_) => "lifetime",
GenericArg::Type(_) => "type",
GenericArg::Const(_) => "constant",
}
}
}
#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)]

279
src/librustc_typeck/astconv.rs
View File

@ -12,7 +12,7 @@
use crate::require_c_abi_if_c_variadic;
use crate::util::common::ErrorReported;
use rustc::lint::builtin::AMBIGUOUS_ASSOCIATED_ITEMS;
use rustc::session::parse::feature_err;
use rustc::session::{parse::feature_err, Session};
use rustc::ty::subst::{self, InternalSubsts, Subst, SubstsRef};
use rustc::ty::{self, Const, DefIdTree, ToPredicate, Ty, TyCtxt, TypeFoldable, WithConstness};
use rustc::ty::{GenericParamDef, GenericParamDefKind};
@ -132,6 +132,15 @@ enum GenericArgPosition {
MethodCall,
}
/// A marker denoting that the generic arguments that were
/// provided did not match the respective generic parameters.
pub struct GenericArgCountMismatch {
/// Indicates whether a fatal error was reported (`Some`), or just a lint (`None`).
pub reported: Option<ErrorReported>,
/// A list of spans of arguments provided that were not valid.
pub invalid_args: Vec<Span>,
}
impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
pub fn ast_region_to_region(
&self,
@ -262,7 +271,7 @@ pub fn check_generic_arg_count_for_call(
def: &ty::Generics,
seg: &hir::PathSegment<'_>,
is_method_call: bool,
) -> bool {
) -> Result<(), GenericArgCountMismatch> {
let empty_args = hir::GenericArgs::none();
let suppress_mismatch = Self::check_impl_trait(tcx, seg, &def);
Self::check_generic_arg_count(
@ -274,7 +283,6 @@ pub fn check_generic_arg_count_for_call(
def.parent.is_none() && def.has_self, // `has_self`
seg.infer_args || suppress_mismatch, // `infer_args`
)
.0
}
/// Checks that the correct number of generic arguments have been provided.
@ -287,7 +295,7 @@ fn check_generic_arg_count(
position: GenericArgPosition,
has_self: bool,
infer_args: bool,
) -> (bool, Option<Vec<Span>>) {
) -> Result<(), GenericArgCountMismatch> {
// At this stage we are guaranteed that the generic arguments are in the correct order, e.g.
// that lifetimes will proceed types. So it suffices to check the number of each generic
// arguments in order to validate them with respect to the generic parameters.
@ -313,7 +321,7 @@ fn check_generic_arg_count(
}
// Prohibit explicit lifetime arguments if late-bound lifetime parameters are present.
let mut reported_late_bound_region_err = None;
let mut explicit_lifetimes = Ok(());
if !infer_lifetimes {
if let Some(span_late) = def.has_late_bound_regions {
let msg = "cannot specify lifetime arguments explicitly \
@ -323,11 +331,12 @@ fn check_generic_arg_count(
if position == GenericArgPosition::Value
&& arg_counts.lifetimes != param_counts.lifetimes
{
explicit_lifetimes = Err(true);
let mut err = tcx.sess.struct_span_err(span, msg);
err.span_note(span_late, note);
err.emit();
reported_late_bound_region_err = Some(true);
} else {
explicit_lifetimes = Err(false);
let mut multispan = MultiSpan::from_span(span);
multispan.push_span_label(span_late, note.to_string());
tcx.struct_span_lint_hir(
@ -336,112 +345,136 @@ fn check_generic_arg_count(
multispan,
|lint| lint.build(msg).emit(),
);
reported_late_bound_region_err = Some(false);
}
}
}
let check_kind_count = |kind, required, permitted, provided, offset| {
debug!(
"check_kind_count: kind: {} required: {} permitted: {} provided: {} offset: {}",
kind, required, permitted, provided, offset
);
// We enforce the following: `required` <= `provided` <= `permitted`.
// For kinds without defaults (e.g.., lifetimes), `required == permitted`.
// For other kinds (i.e., types), `permitted` may be greater than `required`.
if required <= provided && provided <= permitted {
return (reported_late_bound_region_err.unwrap_or(false), None);
}
// Unfortunately lifetime and type parameter mismatches are typically styled
// differently in diagnostics, which means we have a few cases to consider here.
let (bound, quantifier) = if required != permitted {
if provided < required {
(required, "at least ")
} else {
// provided > permitted
(permitted, "at most ")
let check_kind_count =
|kind, required, permitted, provided, offset, unexpected_spans: &mut Vec<Span>| {
debug!(
"check_kind_count: kind: {} required: {} permitted: {} provided: {} offset: {}",
kind, required, permitted, provided, offset
);
// We enforce the following: `required` <= `provided` <= `permitted`.
// For kinds without defaults (e.g.., lifetimes), `required == permitted`.
// For other kinds (i.e., types), `permitted` may be greater than `required`.
if required <= provided && provided <= permitted {
return Ok(());
}
} else {
(required, "")
};
let mut potential_assoc_types: Option<Vec<Span>> = None;
let (spans, label) = if required == permitted && provided > permitted {
// In the case when the user has provided too many arguments,
// we want to point to the unexpected arguments.
let spans: Vec<Span> = args.args[offset + permitted..offset + provided]
.iter()
.map(|arg| arg.span())
.collect();
potential_assoc_types = Some(spans.clone());
(spans, format!("unexpected {} argument", kind))
} else {
(
vec![span],
format!(
"expected {}{} {} argument{}",
quantifier,
bound,
kind,
pluralize!(bound),
// Unfortunately lifetime and type parameter mismatches are typically styled
// differently in diagnostics, which means we have a few cases to consider here.
let (bound, quantifier) = if required != permitted {
if provided < required {
(required, "at least ")
} else {
// provided > permitted
(permitted, "at most ")
}
} else {
(required, "")
};
let (spans, label) = if required == permitted && provided > permitted {
// In the case when the user has provided too many arguments,
// we want to point to the unexpected arguments.
let spans: Vec<Span> = args.args[offset + permitted..offset + provided]
.iter()
.map(|arg| arg.span())
.collect();
unexpected_spans.extend(spans.clone());
(spans, format!("unexpected {} argument", kind))
} else {
(
vec![span],
format!(
"expected {}{} {} argument{}",
quantifier,
bound,
kind,
pluralize!(bound),
),
)
};
let mut err = tcx.sess.struct_span_err_with_code(
spans.clone(),
&format!(
"wrong number of {} arguments: expected {}{}, found {}",
kind, quantifier, bound, provided,
),
)
DiagnosticId::Error("E0107".into()),
);
for span in spans {
err.span_label(span, label.as_str());
}
err.emit();
Err(true)
};
let mut err = tcx.sess.struct_span_err_with_code(
spans.clone(),
&format!(
"wrong number of {} arguments: expected {}{}, found {}",
kind, quantifier, bound, provided,
),
DiagnosticId::Error("E0107".into()),
);
for span in spans {
err.span_label(span, label.as_str());
}
err.emit();
let mut arg_count_correct = explicit_lifetimes;
let mut unexpected_spans = vec![];
(
provided > required, // `suppress_error`
potential_assoc_types,
)
};
if reported_late_bound_region_err.is_none()
if arg_count_correct.is_ok()
&& (!infer_lifetimes || arg_counts.lifetimes > param_counts.lifetimes)
{
check_kind_count(
arg_count_correct = check_kind_count(
"lifetime",
param_counts.lifetimes,
param_counts.lifetimes,
arg_counts.lifetimes,
0,
);
&mut unexpected_spans,
)
.and(arg_count_correct);
}
// FIXME(const_generics:defaults)
if !infer_args || arg_counts.consts > param_counts.consts {
check_kind_count(
arg_count_correct = check_kind_count(
"const",
param_counts.consts,
param_counts.consts,
arg_counts.consts,
arg_counts.lifetimes + arg_counts.types,
);
&mut unexpected_spans,
)
.and(arg_count_correct);
}
// Note that type errors are currently be emitted *after* const errors.
if !infer_args || arg_counts.types > param_counts.types - defaults.types - has_self as usize
{
check_kind_count(
arg_count_correct = check_kind_count(
"type",
param_counts.types - defaults.types - has_self as usize,
param_counts.types - has_self as usize,
arg_counts.types,
arg_counts.lifetimes,
&mut unexpected_spans,
)
} else {
(reported_late_bound_region_err.unwrap_or(false), None)
.and(arg_count_correct);
}
arg_count_correct.map_err(|reported_err| GenericArgCountMismatch {
reported: if reported_err { Some(ErrorReported) } else { None },
invalid_args: unexpected_spans,
})
}
/// Report an error that a generic argument did not match the generic parameter that was
/// expected.
fn generic_arg_mismatch_err(sess: &Session, arg: &GenericArg<'_>, kind: &'static str) {
let mut err = struct_span_err!(
sess,
arg.span(),
E0747,
"{} provided when a {} was expected",
arg.descr(),
kind,
);
// This note will be true as long as generic parameters are strictly ordered by their kind.
err.note(&format!("{} arguments must be provided before {} arguments", kind, arg.descr()));
err.emit();
}
/// Creates the relevant generic argument substitutions
@ -479,6 +512,7 @@ pub fn create_substs_for_generic_args<'b>(
parent_substs: &[subst::GenericArg<'tcx>],
has_self: bool,
self_ty: Option<Ty<'tcx>>,
arg_count_correct: bool,
args_for_def_id: impl Fn(DefId) -> (Option<&'b GenericArgs<'b>>, bool),
provided_kind: impl Fn(&GenericParamDef, &GenericArg<'_>) -> subst::GenericArg<'tcx>,
mut inferred_kind: impl FnMut(
@ -502,7 +536,6 @@ pub fn create_substs_for_generic_args<'b>(
// methods in `subst.rs`, so that we can iterate over the arguments and
// parameters in lock-step linearly, instead of trying to match each pair.
let mut substs: SmallVec<[subst::GenericArg<'tcx>; 8]> = SmallVec::with_capacity(count);
// Iterate over each segment of the path.
while let Some((def_id, defs)) = stack.pop() {
let mut params = defs.params.iter().peekable();
@ -539,6 +572,12 @@ pub fn create_substs_for_generic_args<'b>(
let mut args =
generic_args.iter().flat_map(|generic_args| generic_args.args.iter()).peekable();
// If we encounter a type or const when we expect a lifetime, we infer the lifetimes.
// If we later encounter a lifetime, we know that the arguments were provided in the
// wrong order. `force_infer_lt` records the type or const that forced lifetimes to be
// inferred, so we can use it for diagnostics later.
let mut force_infer_lt = None;
loop {
// We're going to iterate through the generic arguments that the user
// provided, matching them with the generic parameters we expect.
@ -559,30 +598,58 @@ pub fn create_substs_for_generic_args<'b>(
// We expected a lifetime argument, but got a type or const
// argument. That means we're inferring the lifetimes.
substs.push(inferred_kind(None, param, infer_args));
force_infer_lt = Some(arg);
params.next();
}
(_, _) => {
(_, kind) => {
// We expected one kind of parameter, but the user provided
// another. This is an error, but we need to handle it
// gracefully so we can report sensible errors.
// In this case, we're simply going to infer this argument.
args.next();
// another. This is an error. However, if we already know that
// the arguments don't match up with the parameters, we won't issue
// an additional error, as the user already knows what's wrong.
if arg_count_correct {
Self::generic_arg_mismatch_err(tcx.sess, arg, kind.descr());
}
// We've reported the error, but we want to make sure that this
// problem doesn't bubble down and create additional, irrelevant
// errors. In this case, we're simply going to ignore the argument
// and any following arguments. The rest of the parameters will be
// inferred.
while args.next().is_some() {}
}
}
}
(Some(_), None) => {
(Some(&arg), None) => {
// We should never be able to reach this point with well-formed input.
// Getting to this point means the user supplied more arguments than
// there are parameters.
args.next();
// There are two situations in which we can encounter this issue.
//
// 1. The number of arguments is incorrect. In this case, an error
// will already have been emitted, and we can ignore it. This case
// also occurs when late-bound lifetime parameters are present, yet
// the lifetime arguments have also been explicitly specified by the
// user.
// 2. We've inferred some lifetimes, which have been provided later (i.e.
// after a type or const). We want to throw an error in this case.
if arg_count_correct {
let kind = arg.descr();
assert_eq!(kind, "lifetime");
let provided =
force_infer_lt.expect("lifetimes ought to have been inferred");
Self::generic_arg_mismatch_err(tcx.sess, provided, kind);
}
break;
}
(None, Some(&param)) => {
// If there are fewer arguments than parameters, it means
// we're inferring the remaining arguments.
substs.push(inferred_kind(Some(&substs), param, infer_args));
args.next();
params.next();
}
(None, None) => break,
}
}
@ -630,7 +697,8 @@ fn create_substs_for_ast_path<'a>(
generic_args: &'a hir::GenericArgs<'_>,
infer_args: bool,
self_ty: Option<Ty<'tcx>>,
) -> (SubstsRef<'tcx>, Vec<ConvertedBinding<'a, 'tcx>>, Option<Vec<Span>>) {
) -> (SubstsRef<'tcx>, Vec<ConvertedBinding<'a, 'tcx>>, Result<(), GenericArgCountMismatch>)
{
// If the type is parameterized by this region, then replace this
// region with the current anon region binding (in other words,
// whatever & would get replaced with).
@ -656,7 +724,7 @@ fn create_substs_for_ast_path<'a>(
assert!(self_ty.is_none() && parent_substs.is_empty());
}
let (_, potential_assoc_types) = Self::check_generic_arg_count(
let arg_count_correct = Self::check_generic_arg_count(
tcx,
span,
&generic_params,
@ -689,8 +757,16 @@ fn create_substs_for_ast_path<'a>(
parent_substs,
self_ty.is_some(),
self_ty,
arg_count_correct.is_ok(),
// Provide the generic args, and whether types should be inferred.
|_| (Some(generic_args), infer_args),
|did| {
if did == def_id {
(Some(generic_args), infer_args)
} else {
// The last component of this tuple is unimportant.
(None, false)
}
},
// Provide substitutions for parameters for which (valid) arguments have been provided.
|param, arg| match (&param.kind, arg) {
(GenericParamDefKind::Lifetime, GenericArg::Lifetime(lt)) => {
@ -794,7 +870,7 @@ fn create_substs_for_ast_path<'a>(
generic_params, self_ty, substs
);
(substs, assoc_bindings, potential_assoc_types)
(substs, assoc_bindings, arg_count_correct)
}
crate fn create_substs_for_associated_item(
@ -925,7 +1001,7 @@ pub(super) fn instantiate_poly_trait_ref_inner(
self_ty: Ty<'tcx>,
bounds: &mut Bounds<'tcx>,
speculative: bool,
) -> Option<Vec<Span>> {
) -> Result<(), GenericArgCountMismatch> {
let trait_def_id = trait_ref.trait_def_id();
debug!("instantiate_poly_trait_ref({:?}, def_id={:?})", trait_ref, trait_def_id);
@ -942,7 +1018,7 @@ pub(super) fn instantiate_poly_trait_ref_inner(
} else {
trait_ref.path.span
};
let (substs, assoc_bindings, potential_assoc_types) = self.create_substs_for_ast_trait_ref(
let (substs, assoc_bindings, arg_count_correct) = self.create_substs_for_ast_trait_ref(
path_span,
trait_def_id,
self_ty,
@ -971,7 +1047,8 @@ pub(super) fn instantiate_poly_trait_ref_inner(
"instantiate_poly_trait_ref({:?}, bounds={:?}) -> {:?}",
trait_ref, bounds, poly_trait_ref
);
potential_assoc_types
arg_count_correct
}
/// Given a trait bound like `Debug`, applies that trait bound the given self-type to construct
@ -999,7 +1076,7 @@ pub fn instantiate_poly_trait_ref(
constness: Constness,
self_ty: Ty<'tcx>,
bounds: &mut Bounds<'tcx>,
) -> Option<Vec<Span>> {
) -> Result<(), GenericArgCountMismatch> {
self.instantiate_poly_trait_ref_inner(
&poly_trait_ref.trait_ref,
poly_trait_ref.span,
@ -1088,7 +1165,8 @@ fn create_substs_for_ast_trait_ref<'a>(
trait_def_id: DefId,
self_ty: Ty<'tcx>,
trait_segment: &'a hir::PathSegment<'a>,
) -> (SubstsRef<'tcx>, Vec<ConvertedBinding<'a, 'tcx>>, Option<Vec<Span>>) {
) -> (SubstsRef<'tcx>, Vec<ConvertedBinding<'a, 'tcx>>, Result<(), GenericArgCountMismatch>)
{
debug!("create_substs_for_ast_trait_ref(trait_segment={:?})", trait_segment);
self.complain_about_internal_fn_trait(span, trait_def_id, trait_segment);
@ -1433,13 +1511,16 @@ fn conv_object_ty_poly_trait_ref(
let mut potential_assoc_types = Vec::new();
let dummy_self = self.tcx().types.trait_object_dummy_self;
for trait_bound in trait_bounds.iter().rev() {
let cur_potential_assoc_types = self.instantiate_poly_trait_ref(
if let Err(GenericArgCountMismatch {
invalid_args: cur_potential_assoc_types, ..
}) = self.instantiate_poly_trait_ref(
trait_bound,
Constness::NotConst,
dummy_self,
&mut bounds,
);
potential_assoc_types.extend(cur_potential_assoc_types.into_iter().flatten());
) {
potential_assoc_types.extend(cur_potential_assoc_types.into_iter());
}
}
// Expand trait aliases recursively and check that only one regular (non-auto) trait

14
src/librustc_typeck/check/method/confirm.rs
View File

@ -299,7 +299,7 @@ fn instantiate_method_substs(
// If they were not explicitly supplied, just construct fresh
// variables.
let generics = self.tcx.generics_of(pick.item.def_id);
AstConv::check_generic_arg_count_for_call(
let arg_count_correct = AstConv::check_generic_arg_count_for_call(
self.tcx, self.span, &generics, &seg, true, // `is_method_call`
);
@ -313,10 +313,16 @@ fn instantiate_method_substs(
parent_substs,
false,
None,
arg_count_correct.is_ok(),
// Provide the generic args, and whether types should be inferred.
|_| {
// The last argument of the returned tuple here is unimportant.
if let Some(ref data) = seg.args { (Some(data), false) } else { (None, false) }
|def_id| {
// The last component of the returned tuple here is unimportant.
if def_id == pick.item.def_id {
if let Some(ref data) = seg.args {
return (Some(data), false);
}
}
(None, false)
},
// Provide substitutions for parameters for which (valid) arguments have been provided.
|param, arg| match (&param.kind, arg) {

12
src/librustc_typeck/check/mod.rs
View File

@ -87,7 +87,7 @@
mod wfcheck;
pub mod writeback;
use crate::astconv::{AstConv, PathSeg};
use crate::astconv::{AstConv, GenericArgCountMismatch, PathSeg};
use crate::middle::lang_items;
use rustc::hir::map::blocks::FnLikeNode;
use rustc::hir::map::Map;
@ -5431,10 +5431,11 @@ pub fn instantiate_value_path(
// parameter internally, but we don't allow users to specify the
// parameter's value explicitly, so we have to do some error-
// checking here.
let suppress_errors = AstConv::check_generic_arg_count_for_call(
tcx, span, &generics, &seg, false, // `is_method_call`
);
if suppress_errors {
if let Err(GenericArgCountMismatch { reported: Some(ErrorReported), .. }) =
AstConv::check_generic_arg_count_for_call(
tcx, span, &generics, &seg, false, // `is_method_call`
)
{
infer_args_for_err.insert(index);
self.set_tainted_by_errors(); // See issue #53251.
}
@ -5499,6 +5500,7 @@ pub fn instantiate_value_path(
&[][..],
has_self,
self_ty,
infer_args_for_err.is_empty(),
// Provide the generic args, and whether types should be inferred.
|def_id| {
if let Some(&PathSeg(_, index)) =

2
src/librustc_typeck/collect.rs
View File

@ -1270,7 +1270,7 @@ fn generics_of(tcx: TyCtxt<'_>, def_id: DefId) -> &ty::Generics {
let object_lifetime_defaults = tcx.object_lifetime_defaults(hir_id);
// Now create the real type parameters.
// Now create the real type and const parameters.
let type_start = own_start - has_self as u32 + params.len() as u32;
let mut i = 0;
params.extend(ast_generics.params.iter().filter_map(|param| {

10
src/test/ui/const-generics/const-arg-type-arg-misordered.rs Normal file
View File

@ -0,0 +1,10 @@
#![feature(const_generics)]
//~^ WARN the feature `const_generics` is incomplete and may cause the compiler to crash
type Array<T, const N: usize> = [T; N];
fn foo<const N: usize>() -> Array<N, ()> { //~ ERROR constant provided when a type was expected
unimplemented!()
}
fn main() {}

19
src/test/ui/const-generics/const-arg-type-arg-misordered.stderr Normal file
View File

@ -0,0 +1,19 @@
warning: the feature `const_generics` is incomplete and may cause the compiler to crash
--> $DIR/const-arg-type-arg-misordered.rs:1:12
|
LL | #![feature(const_generics)]
| ^^^^^^^^^^^^^^
|
= note: `#[warn(incomplete_features)]` on by default
error[E0747]: constant provided when a type was expected
--> $DIR/const-arg-type-arg-misordered.rs:6:35
|
LL | fn foo<const N: usize>() -> Array<N, ()> {
| ^
|
= note: type arguments must be provided before constant arguments
error: aborting due to previous error
For more information about this error, try `rustc --explain E0747`.

10
src/test/ui/const-generics/const-param-after-const-literal-arg.rs Normal file
View File

@ -0,0 +1,10 @@
// check-pass
#![allow(incomplete_features)]
#![feature(const_generics)]
struct Foo<const A: usize, const B: usize>;
impl<const A: usize> Foo<1, A> {} // ok
fn main() {}

1
src/test/ui/const-generics/const-param-before-other-params.rs
View File

@ -1,3 +1,4 @@
#![allow(incomplete_features)]
#![feature(const_generics)]
fn bar<const X: (), 'a>(_: &'a ()) {

4
src/test/ui/const-generics/const-param-before-other-params.stderr
View File

@ -1,11 +1,11 @@
error: lifetime parameters must be declared prior to const parameters
--> $DIR/const-param-before-other-params.rs:3:21
--> $DIR/const-param-before-other-params.rs:4:21
|
LL | fn bar<const X: (), 'a>(_: &'a ()) {
| --------------^^- help: reorder the parameters: lifetimes, then types, then consts: `<'a, const X: ()>`
error: type parameters must be declared prior to const parameters
--> $DIR/const-param-before-other-params.rs:7:21
--> $DIR/const-param-before-other-params.rs:8:21
|
LL | fn foo<const X: (), T>(_: &T) {
| --------------^- help: reorder the parameters: lifetimes, then types, then consts: `<T, const X: ()>`

1
src/test/ui/generic/generic-arg-mismatch-recover.rs
View File

@ -4,7 +4,6 @@
fn main() {
Foo::<'static, 'static, ()>(&0); //~ ERROR wrong number of lifetime arguments
//~^ ERROR mismatched types
Bar::<'static, 'static, ()>(&()); //~ ERROR wrong number of lifetime arguments
//~^ ERROR wrong number of type arguments

18
src/test/ui/generic/generic-arg-mismatch-recover.stderr
View File

@ -4,28 +4,18 @@ error[E0107]: wrong number of lifetime arguments: expected 1, found 2
LL | Foo::<'static, 'static, ()>(&0);
| ^^^^^^^ unexpected lifetime argument
error[E0308]: mismatched types
--> $DIR/generic-arg-mismatch-recover.rs:6:33
|
LL | Foo::<'static, 'static, ()>(&0);
| ^^ expected `()`, found integer
|
= note: expected reference `&'static ()`
found reference `&{integer}`
error[E0107]: wrong number of lifetime arguments: expected 1, found 2
--> $DIR/generic-arg-mismatch-recover.rs:9:20
--> $DIR/generic-arg-mismatch-recover.rs:8:20
|
LL | Bar::<'static, 'static, ()>(&());
| ^^^^^^^ unexpected lifetime argument
error[E0107]: wrong number of type arguments: expected 0, found 1
--> $DIR/generic-arg-mismatch-recover.rs:9:29
--> $DIR/generic-arg-mismatch-recover.rs:8:29
|
LL | Bar::<'static, 'static, ()>(&());
| ^^ unexpected type argument
error: aborting due to 4 previous errors
error: aborting due to 3 previous errors
Some errors have detailed explanations: E0107, E0308.
For more information about an error, try `rustc --explain E0107`.
For more information about this error, try `rustc --explain E0107`.

2
src/test/ui/parser/issue-14303-fncall.rs
View File

@ -11,7 +11,7 @@ fn foo<'a, 'b>(start: &'a usize, end: &'a usize) {
let _x = (*start..*end)
.map(|x| S { a: start, b: end })
.collect::<Vec<S<_, 'a>>>();
//~^ ERROR lifetime arguments must be declared prior to type arguments
//~^ ERROR type provided when a lifetime was expected
}
fn main() {}

9
src/test/ui/parser/issue-14303-fncall.stderr
View File

@ -1,8 +1,11 @@
error: lifetime arguments must be declared prior to type arguments
--> $DIR/issue-14303-fncall.rs:13:29
error[E0747]: type provided when a lifetime was expected
--> $DIR/issue-14303-fncall.rs:13:26
|
LL | .collect::<Vec<S<_, 'a>>>();
| ^^
| ^
|
= note: lifetime arguments must be provided before type arguments
error: aborting due to previous error
For more information about this error, try `rustc --explain E0747`.

2
src/test/ui/parser/issue-14303-path.rs
View File

@ -8,6 +8,6 @@ pub struct X<'a, 'b, 'c, T> {
}
fn bar<'a, 'b, 'c, T>(x: foo::X<'a, T, 'b, 'c>) {}
//~^ ERROR lifetime arguments must be declared prior to type arguments
//~^ ERROR type provided when a lifetime was expected
fn main() {}

9
src/test/ui/parser/issue-14303-path.stderr
View File

@ -1,8 +1,11 @@
error: lifetime arguments must be declared prior to type arguments
--> $DIR/issue-14303-path.rs:10:40
error[E0747]: type provided when a lifetime was expected
--> $DIR/issue-14303-path.rs:10:37
|
LL | fn bar<'a, 'b, 'c, T>(x: foo::X<'a, T, 'b, 'c>) {}
| ^^ ^^
| ^
|
= note: lifetime arguments must be provided before type arguments
error: aborting due to previous error
For more information about this error, try `rustc --explain E0747`.

8
src/test/ui/suggestions/suggest-move-types.rs
View File

@ -33,7 +33,7 @@ struct A<T, M: One<A=(), T>> { //~ ERROR associated type bindings must be declar
struct Al<'a, T, M: OneWithLifetime<A=(), T, 'a>> {
//~^ ERROR associated type bindings must be declared after generic parameters
//~^^ ERROR lifetime arguments must be declared prior to type arguments
//~^^ ERROR type provided when a lifetime was expected
m: M,
t: &'a T,
}
@ -47,7 +47,7 @@ struct B<T, U, V, M: Three<A=(), B=(), C=(), T, U, V>> { //~ ERROR associated ty
struct Bl<'a, 'b, 'c, T, U, V, M: ThreeWithLifetime<A=(), B=(), C=(), T, U, V, 'a, 'b, 'c>> {
//~^ ERROR associated type bindings must be declared after generic parameters
//~^^ ERROR lifetime arguments must be declared prior to type arguments
//~^^ ERROR type provided when a lifetime was expected
m: M,
t: &'a T,
u: &'b U,
@ -63,7 +63,7 @@ struct C<T, U, V, M: Three<T, A=(), B=(), C=(), U, V>> { //~ ERROR associated ty
struct Cl<'a, 'b, 'c, T, U, V, M: ThreeWithLifetime<T, 'a, A=(), B=(), C=(), U, 'b, V, 'c>> {
//~^ ERROR associated type bindings must be declared after generic parameters
//~^^ ERROR lifetime arguments must be declared prior to type arguments
//~^^ ERROR lifetime provided when a type was expected
m: M,
t: &'a T,
u: &'b U,
@ -79,7 +79,7 @@ struct D<T, U, V, M: Three<T, A=(), B=(), U, C=(), V>> { //~ ERROR associated ty
struct Dl<'a, 'b, 'c, T, U, V, M: ThreeWithLifetime<T, 'a, A=(), B=(), U, 'b, C=(), V, 'c>> {
//~^ ERROR associated type bindings must be declared after generic parameters
//~^^ ERROR lifetime arguments must be declared prior to type arguments
//~^^ ERROR lifetime provided when a type was expected
m: M,
t: &'a T,
u: &'b U,

29
src/test/ui/suggestions/suggest-move-types.stderr
View File

@ -74,29 +74,38 @@ LL | struct Dl<'a, 'b, 'c, T, U, V, M: ThreeWithLifetime<T, 'a, A=(), B=(), U, '
| | this associated type binding should be moved after the generic parameters
| this associated type binding should be moved after the generic parameters
error: lifetime arguments must be declared prior to type arguments
--> $DIR/suggest-move-types.rs:34:46
error[E0747]: type provided when a lifetime was expected
--> $DIR/suggest-move-types.rs:34:43
|
LL | struct Al<'a, T, M: OneWithLifetime<A=(), T, 'a>> {
| ^^
| ^
|
= note: lifetime arguments must be provided before type arguments
error: lifetime arguments must be declared prior to type arguments
--> $DIR/suggest-move-types.rs:48:80
error[E0747]: type provided when a lifetime was expected
--> $DIR/suggest-move-types.rs:48:71
|
LL | struct Bl<'a, 'b, 'c, T, U, V, M: ThreeWithLifetime<A=(), B=(), C=(), T, U, V, 'a, 'b, 'c>> {
| ^^ ^^ ^^
| ^
|
= note: lifetime arguments must be provided before type arguments
error: lifetime arguments must be declared prior to type arguments
error[E0747]: lifetime provided when a type was expected
--> $DIR/suggest-move-types.rs:64:56
|
LL | struct Cl<'a, 'b, 'c, T, U, V, M: ThreeWithLifetime<T, 'a, A=(), B=(), C=(), U, 'b, V, 'c>> {
| ^^ ^^ ^^
| ^^
|
= note: type arguments must be provided before lifetime arguments
error: lifetime arguments must be declared prior to type arguments
error[E0747]: lifetime provided when a type was expected
--> $DIR/suggest-move-types.rs:80:56
|
LL | struct Dl<'a, 'b, 'c, T, U, V, M: ThreeWithLifetime<T, 'a, A=(), B=(), U, 'b, C=(), V, 'c>> {
| ^^ ^^ ^^
| ^^
|
= note: type arguments must be provided before lifetime arguments
error: aborting due to 12 previous errors
For more information about this error, try `rustc --explain E0747`.

2
src/test/ui/traits/trait-object-vs-lifetime.rs
View File

@ -12,6 +12,6 @@ fn main() {
//~^ ERROR wrong number of lifetime arguments: expected 1, found 2
//~| ERROR wrong number of type arguments: expected 1, found 0
let _: S<dyn 'static +, 'static>;
//~^ ERROR lifetime arguments must be declared prior to type arguments
//~^ ERROR type provided when a lifetime was expected
//~| ERROR at least one trait is required for an object type
}

17
src/test/ui/traits/trait-object-vs-lifetime.stderr
View File

@ -1,9 +1,3 @@
error: lifetime arguments must be declared prior to type arguments
--> $DIR/trait-object-vs-lifetime.rs:14:29
|
LL | let _: S<dyn 'static +, 'static>;
| ^^^^^^^
error[E0224]: at least one trait is required for an object type
--> $DIR/trait-object-vs-lifetime.rs:9:23
|
@ -28,6 +22,15 @@ error[E0224]: at least one trait is required for an object type
LL | let _: S<dyn 'static +, 'static>;
| ^^^^^^^^^^^^^
error[E0747]: type provided when a lifetime was expected
--> $DIR/trait-object-vs-lifetime.rs:14:14
|
LL | let _: S<dyn 'static +, 'static>;
| ^^^^^^^^^^^^^
|
= note: lifetime arguments must be provided before type arguments
error: aborting due to 5 previous errors
For more information about this error, try `rustc --explain E0107`.
Some errors have detailed explanations: E0107, E0747.
For more information about an error, try `rustc --explain E0107`.