dnrops
/
rust
mirror of https://github.com/rust-lang/rust.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Change RTN to use .. again

This commit is contained in:
Michael Goulet 2024-06-28 11:49:16 -04:00
parent 99f77a2eda
commit b1a0c0b123
47 changed files with 109 additions and 163 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
compiler/rustc_ast/src/ast.rs
View File

@ -176,6 +176,8 @@ pub enum GenericArgs {
AngleBracketed(AngleBracketedArgs),
/// The `(A, B)` and `C` in `Foo(A, B) -> C`.
Parenthesized(ParenthesizedArgs),
/// `(..)` in return type notation
ParenthesizedElided(Span),
}
impl GenericArgs {
@ -187,6 +189,7 @@ impl GenericArgs {
match self {
AngleBracketed(data) => data.span,
Parenthesized(data) => data.span,
ParenthesizedElided(span) => *span,
}
}
}
@ -2051,7 +2054,7 @@ impl UintTy {
/// * the `A: Bound` in `Trait<A: Bound>`
/// * the `RetTy` in `Trait(ArgTy, ArgTy) -> RetTy`
/// * the `C = { Ct }` in `Trait<C = { Ct }>` (feature `associated_const_equality`)
/// * the `f(): Bound` in `Trait<f(): Bound>` (feature `return_type_notation`)
/// * the `f(..): Bound` in `Trait<f(..): Bound>` (feature `return_type_notation`)
#[derive(Clone, Encodable, Decodable, Debug)]
pub struct AssocItemConstraint {
pub id: NodeId,

1
compiler/rustc_ast/src/mut_visit.rs
View File

@ -582,6 +582,7 @@ fn noop_visit_generic_args<T: MutVisitor>(generic_args: &mut GenericArgs, vis: &
match generic_args {
GenericArgs::AngleBracketed(data) => vis.visit_angle_bracketed_parameter_data(data),
GenericArgs::Parenthesized(data) => vis.visit_parenthesized_parameter_data(data),
GenericArgs::ParenthesizedElided(span) => vis.visit_span(span),
}
}

2
compiler/rustc_ast/src/util/classify.rs
View File

@ -234,6 +234,6 @@ fn path_return_type(path: &ast::Path) -> Option<&ast::Ty> {
ast::FnRetTy::Default(_) => None,
ast::FnRetTy::Ty(ret) => Some(ret),
},
ast::GenericArgs::AngleBracketed(_) => None,
ast::GenericArgs::AngleBracketed(_) | ast::GenericArgs::ParenthesizedElided(_) => None,
}
}

1
compiler/rustc_ast/src/visit.rs
View File

@ -609,6 +609,7 @@ where
walk_list!(visitor, visit_ty, inputs);
try_visit!(visitor.visit_fn_ret_ty(output));
}
GenericArgs::ParenthesizedElided(_span) => {}
}
V::Result::output()
}

3
compiler/rustc_ast_lowering/messages.ftl
View File

@ -36,6 +36,9 @@ ast_lowering_bad_return_type_notation_inputs =
argument types not allowed with return type notation
.suggestion = remove the input types
ast_lowering_bad_return_type_notation_needs_dots = return type notation arguments must be elided with `..`
.suggestion = add `..`
ast_lowering_bad_return_type_notation_output =
return type not allowed with return type notation
.suggestion = remove the return type

6
compiler/rustc_ast_lowering/src/errors.rs
View File

@ -393,6 +393,12 @@ pub enum BadReturnTypeNotation {
#[suggestion(code = "", applicability = "maybe-incorrect")]
span: Span,
},
#[diag(ast_lowering_bad_return_type_notation_needs_dots)]
NeedsDots {
#[primary_span]
#[suggestion(code = "(..)", applicability = "maybe-incorrect")]
span: Span,
},
}
#[derive(Diagnostic)]

25
compiler/rustc_ast_lowering/src/lib.rs
View File

