Skip to content

Commit 3a8bed5

Browse files
borsbors
committed
Auto merge of #127054 - compiler-errors:bound-ordering, r=<try>
Reorder trait bound modifiers *after* `for<...>` binder in trait bounds r? `@fmease` or reassign if you're busy I wanted to crater this to see what the consequences are. Otherwise, we may be able to make this into a lint if the crater fallout is really bad. The motivation for this is because we currently parse: ```rust T: async for<'a> Fn(&'a ()) ``` Instead of: ```rust T: for<'a> async Fn(&'a ()) ``` I believe the latter to be the correct ordering of bounds, since the `async` keyword modifies the *trait* so it should be attached to the trait path.
2 parents 2495953 + 13bff3f commit 3a8bed5

File tree

13 files changed

+102
-51
lines changed

13 files changed

+102
-51
lines changed

‎compiler/rustc_parse/messages.ftl

+3
Original file line numberDiff line numberDiff line change
@@ -61,6 +61,9 @@ parse_bare_cr = {$double_quotes ->
6161
6262
parse_bare_cr_in_raw_string = bare CR not allowed in raw string
6363
64+
parse_binder_before_modifiers = `for<...>` binder should be placed before trait bound modifiers
65+
.label = place the `for<...>` binder before any modifiers
66+
6467
parse_bounds_not_allowed_on_trait_aliases = bounds are not allowed on trait aliases
6568
6669
parse_box_not_pat = expected pattern, found {$descr}

‎compiler/rustc_parse/src/errors.rs

+9
Original file line numberDiff line numberDiff line change
@@ -3028,3 +3028,12 @@ pub struct UnsafeAttrOutsideUnsafeSuggestion {
30283028
#[suggestion_part(code = ")")]
30293029
pub right: Span,
30303030
}
3031+
3032+
#[derive(Diagnostic)]
3033+
#[diag(parse_binder_before_modifiers)]
3034+
pub struct BinderBeforeModifiers {
3035+
#[primary_span]
3036+
pub binder_span: Span,
3037+
#[label]
3038+
pub modifiers_span: Span,
3039+
}

‎compiler/rustc_parse/src/parser/expr.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -2327,7 +2327,7 @@ impl<'a> Parser<'a> {
23272327
let before = self.prev_token.clone();
23282328
let binder = if self.check_keyword(kw::For) {
23292329
let lo = self.token.span;
2330-
let lifetime_defs = self.parse_late_bound_lifetime_defs()?;
2330+
let (lifetime_defs, _) = self.parse_late_bound_lifetime_defs()?;
23312331
let span = lo.to(self.prev_token.span);
23322332

23332333
self.psess.gated_spans.gate(sym::closure_lifetime_binder, span);

‎compiler/rustc_parse/src/parser/generics.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -457,7 +457,7 @@ impl<'a> Parser<'a> {
457457
// * `for<'a> Trait1<'a>: Trait2<'a /* ok */>`
458458
// * `(for<'a> Trait1<'a>): Trait2<'a /* not ok */>`
459459
// * `for<'a> for<'b> Trait1<'a, 'b>: Trait2<'a /* ok */, 'b /* not ok */>`
460-
let lifetime_defs = self.parse_late_bound_lifetime_defs()?;
460+
let (lifetime_defs, _) = self.parse_late_bound_lifetime_defs()?;
461461

462462
// Parse type with mandatory colon and (possibly empty) bounds,
463463
// or with mandatory equality sign and the second type.

‎compiler/rustc_parse/src/parser/ty.rs

+67-37
Original file line numberDiff line numberDiff line change
@@ -18,7 +18,7 @@ use rustc_ast::{
1818
};
1919
use rustc_errors::{Applicability, PResult};
2020
use rustc_span::symbol::{kw, sym, Ident};
21-
use rustc_span::{Span, Symbol};
21+
use rustc_span::{ErrorGuaranteed, Span, Symbol};
2222
use thin_vec::{thin_vec, ThinVec};
2323

2424
#[derive(Copy, Clone, PartialEq)]
@@ -280,7 +280,7 @@ impl<'a> Parser<'a> {
280280
// Function pointer type or bound list (trait object type) starting with a poly-trait.
281281
// `for<'lt> [unsafe] [extern "ABI"] fn (&'lt S) -> T`
282282
// `for<'lt> Trait1<'lt> + Trait2 + 'a`
283-
let lifetime_defs = self.parse_late_bound_lifetime_defs()?;
283+
let (lifetime_defs, _) = self.parse_late_bound_lifetime_defs()?;
284284
if self.check_fn_front_matter(false, Case::Sensitive) {
285285
self.parse_ty_bare_fn(
286286
lo,
@@ -833,12 +833,9 @@ impl<'a> Parser<'a> {
833833
let lo = self.token.span;
834834
let leading_token = self.prev_token.clone();
835835
let has_parens = self.eat(&token::OpenDelim(Delimiter::Parenthesis));
836-
let inner_lo = self.token.span;
837836

838-
let modifiers = self.parse_trait_bound_modifiers()?;
839837
let bound = if self.token.is_lifetime() {
840-
self.error_lt_bound_with_modifiers(modifiers);
841-
self.parse_generic_lt_bound(lo, inner_lo, has_parens)?
838+
self.parse_generic_lt_bound(lo, has_parens)?
842839
} else if self.eat_keyword(kw::Use) {
843840
// parse precise captures, if any. This is `use<'lt, 'lt, P, P>`; a list of
844841
// lifetimes and ident params (including SelfUpper). These are validated later
@@ -848,7 +845,7 @@ impl<'a> Parser<'a> {
848845
let (args, args_span) = self.parse_precise_capturing_args()?;
849846
GenericBound::Use(args, use_span.to(args_span))
850847
} else {
851-
self.parse_generic_ty_bound(lo, has_parens, modifiers, &leading_token)?
848+
self.parse_generic_ty_bound(lo, has_parens, &leading_token)?
852849
};
853850

854851
Ok(bound)
@@ -858,50 +855,64 @@ impl<'a> Parser<'a> {
858855
/// ```ebnf
859856
/// LT_BOUND = LIFETIME
860857
/// ```
861-
fn parse_generic_lt_bound(
862-
&mut self,
863-
lo: Span,
864-
inner_lo: Span,
865-
has_parens: bool,
866-
) -> PResult<'a, GenericBound> {
867-
let bound = GenericBound::Outlives(self.expect_lifetime());
858+
fn parse_generic_lt_bound(&mut self, lo: Span, has_parens: bool) -> PResult<'a, GenericBound> {
859+
let lt = self.expect_lifetime();
860+
let bound = GenericBound::Outlives(lt);
868861
if has_parens {
869862
// FIXME(Centril): Consider not erroring here and accepting `('lt)` instead,
870863
// possibly introducing `GenericBound::Paren(P<GenericBound>)`?
871-
self.recover_paren_lifetime(lo, inner_lo)?;
864+
self.recover_paren_lifetime(lo, lt.ident.span)?;
872865
}
873866
Ok(bound)
874867
}
875868

876869
/// Emits an error if any trait bound modifiers were present.
877-
fn error_lt_bound_with_modifiers(&self, modifiers: TraitBoundModifiers) {
878-
match modifiers.constness {
870+
fn error_lt_bound_with_modifiers(
871+
&self,
872+
modifiers: TraitBoundModifiers,
873+
binder_span: Option<Span>,
874+
) -> ErrorGuaranteed {
875+
let TraitBoundModifiers { constness, asyncness, polarity } = modifiers;
876+
877+
match constness {
879878
BoundConstness::Never => {}
880879
BoundConstness::Always(span) | BoundConstness::Maybe(span) => {
881-
self.dcx().emit_err(errors::ModifierLifetime {
882-
span,
883-
modifier: modifiers.constness.as_str(),
884-
});
880+
return self
881+
.dcx()
882+
.emit_err(errors::ModifierLifetime { span, modifier: constness.as_str() });
885883
}
886884
}
887885

888-
match modifiers.polarity {
886+
match polarity {
889887
BoundPolarity::Positive => {}
890888
BoundPolarity::Negative(span) | BoundPolarity::Maybe(span) => {
891-
self.dcx().emit_err(errors::ModifierLifetime {
892-
span,
893-
modifier: modifiers.polarity.as_str(),
894-
});
889+
return self
890+
.dcx()
891+
.emit_err(errors::ModifierLifetime { span, modifier: polarity.as_str() });
892+
}
893+
}
894+
895+
match asyncness {
896+
BoundAsyncness::Normal => {}
897+
BoundAsyncness::Async(span) => {
898+
return self
899+
.dcx()
900+
.emit_err(errors::ModifierLifetime { span, modifier: asyncness.as_str() });
895901
}
896902
}
903+
904+
if let Some(span) = binder_span {
905+
return self.dcx().emit_err(errors::ModifierLifetime { span, modifier: "for<...>" });
906+
}
907+
908+
unreachable!("lifetime bound intercepted in `parse_generic_ty_bound` but no modifiers?")
897909
}
898910

899911
/// Recover on `('lifetime)` with `(` already eaten.
900-
fn recover_paren_lifetime(&mut self, lo: Span, inner_lo: Span) -> PResult<'a, ()> {
901-
let inner_span = inner_lo.to(self.prev_token.span);
912+
fn recover_paren_lifetime(&mut self, lo: Span, lt_span: Span) -> PResult<'a, ()> {
902913
self.expect(&token::CloseDelim(Delimiter::Parenthesis))?;
903914
let span = lo.to(self.prev_token.span);
904-
let (sugg, snippet) = if let Ok(snippet) = self.span_to_snippet(inner_span) {
915+
let (sugg, snippet) = if let Ok(snippet) = self.span_to_snippet(lt_span) {
905916
(Some(span), snippet)
906917
} else {
907918
(None, String::new())
@@ -970,15 +981,31 @@ impl<'a> Parser<'a> {
970981
/// TY_BOUND_NOPAREN = [TRAIT_BOUND_MODIFIERS] [for<LT_PARAM_DEFS>] SIMPLE_PATH
971982
/// ```
972983
///
973-
/// For example, this grammar accepts `~const ?for<'a: 'b> m::Trait<'a>`.
984+
/// For example, this grammar accepts `for<'a: 'b> ~const ?m::Trait<'a>`.
974985
fn parse_generic_ty_bound(
975986
&mut self,
976987
lo: Span,
977988
has_parens: bool,
978-
modifiers: TraitBoundModifiers,
979989
leading_token: &Token,
980990
) -> PResult<'a, GenericBound> {
981-
let mut lifetime_defs = self.parse_late_bound_lifetime_defs()?;
991+
let (mut lifetime_defs, binder_span) = self.parse_late_bound_lifetime_defs()?;
992+
993+
let modifiers_lo = self.token.span;
994+
let modifiers = self.parse_trait_bound_modifiers()?;
995+
let modifiers_span = modifiers_lo.to(self.prev_token.span);
996+
997+
// Recover erroneous lifetime bound with modifiers or binder.
998+
// e.g. `T: for<'a> 'a` or `T: ~const 'a`.
999+
if self.token.is_lifetime() {
1000+
let _: ErrorGuaranteed = self.error_lt_bound_with_modifiers(modifiers, binder_span);
1001+
return self.parse_generic_lt_bound(lo, has_parens);
1002+
}
1003+
1004+
if let (more_lifetime_defs, Some(binder_span)) = self.parse_late_bound_lifetime_defs()? {
1005+
lifetime_defs.extend(more_lifetime_defs);
1006+
self.dcx().emit_err(errors::BinderBeforeModifiers { binder_span, modifiers_span });
1007+
}
1008+
9821009
let mut path = if self.token.is_keyword(kw::Fn)
9831010
&& self.look_ahead(1, |tok| tok.kind == TokenKind::OpenDelim(Delimiter::Parenthesis))
9841011
&& let Some(path) = self.recover_path_from_fn()
@@ -1094,16 +1121,19 @@ impl<'a> Parser<'a> {
10941121
}
10951122

10961123
/// Optionally parses `for<$generic_params>`.
1097-
pub(super) fn parse_late_bound_lifetime_defs(&mut self) -> PResult<'a, ThinVec<GenericParam>> {
1124+
pub(super) fn parse_late_bound_lifetime_defs(
1125+
&mut self,
1126+
) -> PResult<'a, (ThinVec<GenericParam>, Option<Span>)> {
10981127
if self.eat_keyword(kw::For) {
1128+
let lo = self.token.span;
10991129
self.expect_lt()?;
11001130
let params = self.parse_generic_params()?;
11011131
self.expect_gt()?;
1102-
// We rely on AST validation to rule out invalid cases: There must not be type
1103-
// parameters, and the lifetime parameters must not have bounds.
1104-
Ok(params)
1132+
// We rely on AST validation to rule out invalid cases: There must not be
1133+
// type or const parameters, and parameters must not have bounds.
1134+
Ok((params, Some(lo.to(self.prev_token.span))))
11051135
} else {
1106-
Ok(ThinVec::new())
1136+
Ok((ThinVec::new(), None))
11071137
}
11081138
}
11091139

‎src/tools/tidy/src/ui_tests.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -16,7 +16,7 @@ use std::path::{Path, PathBuf};
1616
const ENTRY_LIMIT: u32 = 900;
1717
// FIXME: The following limits should be reduced eventually.
1818

19-
const ISSUES_ENTRY_LIMIT: u32 = 1672;
19+
const ISSUES_ENTRY_LIMIT: u32 = 1673;
2020

2121
const EXPECTED_TEST_FILE_EXTENSIONS: &[&str] = &[
2222
"rs", // test source files

‎tests/ui/async-await/async-fn/higher-ranked-async-fn.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -15,7 +15,7 @@ async fn f(arg: &i32) {}
1515

1616
async fn func<F>(f: F)
1717
where
18-
F: async for<'a> Fn(&'a i32),
18+
F: for<'a> async Fn(&'a i32),
1919
{
2020
let x: i32 = 0;
2121
f(&x).await;

‎tests/ui/impl-trait/normalize-tait-in-const.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -24,7 +24,7 @@ mod foo {
2424
}
2525
use foo::*;
2626

27-
const fn with_positive<F: ~const for<'a> Fn(&'a Alias<'a>) + ~const Destruct>(fun: F) {
27+
const fn with_positive<F: for<'a> ~const Fn(&'a Alias<'a>) + ~const Destruct>(fun: F) {
2828
fun(filter_positive());
2929
}
3030

‎tests/ui/impl-trait/normalize-tait-in-const.stderr

+4-4
Original file line numberDiff line numberDiff line change
@@ -1,13 +1,13 @@
11
error: `~const` can only be applied to `#[const_trait]` traits
22
--> $DIR/normalize-tait-in-const.rs:27:42
33
|
4-
LL | const fn with_positive<F: ~const for<'a> Fn(&'a Alias<'a>) + ~const Destruct>(fun: F) {
4+
LL | const fn with_positive<F: for<'a> ~const Fn(&'a Alias<'a>) + ~const Destruct>(fun: F) {
55
| ^^^^^^^^^^^^^^^^^
66

77
error: `~const` can only be applied to `#[const_trait]` traits
88
--> $DIR/normalize-tait-in-const.rs:27:69
99
|
10-
LL | const fn with_positive<F: ~const for<'a> Fn(&'a Alias<'a>) + ~const Destruct>(fun: F) {
10+
LL | const fn with_positive<F: for<'a> ~const Fn(&'a Alias<'a>) + ~const Destruct>(fun: F) {
1111
| ^^^^^^^^
1212

1313
error[E0015]: cannot call non-const closure in constant functions
@@ -19,7 +19,7 @@ LL | fun(filter_positive());
1919
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
2020
help: consider further restricting this bound
2121
|
22-
LL | const fn with_positive<F: ~const for<'a> Fn(&'a Alias<'a>) + ~const Destruct + ~const Fn(&foo::Alias<'_>)>(fun: F) {
22+
LL | const fn with_positive<F: for<'a> ~const Fn(&'a Alias<'a>) + ~const Destruct + ~const Fn(&foo::Alias<'_>)>(fun: F) {
2323
| ++++++++++++++++++++++++++++
2424
help: add `#![feature(effects)]` to the crate attributes to enable
2525
|
@@ -29,7 +29,7 @@ LL + #![feature(effects)]
2929
error[E0493]: destructor of `F` cannot be evaluated at compile-time
3030
--> $DIR/normalize-tait-in-const.rs:27:79
3131
|
32-
LL | const fn with_positive<F: ~const for<'a> Fn(&'a Alias<'a>) + ~const Destruct>(fun: F) {
32+
LL | const fn with_positive<F: for<'a> ~const Fn(&'a Alias<'a>) + ~const Destruct>(fun: F) {
3333
| ^^^ the destructor for this type cannot be evaluated in constant functions
3434
LL | fun(filter_positive());
3535
LL | }

‎tests/ui/issues/issue-39089.rs

+1-2
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,4 @@
1-
//@ check-pass
2-
#![allow(dead_code)]
31
fn f<T: ?for<'a> Sized>() {}
2+
//~^ ERROR `for<...>` binder should be placed before trait bound modifiers
43

54
fn main() {}

‎tests/ui/issues/issue-39089.stderr

+10
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,10 @@
1+
error: `for<...>` binder should be placed before trait bound modifiers
2+
--> $DIR/issue-39089.rs:1:13
3+
|
4+
LL | fn f<T: ?for<'a> Sized>() {}
5+
| - ^^^^
6+
| |
7+
| place the `for<...>` binder before any modifiers
8+
9+
error: aborting due to 1 previous error
10+

‎tests/ui/parser/bounds-type.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,7 @@ struct S<
55
T: Tr + 'a, // OK
66
T: 'a, // OK
77
T:, // OK
8-
T: ?for<'a> Trait, // OK
8+
T: for<'a> ?Trait, // OK
99
T: Tr +, // OK
1010
T: ?'a, //~ ERROR `?` may only modify trait bounds, not lifetime bounds
1111

‎tests/ui/rfcs/rfc-2632-const-trait-impl/tilde-const-syntax.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -4,6 +4,6 @@
44
#![feature(const_trait_impl)]
55

66
struct S<
7-
T: ~const ?for<'a> Tr<'a> + 'static + ~const std::ops::Add,
8-
T: ~const ?for<'a: 'b> m::Trait<'a>,
7+
T: for<'a> ~const ?Tr<'a> + 'static + ~const std::ops::Add,
8+
T: for<'a: 'b> ~const ?m::Trait<'a>,
99
>;

0 commit comments

Comments
 (0)