Stabilize RTN

Author: compiler-errors

compiler/rustc_ast_lowering/src/lib.rs

@@ -954,17 +954,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                                 }
                             }
                         };
-                        let mut err = self.dcx().create_err(err);
-                        if !self.tcx.features().return_type_notation()
-                            && self.tcx.sess.is_nightly_build()
-                        {
-                            add_feature_diagnostics(
-                                &mut err,
-                                &self.tcx.sess,
-                                sym::return_type_notation,
-                            );
-                        }
-                        err.emit();
+                        self.dcx().emit_err(err);
                         GenericArgsCtor {
                             args: Default::default(),
                             constraints: &[],

compiler/rustc_ast_lowering/src/path.rs

@@ -6,7 +6,6 @@ use rustc_hir::GenericArg;
 use rustc_hir::def::{DefKind, PartialRes, Res};
 use rustc_hir::def_id::DefId;
 use rustc_middle::span_bug;
-use rustc_session::parse::add_feature_diagnostics;
 use rustc_span::{BytePos, DUMMY_SP, DesugaringKind, Ident, Span, Symbol, kw, sym};
 use smallvec::{SmallVec, smallvec};
 use tracing::{debug, instrument};
@@ -287,17 +286,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                                 }
                             }
                         };
-                        let mut err = self.dcx().create_err(err);
-                        if !self.tcx.features().return_type_notation()
-                            && self.tcx.sess.is_nightly_build()
-                        {
-                            add_feature_diagnostics(
-                                &mut err,
-                                &self.tcx.sess,
-                                sym::return_type_notation,
-                            );
-                        }
-                        err.emit();
+                        self.dcx().emit_err(err);
                         (
                             GenericArgsCtor {
                                 args: Default::default(),

compiler/rustc_ast_passes/src/feature_gate.rs

@@ -498,7 +498,6 @@ pub fn check_crate(krate: &ast::Crate, sess: &Session, features: &Features) {
     gate_all!(postfix_match, "postfix match is experimental");
     gate_all!(mut_ref, "mutable by-reference bindings are experimental");
     gate_all!(global_registration, "global registration is experimental");
-    gate_all!(return_type_notation, "return type notation is experimental");
     gate_all!(pin_ergonomics, "pinned reference syntax is experimental");
     gate_all!(unsafe_fields, "`unsafe` fields are experimental");
     gate_all!(unsafe_binders, "unsafe binder types are experimental");

compiler/rustc_feature/src/accepted.rs

@@ -364,6 +364,8 @@ declare_features! (
     (accepted, result_ffi_guarantees, "1.84.0", Some(110503)),
     /// Allows return-position `impl Trait` in traits.
     (accepted, return_position_impl_trait_in_trait, "1.75.0", Some(91611)),
+    /// Allows bounding the return type of AFIT/RPITIT.
+    (accepted, return_type_notation, "CURRENT_RUSTC_VERSION", Some(109417)),
     /// Allows code like `let x: &'static u32 = &42` to work (RFC 1414).
     (accepted, rvalue_static_promotion, "1.21.0", Some(38865)),
     /// Allows `Self` in type definitions (RFC 2300).

compiler/rustc_feature/src/unstable.rs

@@ -616,8 +616,6 @@ declare_features! (
     (incomplete, repr128, "1.16.0", Some(56071)),
     /// Allows `repr(simd)` and importing the various simd intrinsics.
     (unstable, repr_simd, "1.4.0", Some(27731)),
-    /// Allows bounding the return type of AFIT/RPITIT.
-    (unstable, return_type_notation, "1.70.0", Some(109417)),
     /// Allows `extern "rust-cold"`.
     (unstable, rust_cold_cc, "1.63.0", Some(97544)),
     /// Allows use of x86 SHA512, SM3 and SM4 target-features and intrinsics

compiler/rustc_hir_analysis/src/check/mod.rs

@@ -475,7 +475,11 @@ fn fn_sig_suggestion<'tcx>(
         ""
     };
 
-    let output = if !output.is_unit() { format!(" -> {output}") } else { String::new() };
+    let output = if !output.is_unit() {
+        with_types_for_signature!(format!(" -> {output}"))
+    } else {
+        String::new()
+    };
 
     let safety = sig.safety.prefix_str();
     let (generics, where_clauses) = bounds_from_generic_predicates(tcx, predicates);

compiler/rustc_lint/src/async_fn_in_trait.rs

@@ -95,7 +95,8 @@ impl<'tcx> LateLintPass<'tcx> for AsyncFnInTrait {
             && let hir::IsAsync::Async(async_span) = sig.header.asyncness
         {
             // RTN can be used to bound `async fn` in traits in a better way than "always"
-            if cx.tcx.features().return_type_notation() {
+            // TODO:
+            if true {
                 return;
             }
 

compiler/rustc_middle/src/ty/print/pretty.rs

@@ -1339,15 +1339,17 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
         def_id: DefId,
         args: ty::GenericArgsRef<'tcx>,
     ) -> Result<(), PrintError> {
-        let fn_args = if self.tcx().features().return_type_notation()
-            && let Some(ty::ImplTraitInTraitData::Trait { fn_def_id, .. }) =
-                self.tcx().opt_rpitit_info(def_id)
+        let fn_args = if let Some(ty::ImplTraitInTraitData::Trait { fn_def_id, .. }) =
+            self.tcx().opt_rpitit_info(def_id)
             && let ty::Alias(_, alias_ty) =
                 self.tcx().fn_sig(fn_def_id).skip_binder().output().skip_binder().kind()
             && alias_ty.def_id == def_id
             && let generics = self.tcx().generics_of(fn_def_id)
             // FIXME(return_type_notation): We only support lifetime params for now.
-            && generics.own_params.iter().all(|param| matches!(param.kind, ty::GenericParamDefKind::Lifetime))
+            && generics
+                .own_params
+                .iter()
+                .all(|param| matches!(param.kind, ty::GenericParamDefKind::Lifetime))
         {
             let num_args = generics.count();
             Some((fn_def_id, &args[..num_args]))

compiler/rustc_parse/src/parser/path.rs

@@ -377,8 +377,6 @@ impl<'a> Parser<'a> {
                     self.expect(exp!(CloseParen))?;
                     let span = lo.to(self.prev_token.span);
 
-                    self.psess.gated_spans.gate(sym::return_type_notation, span);
-
                     let prev_lo = self.prev_token.span.shrink_to_hi();
                     if self.eat_noexpect(&token::RArrow) {
                         let lo = self.prev_token.span;

compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs

@@ -524,7 +524,6 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                         }
 
                         self.explain_hrtb_projection(&mut err, leaf_trait_predicate, obligation.param_env, &obligation.cause);
-                        self.suggest_desugaring_async_fn_in_trait(&mut err, main_trait_predicate);
 
                         // Return early if the trait is Debug or Display and the invocation
                         // originates within a standard library macro, because the output

compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs

@@ -137,9 +137,7 @@ pub fn suggest_restriction<'tcx, G: EmissionGuarantee>(
     if hir_generics.where_clause_span.from_expansion()
         || hir_generics.where_clause_span.desugaring_kind().is_some()
         || projection.is_some_and(|projection| {
-            (tcx.is_impl_trait_in_trait(projection.def_id)
-                && !tcx.features().return_type_notation())
-                || tcx.lookup_stability(projection.def_id).is_some_and(|stab| stab.is_unstable())
+            tcx.lookup_stability(projection.def_id).is_some_and(|stab| stab.is_unstable())
         })
     {
         return;
@@ -4565,90 +4563,6 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
         }
     }
 
-    pub(super) fn suggest_desugaring_async_fn_in_trait(
-        &self,
-        err: &mut Diag<'_>,
-        trait_pred: ty::PolyTraitPredicate<'tcx>,
-    ) {
-        // Don't suggest if RTN is active -- we should prefer a where-clause bound instead.
-        if self.tcx.features().return_type_notation() {
-            return;
-        }
-
-        let trait_def_id = trait_pred.def_id();
-
-        // Only suggest specifying auto traits
-        if !self.tcx.trait_is_auto(trait_def_id) {
-            return;
-        }
-
-        // Look for an RPITIT
-        let ty::Alias(ty::Projection, alias_ty) = trait_pred.self_ty().skip_binder().kind() else {
-            return;
-        };
-        let Some(ty::ImplTraitInTraitData::Trait { fn_def_id, opaque_def_id }) =
-            self.tcx.opt_rpitit_info(alias_ty.def_id)
-        else {
-            return;
-        };
-
-        let auto_trait = self.tcx.def_path_str(trait_def_id);
-        // ... which is a local function
-        let Some(fn_def_id) = fn_def_id.as_local() else {
-            // If it's not local, we can at least mention that the method is async, if it is.
-            if self.tcx.asyncness(fn_def_id).is_async() {
-                err.span_note(
-                    self.tcx.def_span(fn_def_id),
-                    format!(
-                        "`{}::{}` is an `async fn` in trait, which does not \
-                    automatically imply that its future is `{auto_trait}`",
-                        alias_ty.trait_ref(self.tcx),
-                        self.tcx.item_name(fn_def_id)
-                    ),
-                );
-            }
-            return;
-        };
-        let hir::Node::TraitItem(item) = self.tcx.hir_node_by_def_id(fn_def_id) else {
-            return;
-        };
-
-        // ... whose signature is `async` (i.e. this is an AFIT)
-        let (sig, body) = item.expect_fn();
-        let hir::FnRetTy::Return(hir::Ty { kind: hir::TyKind::OpaqueDef(opaq_def, ..), .. }) =
-            sig.decl.output
-        else {
-            // This should never happen, but let's not ICE.
-            return;
-        };
-
-        // Check that this is *not* a nested `impl Future` RPIT in an async fn
-        // (i.e. `async fn foo() -> impl Future`)
-        if opaq_def.def_id.to_def_id() != opaque_def_id {
-            return;
-        }
-
-        let Some(sugg) = suggest_desugaring_async_fn_to_impl_future_in_trait(
-            self.tcx,
-            *sig,
-            *body,
-            opaque_def_id.expect_local(),
-            &format!(" + {auto_trait}"),
-        ) else {
-            return;
-        };
-
-        let function_name = self.tcx.def_path_str(fn_def_id);
-        err.multipart_suggestion(
-            format!(
-                "`{auto_trait}` can be made part of the associated future's \
-                guarantees for all implementations of `{function_name}`"
-            ),
-            sugg,
-            Applicability::MachineApplicable,
-        );
-    }
-
     pub fn ty_kind_suggestion(
         &self,
         param_env: ty::ParamEnv<'tcx>,

tests/ui/associated-type-bounds/all-generics-lookup.rs

@@ -1,7 +1,5 @@
 //@ check-pass
 
-#![feature(return_type_notation)]
-
 trait Trait {
     fn method(&self) -> impl Sized;
 }

tests/ui/associated-type-bounds/implied-from-self-where-clause.rs

@@ -3,8 +3,6 @@
 
 //@ check-pass
 
-#![feature(return_type_notation)]
-
 trait Foo
 where
     Self::method(..): Send,

tests/ui/associated-type-bounds/return-type-notation/bad-inputs-and-output.fixed

@@ -1,6 +1,6 @@
 //@ edition: 2021
 //@ run-rustfix
-#![feature(return_type_notation)]
+
 #![allow(dead_code)]
 
 trait Trait {

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

@@ -1,6 +1,6 @@
 //@ edition: 2021
 //@ run-rustfix
-#![feature(return_type_notation)]
+
 #![allow(dead_code)]
 
 trait Trait {

tests/ui/associated-type-bounds/return-type-notation/bare-path.rs

@@ -1,5 +1,3 @@
-#![feature(return_type_notation)]
-
 trait Tr {
     const CONST: usize;
 

tests/ui/associated-type-bounds/return-type-notation/bare-path.stderr

@@ -1,11 +1,11 @@
 error: return type notation not allowed in this position yet
-  --> $DIR/bare-path.rs:14:23
+  --> $DIR/bare-path.rs:12:23
    |
 LL |     let _ = T::CONST::(..);
    |                       ^^^^
 
 error: return type notation not allowed in this position yet
-  --> $DIR/bare-path.rs:16:12
+  --> $DIR/bare-path.rs:14:12
    |
 LL |     let _: T::method(..);
    |            ^^^^^^^^^^^^^

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

@@ -2,8 +2,6 @@
 //@ edition: 2021
 //@ [with] check-pass
 
-#![feature(return_type_notation)]
-
 trait Foo {
     async fn method() -> Result<(), ()>;
 }

tests/ui/associated-type-bounds/return-type-notation/basic.without.stderr

@@ -1,17 +1,17 @@
 error: future cannot be sent between threads safely
-  --> $DIR/basic.rs:22:13
+  --> $DIR/basic.rs:20:13
    |
 LL |     is_send(foo::<T>());
    |             ^^^^^^^^^^ future returned by `foo` is not `Send`
    |
    = help: within `impl Future<Output = Result<(), ()>>`, the trait `Send` is not implemented for `impl Future<Output = Result<(), ()>> { <T as Foo>::method(..) }`
 note: future is not `Send` as it awaits another future which is not `Send`
-  --> $DIR/basic.rs:12:5
+  --> $DIR/basic.rs:10:5
    |
 LL |     T::method().await?;
    |     ^^^^^^^^^^^ await occurs here on type `impl Future<Output = Result<(), ()>> { <T as Foo>::method(..) }`, which is not `Send`
 note: required by a bound in `is_send`
-  --> $DIR/basic.rs:16:20
+  --> $DIR/basic.rs:14:20
    |
 LL | fn is_send(_: impl Send) {}
    |                    ^^^^ required by this bound in `is_send`

tests/ui/associated-type-bounds/return-type-notation/display.rs

@@ -1,5 +1,3 @@
-#![feature(return_type_notation)]
-
 trait Trait {}
 fn needs_trait(_: impl Trait) {}