@ -979,20 +979,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
self.lower_angle_bracketed_parameter_data(data, ParamMode::Explicit, itctx).0
}
GenericArgs::Parenthesized(data) => {
if data.inputs.is_empty() && matches!(data.output, FnRetTy::Default(..)) {
let parenthesized = if self.tcx.features().return_type_notation {
hir::GenericArgsParentheses::ReturnTypeNotation
} else {
self.emit_bad_parenthesized_trait_in_assoc_ty(data);
hir::GenericArgsParentheses::No
};
GenericArgsCtor {
args: Default::default(),
constraints: &[],
parenthesized,
span: data.inputs_span,
}
} else if let Some(first_char) = constraint.ident.as_str().chars().next()
if let Some(first_char) = constraint.ident.as_str().chars().next()
&& first_char.is_ascii_lowercase()
{
let mut err = if !data.inputs.is_empty() {
@ -1004,7 +991,9 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
span: data.inputs_span.shrink_to_hi().to(ty.span),
})
} else {
unreachable!("inputs are empty and return type is not provided")
self.dcx().create_err(errors::BadReturnTypeNotation::NeedsDots {
span: data.inputs_span,
})
};
if !self.tcx.features().return_type_notation
&& self.tcx.sess.is_nightly_build()
@ -1034,6 +1023,12 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
.0
}
}
GenericArgs::ParenthesizedElided(span) => GenericArgsCtor {
args: Default::default(),
constraints: &[],
parenthesized: hir::GenericArgsParentheses::ReturnTypeNotation,
span: *span,
},
};
gen_args_ctor.into_generic_args(self)
} else {

3
compiler/rustc_ast_lowering/src/path.rs
View File

@ -276,6 +276,9 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
)
}
},
GenericArgs::ParenthesizedElided(_span) => {
todo!()
}
}
} else {
(

7
compiler/rustc_ast_passes/src/ast_validation.rs
View File

@ -1289,6 +1289,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
self.with_impl_trait(None, |this| this.visit_ty(ty));
}
}
GenericArgs::ParenthesizedElided(_span) => {}
}
}
@ -1445,7 +1446,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
span: args.span,
});
}
None => {}
Some(ast::GenericArgs::ParenthesizedElided(_)) | None => {}
}
}
}
@ -1693,7 +1694,9 @@ fn deny_equality_constraints(
// Add `<Bar = RhsTy>` to `Foo`.
match &mut assoc_path.segments[len].args {
Some(args) => match args.deref_mut() {
GenericArgs::Parenthesized(_) => continue,
GenericArgs::Parenthesized(_) | GenericArgs::ParenthesizedElided(..) => {
continue;
}
GenericArgs::AngleBracketed(args) => {
args.args.push(arg);
}

24
compiler/rustc_ast_passes/src/feature_gate.rs
View File

@ -1,6 +1,6 @@
use rustc_ast as ast;
use rustc_ast::visit::{self, AssocCtxt, FnCtxt, FnKind, Visitor};
use rustc_ast::{attr, AssocItemConstraint, AssocItemConstraintKind, NodeId};
use rustc_ast::{attr, NodeId};
use rustc_ast::{token, PatKind};
use rustc_feature::{AttributeGate, BuiltinAttribute, Features, GateIssue, BUILTIN_ATTRIBUTE_MAP};
use rustc_session::parse::{feature_err, feature_err_issue, feature_warn};
@ -445,23 +445,6 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
visit::walk_fn(self, fn_kind)
}
fn visit_assoc_item_constraint(&mut self, constraint: &'a AssocItemConstraint) {
if let AssocItemConstraintKind::Bound { .. } = constraint.kind
&& let Some(ast::GenericArgs::Parenthesized(args)) = constraint.gen_args.as_ref()
&& args.inputs.is_empty()
&& let ast::FnRetTy::Default(..) = args.output
{
gate!(
&self,
return_type_notation,
constraint.span,
"return type notation is experimental"
);
}
visit::walk_assoc_item_constraint(self, constraint)
}
fn visit_assoc_item(&mut self, i: &'a ast::AssocItem, ctxt: AssocCtxt) {
let is_fn = match &i.kind {
ast::AssocItemKind::Fn(_) => true,
@ -566,6 +549,7 @@ pub fn check_crate(krate: &ast::Crate, sess: &Session, features: &Features) {
unsafe_extern_blocks,
"`unsafe extern {}` blocks and `safe` keyword are experimental"
);
gate_all!(return_type_notation, "return type notation is experimental");
if !visitor.features.never_patterns {
if let Some(spans) = spans.get(&sym::never_patterns) {
@ -611,10 +595,6 @@ pub fn check_crate(krate: &ast::Crate, sess: &Session, features: &Features) {
gate_all_legacy_dont_use!(box_patterns, "box pattern syntax is experimental");
gate_all_legacy_dont_use!(trait_alias, "trait aliases are experimental");
// Despite being a new feature, `where T: Trait<Assoc(): Sized>`, which is RTN syntax now,
// used to be gated under associated_type_bounds, which are right above, so RTN needs to
// be too.
gate_all_legacy_dont_use!(return_type_notation, "return type notation is experimental");
gate_all_legacy_dont_use!(decl_macro, "`macro` is experimental");
gate_all_legacy_dont_use!(try_blocks, "`try` blocks are unstable");
gate_all_legacy_dont_use!(auto_traits, "`auto` traits are unstable");

5
compiler/rustc_ast_pretty/src/pprust/state.rs
View File

@ -1060,6 +1060,11 @@ impl<'a> PrintState<'a> for State<'a> {
self.word(")");
self.print_fn_ret_ty(&data.output);
}
ast::GenericArgs::ParenthesizedElided(_) => {
self.word("(");
self.word("..");
self.word(")");
}
}
}
}

2
compiler/rustc_hir/src/hir.rs
View File

@ -2413,7 +2413,7 @@ pub enum ImplItemKind<'hir> {
/// * the `A: Bound` in `Trait<A: Bound>`
/// * the `RetTy` in `Trait(ArgTy, ArgTy) -> RetTy`
/// * the `C = { Ct }` in `Trait<C = { Ct }>` (feature `associated_const_equality`)
/// * the `f(): Bound` in `Trait<f(): Bound>` (feature `return_type_notation`)
/// * the `f(..): Bound` in `Trait<f(..): Bound>` (feature `return_type_notation`)
#[derive(Debug, Clone, Copy, HashStable_Generic)]
pub struct AssocItemConstraint<'hir> {
pub hir_id: HirId,

4
compiler/rustc_parse/messages.ftl
View File

@ -45,10 +45,6 @@ parse_bad_assoc_type_bounds = bounds on associated types do not belong here
parse_bad_item_kind = {$descr} is not supported in {$ctx}
.help = consider moving the {$descr} out to a nearby module scope
parse_bad_return_type_notation_dotdot =
return type notation uses `()` instead of `(..)` for elided arguments
.suggestion = remove the `..`
parse_bad_return_type_notation_output =
return type not allowed with return type notation
.suggestion = remove the return type

8
compiler/rustc_parse/src/errors.rs
View File

@ -2567,14 +2567,6 @@ pub(crate) struct BadReturnTypeNotationOutput {
pub span: Span,
}
#[derive(Diagnostic)]
#[diag(parse_bad_return_type_notation_dotdot)]
pub(crate) struct BadReturnTypeNotationDotDot {
#[primary_span]
#[suggestion(code = "", applicability = "maybe-incorrect")]
pub span: Span,
}
#[derive(Diagnostic)]
#[diag(parse_bad_assoc_type_bounds)]
pub(crate) struct BadAssocTypeBounds {

27
compiler/rustc_parse/src/parser/path.rs
View File

@ -353,18 +353,17 @@ impl<'a> Parser<'a> {
})?;
let span = lo.to(self.prev_token.span);
AngleBracketedArgs { args, span }.into()
} else if self.may_recover()
&& self.token.kind == token::OpenDelim(Delimiter::Parenthesis)
} else if self.token.kind == token::OpenDelim(Delimiter::Parenthesis)
// FIXME(return_type_notation): Could also recover `...` here.
&& self.look_ahead(1, |tok| tok.kind == token::DotDot)
{
self.bump();
self.dcx()
.emit_err(errors::BadReturnTypeNotationDotDot { span: self.token.span });
self.bump();
self.bump(); // (
self.bump(); // ..
self.expect(&token::CloseDelim(Delimiter::Parenthesis))?;
let span = lo.to(self.prev_token.span);
self.psess.gated_spans.gate(sym::return_type_notation, span);
if self.eat_noexpect(&token::RArrow) {
let lo = self.prev_token.span;
let ty = self.parse_ty()?;
@ -372,13 +371,7 @@ impl<'a> Parser<'a> {
.emit_err(errors::BadReturnTypeNotationOutput { span: lo.to(ty.span) });
}
ParenthesizedArgs {
span,
inputs: ThinVec::new(),
inputs_span: span,
output: ast::FnRetTy::Default(self.prev_token.span.shrink_to_hi()),
}
.into()
P(ast::GenericArgs::ParenthesizedElided(span))
} else {
// `(T, U) -> R`
@ -733,14 +726,6 @@ impl<'a> Parser<'a> {
let span = lo.to(self.prev_token.span);
if let AssocItemConstraintKind::Bound { .. } = kind
&& let Some(ast::GenericArgs::Parenthesized(args)) = &gen_args
&& args.inputs.is_empty()
&& let ast::FnRetTy::Default(..) = args.output
{
self.psess.gated_spans.gate(sym::return_type_notation, span);
}
let constraint =
AssocItemConstraint { id: ast::DUMMY_NODE_ID, ident, gen_args, kind, span };
Ok(Some(AngleBracketedArg::Constraint(constraint)))

2
compiler/rustc_passes/src/hir_stats.rs
View File

@ -695,7 +695,7 @@ impl<'v> ast_visit::Visitor<'v> for StatCollector<'v> {
fn visit_generic_args(&mut self, g: &'v ast::GenericArgs) {
record_variants!(
(self, g, g, Id::None, ast, GenericArgs, GenericArgs),
[AngleBracketed, Parenthesized]
[AngleBracketed, Parenthesized, ParenthesizedElided]
);
ast_visit::walk_generic_args(self, g)
}

1
compiler/rustc_resolve/src/late.rs
View File

@ -1221,6 +1221,7 @@ impl<'a: 'ast, 'ast, 'tcx> Visitor<'ast> for LateResolutionVisitor<'a, '_, 'ast,
}
}
}
GenericArgs::ParenthesizedElided(_) => {}
}
}
}

1
compiler/rustc_resolve/src/lib.rs
View File

@ -350,6 +350,7 @@ impl<'a> From<&'a ast::PathSegment> for Segment {
(args.span, found_lifetimes)
}
GenericArgs::Parenthesized(args) => (args.span, true),
GenericArgs::ParenthesizedElided(span) => (*span, true),
}
} else {
(DUMMY_SP, false)

2
src/librustdoc/clean/types.rs
View File

@ -2557,7 +2557,7 @@ pub(crate) struct ProcMacro {
/// * the `A: Bound` in `Trait<A: Bound>`
/// * the `RetTy` in `Trait(ArgTy, ArgTy) -> RetTy`
/// * the `C = { Ct }` in `Trait<C = { Ct }>` (feature `associated_const_equality`)
/// * the `f(): Bound` in `Trait<f(): Bound>` (feature `return_type_notation`)
/// * the `f(..): Bound` in `Trait<f(..): Bound>` (feature `return_type_notation`)
#[derive(Clone, PartialEq, Eq, Debug, Hash)]
pub(crate) struct AssocItemConstraint {
pub(crate) assoc: PathSegment,

2
tests/crashes/125249.rs
View File

@ -2,7 +2,7 @@
#![feature(return_position_impl_trait_in_trait, return_type_notation)]
trait IntFactory {
fn stream(&self) -> impl IntFactory<stream(): IntFactory<stream(): Send> + Send>;
fn stream(&self) -> impl IntFactory<stream(..): IntFactory<stream(..): Send> + Send>;
}
pub fn main() {}

4
tests/ui/associated-type-bounds/return-type-notation/bad-inputs-and-output.rs
View File

@ -13,7 +13,7 @@ fn foo<T: Trait<method(i32): Send>>() {}
fn bar<T: Trait<method() -> (): Send>>() {}
//~^ ERROR return type not allowed with return type notation
fn baz<T: Trait<method(..): Send>>() {}
//~^ ERROR return type notation uses `()` instead of `(..)` for elided arguments
fn baz<T: Trait<method(): Send>>() {}
//~^ ERROR return type notation arguments must be elided with `..`
fn main() {}

12
tests/ui/associated-type-bounds/return-type-notation/bad-inputs-and-output.stderr
View File

@ -1,9 +1,3 @@
error: return type notation uses `()` instead of `(..)` for elided arguments
--> $DIR/bad-inputs-and-output.rs:16:24
|
LL | fn baz<T: Trait<method(..): Send>>() {}
| ^^ help: remove the `..`
warning: the feature `return_type_notation` is incomplete and may not be safe to use and/or cause compiler crashes
--> $DIR/bad-inputs-and-output.rs:3:12
|
@ -25,5 +19,11 @@ error: return type not allowed with return type notation
LL | fn bar<T: Trait<method() -> (): Send>>() {}
| ^^^^^^ help: remove the return type
error: return type notation arguments must be elided with `..`
--> $DIR/bad-inputs-and-output.rs:16:23
|
LL | fn baz<T: Trait<method(): Send>>() {}
| ^^ help: add `..`: `(..)`
error: aborting due to 3 previous errors; 1 warning emitted

2
tests/ui/associated-type-bounds/return-type-notation/basic.rs
View File

@ -17,7 +17,7 @@ async fn foo<T: Foo>() -> Result<(), ()> {
fn is_send(_: impl Send) {}
fn test<
#[cfg(with)] T: Foo<method(): Send>,
#[cfg(with)] T: Foo<method(..): Send>,
#[cfg(without)] T: Foo,
>() {
is_send(foo::<T>());

2
tests/ui/associated-type-bounds/return-type-notation/equality.rs
View File

@ -9,7 +9,7 @@ trait Trait {
async fn method() {}
}
fn test<T: Trait<method() = Box<dyn Future<Output = ()>>>>() {}
fn test<T: Trait<method(..) = Box<dyn Future<Output = ()>>>>() {}
//~^ ERROR return type notation is not allowed to use type equality
fn main() {}

4
tests/ui/associated-type-bounds/return-type-notation/equality.stderr
View File

@ -10,8 +10,8 @@ LL | #![feature(return_type_notation)]
error: return type notation is not allowed to use type equality
--> $DIR/equality.rs:12:18
|
LL | fn test<T: Trait<method() = Box<dyn Future<Output = ()>>>>() {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
LL | fn test<T: Trait<method(..) = Box<dyn Future<Output = ()>>>>() {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: aborting due to 1 previous error; 1 warning emitted

2
tests/ui/associated-type-bounds/return-type-notation/issue-120208-higher-ranked-const.rs
View File

@ -9,7 +9,7 @@ trait HealthCheck {
async fn do_health_check_par<HC>(hc: HC)
where
HC: HealthCheck<check(): Send> + Send + 'static,
HC: HealthCheck<check(..): Send> + Send + 'static,
//~^ ERROR return type notation is not allowed for functions that have const parameters
{
}

4
tests/ui/associated-type-bounds/return-type-notation/issue-120208-higher-ranked-const.stderr
View File

@ -13,8 +13,8 @@ error: return type notation is not allowed for functions that have const paramet
LL | async fn check<const N: usize>() -> bool;
| -------------- const parameter declared here
...
LL | HC: HealthCheck<check(): Send> + Send + 'static,
| ^^^^^^^^^^^^^
LL | HC: HealthCheck<check(..): Send> + Send + 'static,
| ^^^^^^^^^^^^^^^
error: aborting due to 1 previous error; 1 warning emitted

2
tests/ui/associated-type-bounds/return-type-notation/missing.rs
View File

@ -7,7 +7,7 @@ trait Trait {
async fn method() {}
}
fn bar<T: Trait<methid(): Send>>() {}
fn bar<T: Trait<methid(..): Send>>() {}
//~^ ERROR associated function `methid` not found for `Trait`
fn main() {}

2
tests/ui/associated-type-bounds/return-type-notation/missing.stderr
View File

@ -10,7 +10,7 @@ LL | #![feature(return_type_notation)]
error[E0220]: associated function `methid` not found for `Trait`
--> $DIR/missing.rs:10:17
|
LL | fn bar<T: Trait<methid(): Send>>() {}
LL | fn bar<T: Trait<methid(..): Send>>() {}
| ^^^^^^ help: there is an associated function with a similar name: `method`
error: aborting due to 1 previous error; 1 warning emitted

2
tests/ui/associated-type-bounds/return-type-notation/non-rpitit.rs
View File

@ -5,7 +5,7 @@ trait Trait {
fn method() {}
}
fn test<T: Trait<method(): Send>>() {}
fn test<T: Trait<method(..): Send>>() {}
//~^ ERROR return type notation used on function that is not `async` and does not return `impl Trait`
fn main() {}

4
tests/ui/associated-type-bounds/return-type-notation/non-rpitit.stderr
View File

@ -13,8 +13,8 @@ error: return type notation used on function that is not `async` and does not re
LL | fn method() {}
| ----------- this function must be `async` or return `impl Trait`
...
LL | fn test<T: Trait<method(): Send>>() {}
| ^^^^^^^^^^^^^^
LL | fn test<T: Trait<method(..): Send>>() {}
| ^^^^^^^^^^^^^^^^
|
= note: function returns `()`, which is not compatible with associated type return bounds

2
tests/ui/async-await/return-type-notation/issue-110963-early.rs
View File

@ -9,7 +9,7 @@ trait HealthCheck {
async fn do_health_check_par<HC>(hc: HC)
where
HC: HealthCheck<check(): Send> + Send + 'static,
HC: HealthCheck<check(..): Send> + Send + 'static,
{
spawn(async move {
let mut hc = hc;

2
tests/ui/async-await/return-type-notation/issue-110963-late.rs
View File

@ -10,7 +10,7 @@ trait HealthCheck {
async fn do_health_check_par<HC>(hc: HC)
where
HC: HealthCheck<check(): Send> + Send + 'static,
HC: HealthCheck<check(..): Send> + Send + 'static,
{
spawn(async move {
let mut hc = hc;

2
tests/ui/async-await/return-type-notation/normalizing-self-auto-trait-issue-109924.rs
View File

@ -16,7 +16,7 @@ impl Foo for Bar {
async fn bar(&self) {}
}
fn build<T>(_: T) where T: Foo<bar(): Send> {}
fn build<T>(_: T) where T: Foo<bar(..): Send> {}
fn main() {
build(Bar);

2
tests/ui/async-await/return-type-notation/rtn-implied-in-supertrait.rs
View File

@ -16,7 +16,7 @@ trait Foo {
async fn bar(&self) -> i32;
}
trait SendFoo: Foo<bar(): Send> + Send {}
trait SendFoo: Foo<bar(..): Send> + Send {}
fn foobar(foo: impl SendFoo) -> JoinHandle<i32> {
spawn(async move {

2
tests/ui/async-await/return-type-notation/rtn-in-impl-signature.rs
View File

@ -7,7 +7,7 @@ trait Super1<'a> {
fn bar<'b>() -> bool;
}
impl Super1<'_, bar(): Send> for () {}
impl Super1<'_, bar(..): Send> for () {}
//~^ ERROR associated item constraints are not allowed here
//~| ERROR not all trait items implemented

12
tests/ui/async-await/return-type-notation/rtn-in-impl-signature.stderr
View File

@ -10,13 +10,13 @@ LL | #![feature(return_type_notation)]
error[E0229]: associated item constraints are not allowed here
--> $DIR/rtn-in-impl-signature.rs:10:17
|
LL | impl Super1<'_, bar(): Send> for () {}
| ^^^^^^^^^^^ associated item constraint not allowed here
LL | impl Super1<'_, bar(..): Send> for () {}
| ^^^^^^^^^^^^^ associated item constraint not allowed here
|
help: consider removing this associated item constraint
|
LL | impl Super1<'_, bar(): Send> for () {}
| ~~~~~~~~~~~~~
LL | impl Super1<'_, bar(..): Send> for () {}
| ~~~~~~~~~~~~~~~
error[E0046]: not all trait items implemented, missing: `bar`
--> $DIR/rtn-in-impl-signature.rs:10:1
@ -24,8 +24,8 @@ error[E0046]: not all trait items implemented, missing: `bar`
LL | fn bar<'b>() -> bool;
| --------------------- `bar` from trait
...
LL | impl Super1<'_, bar(): Send> for () {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ missing `bar` in implementation
LL | impl Super1<'_, bar(..): Send> for () {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ missing `bar` in implementation
error: aborting due to 2 previous errors; 1 warning emitted

2
tests/ui/async-await/return-type-notation/super-method-bound-ambig.rs
View File

@ -22,7 +22,7 @@ impl Foo for () {}
fn test<T>()
where
T: Foo<test(): Send>,
T: Foo<test(..): Send>,
//~^ ERROR ambiguous associated function `test` in bounds of `Foo`
{
}

4
tests/ui/async-await/return-type-notation/super-method-bound-ambig.stderr
View File

@ -16,8 +16,8 @@ LL | async fn test();
LL | async fn test();
| ---------------- ambiguous `test` from `Super2`
...
LL | T: Foo<test(): Send>,
| ^^^^^^^^^^^^ ambiguous associated function `test`
LL | T: Foo<test(..): Send>,
| ^^^^^^^^^^^^^^ ambiguous associated function `test`
error: aborting due to 1 previous error; 1 warning emitted

2
tests/ui/async-await/return-type-notation/super-method-bound.rs
View File

@ -16,7 +16,7 @@ impl Foo for () {}
fn test<T>()
where
T: Foo<test(): Send>,
T: Foo<test(..): Send>,
{
}

2
tests/ui/async-await/return-type-notation/supertrait-bound.rs
View File

@ -6,6 +6,6 @@
trait IntFactory {
fn stream(&self) -> impl Iterator<Item = i32>;
}
trait SendIntFactory: IntFactory<stream(): Send> + Send {}
trait SendIntFactory: IntFactory<stream(..): Send> + Send {}
fn main() {}

2
tests/ui/async-await/return-type-notation/ty-or-ct-params.rs
View File

@ -11,7 +11,7 @@ trait Foo {
fn test<T>()
where
T: Foo<bar(): Send, baz(): Send>,
T: Foo<bar(..): Send, baz(..): Send>,
//~^ ERROR return type notation is not allowed for functions that have const parameters
//~| ERROR return type notation is not allowed for functions that have type parameters
{

10
tests/ui/async-await/return-type-notation/ty-or-ct-params.stderr
View File

@ -13,17 +13,17 @@ error: return type notation is not allowed for functions that have type paramete
LL | async fn bar<T>() {}
| - type parameter declared here
...
LL | T: Foo<bar(): Send, baz(): Send>,
| ^^^^^^^^^^^
LL | T: Foo<bar(..): Send, baz(..): Send>,
| ^^^^^^^^^^^^^
error: return type notation is not allowed for functions that have const parameters
--> $DIR/ty-or-ct-params.rs:14:25
--> $DIR/ty-or-ct-params.rs:14:27
|
LL | async fn baz<const N: usize>() {}
| -------------- const parameter declared here
...
LL | T: Foo<bar(): Send, baz(): Send>,
| ^^^^^^^^^^^
LL | T: Foo<bar(..): Send, baz(..): Send>,
| ^^^^^^^^^^^^^
error: aborting due to 2 previous errors; 1 warning emitted

4
tests/ui/borrowck/alias-liveness/rtn-static.rs
View File

@ -7,7 +7,7 @@ trait Foo {
fn borrow(&mut self) -> impl Sized + '_;
}
fn live_past_borrow<T: Foo<borrow(): 'static>>(mut t: T) {
fn live_past_borrow<T: Foo<borrow(..): 'static>>(mut t: T) {
let x = t.borrow();
drop(t);
drop(x);
@ -15,7 +15,7 @@ fn live_past_borrow<T: Foo<borrow(): 'static>>(mut t: T) {
// Test that the `'_` item bound in `borrow` does not cause us to
// overlook the `'static` RTN bound.
fn overlapping_mut<T: Foo<borrow(): 'static>>(mut t: T) {
fn overlapping_mut<T: Foo<borrow(..): 'static>>(mut t: T) {
let x = t.borrow();
let x = t.borrow();
}

28
tests/ui/feature-gates/feature-gate-return_type_notation.cfg.stderr
View File

@ -1,33 +1,13 @@
error[E0658]: return type notation is experimental
--> $DIR/feature-gate-return_type_notation.rs:14:17
--> $DIR/feature-gate-return_type_notation.rs:10:18
|
LL | fn foo<T: Trait<m(): Send>>() {}
| ^^^^^^^^^
LL | fn foo<T: Trait<m(..): Send>>() {}
| ^^^^
|
= note: see issue #109417 <https://github.com/rust-lang/rust/issues/109417> for more information
= help: add `#![feature(return_type_notation)]` to the crate attributes to enable
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
error: parenthesized generic arguments cannot be used in associated type constraints
--> $DIR/feature-gate-return_type_notation.rs:14:17
|
LL | fn foo<T: Trait<m(): Send>>() {}
| ^--
| |
| help: remove these parentheses
error: expected type, found function
--> $DIR/feature-gate-return_type_notation.rs:14:17
|
LL | fn foo<T: Trait<m(): Send>>() {}
| ^ unexpected function
|
note: the associated function is defined here
--> $DIR/feature-gate-return_type_notation.rs:10:5
|
LL | async fn m();
| ^^^^^^^^^^^^^
error: aborting due to 3 previous errors
error: aborting due to 1 previous error
For more information about this error, try `rustc --explain E0658`.

13
tests/ui/feature-gates/feature-gate-return_type_notation.no.stderr
View File

@ -1,14 +1,13 @@
warning: return type notation is experimental
--> $DIR/feature-gate-return_type_notation.rs:14:17
error[E0658]: return type notation is experimental
--> $DIR/feature-gate-return_type_notation.rs:10:18
|
LL | fn foo<T: Trait<m(): Send>>() {}
| ^^^^^^^^^
LL | fn foo<T: Trait<m(..): Send>>() {}
| ^^^^
|
= note: see issue #109417 <https://github.com/rust-lang/rust/issues/109417> for more information
= help: add `#![feature(return_type_notation)]` to the crate attributes to enable
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
= warning: unstable syntax can change at any point in the future, causing a hard error!
= note: for more information, see issue #65860 <https://github.com/rust-lang/rust/issues/65860>
warning: 1 warning emitted
error: aborting due to 1 previous error
For more information about this error, try `rustc --explain E0658`.

12
tests/ui/feature-gates/feature-gate-return_type_notation.rs
View File

@ -1,21 +1,13 @@
//@ edition: 2021
//@ revisions: cfg no
//@ [no] check-pass
// Since we're not adding new syntax, `cfg`'d out RTN must pass.
trait Trait {
#[allow(async_fn_in_trait)]
async fn m();
}
#[cfg(cfg)]
fn foo<T: Trait<m(): Send>>() {}
//[cfg]~^ ERROR return type notation is experimental
//[cfg]~| ERROR parenthesized generic arguments cannot be used in associated type constraints
//[cfg]~| ERROR expected type, found function
//[no]~^^^^ WARN return type notation is experimental
//[no]~| WARN unstable syntax can change at any point in the future, causing a hard error!
fn foo<T: Trait<m(..): Send>>() {}
//~^ ERROR return type notation is experimental
fn main() {}