Restrict TAITs to argument and return types only and add an additional feature gate for the other cases

Author: oli-obk

compiler/rustc_feature/src/active.rs

@@ -524,6 +524,8 @@ declare_features! (
     (active, try_blocks, "1.29.0", Some(31436), None),
     /// Allows `impl Trait` to be used inside type aliases (RFC 2515).
     (active, type_alias_impl_trait, "1.38.0", Some(63063), None),
+    /// Allows functions with TAITs in their where bounds to register hidden types.
+    (active, type_alias_impl_trait_in_where_bounds, "CURRENT_RUSTC_VERSION", Some(63063), None),
     /// Allows the use of type ascription in expressions.
     (active, type_ascription, "1.6.0", Some(23416), None),
     /// Allows creation of instances of a struct by moving fields that have

compiler/rustc_hir_analysis/src/collect/type_of.rs

@@ -16,8 +16,9 @@ use rustc_middle::ty::{
     self, ImplTraitInTraitData, IsSuggestable, Ty, TyCtxt, TypeFoldable, TypeFolder,
     TypeSuperFoldable, TypeSuperVisitable, TypeVisitable, TypeVisitableExt, TypeVisitor,
 };
+use rustc_session::parse::feature_err;
 use rustc_span::symbol::Ident;
-use rustc_span::{Span, DUMMY_SP};
+use rustc_span::{sym, Span, DUMMY_SP};
 
 use super::ItemCtxt;
 use super::{bad_placeholder, is_suggestable_infer_ty};
@@ -639,7 +640,7 @@ fn find_opaque_ty_constraints_for_tait(tcx: TyCtxt<'_>, def_id: LocalDefId) -> T
             let concrete_opaque_types = &self.tcx.mir_borrowck(item_def_id).concrete_opaque_types;
             debug!(?concrete_opaque_types);
             if let Some(&concrete_type) = concrete_opaque_types.get(&self.def_id) {
-                if !may_define_opaque_type(self.tcx, item_def_id, self.def_id) {
+                if !may_define_opaque_type(self.tcx, item_def_id, self.def_id, concrete_type.span) {
                     self.tcx.sess.emit_err(OpaqueTypeConstrainedButNotInSig {
                         span: concrete_type.span,
                         item_span: self.tcx.def_span(item_def_id),
@@ -758,6 +759,7 @@ fn may_define_opaque_type<'tcx>(
     tcx: TyCtxt<'tcx>,
     def_id: LocalDefId,
     opaque_def_id: LocalDefId,
+    span: Span,
 ) -> bool {
     if tcx.is_descendant_of(opaque_def_id.to_def_id(), def_id.to_def_id()) {
         // If the opaque type is defined in the body of a function, that function
@@ -766,7 +768,7 @@ fn may_define_opaque_type<'tcx>(
     }
 
     if tcx.is_closure(def_id.to_def_id()) {
-        return may_define_opaque_type(tcx, tcx.local_parent(def_id), opaque_def_id);
+        return may_define_opaque_type(tcx, tcx.local_parent(def_id), opaque_def_id, span);
     }
 
     let param_env = tcx.param_env(def_id);
@@ -860,8 +862,25 @@ fn may_define_opaque_type<'tcx>(
         _ => false,
     };
     trace!(?tait_in_fn_sig);
-    tait_in_fn_sig
-        || has_tait(tcx.predicates_of(def_id.to_def_id()).predicates, opaque_def_id, tcx, param_env)
+    if tait_in_fn_sig {
+        return true;
+    }
+    let tait_in_where_bounds =
+        has_tait(tcx.predicates_of(def_id.to_def_id()).predicates, opaque_def_id, tcx, param_env);
+    if tcx.features().type_alias_impl_trait_in_where_bounds {
+        tait_in_where_bounds
+    } else {
+        if tait_in_where_bounds {
+            feature_err(
+                &tcx.sess.parse_sess,
+                sym::type_alias_impl_trait_in_where_bounds,
+                span,
+                "type alias impl trait is only usable in argument or return types",
+            )
+            .emit();
+        }
+        false
+    }
 }
 
 fn find_opaque_ty_constraints_for_rpit(
@@ -1072,8 +1091,6 @@ fn infer_placeholder_type<'a>(
 
 fn check_feature_inherent_assoc_ty(tcx: TyCtxt<'_>, span: Span) {
     if !tcx.features().inherent_associated_types {
-        use rustc_session::parse::feature_err;
-        use rustc_span::symbol::sym;
         feature_err(
             &tcx.sess.parse_sess,
             sym::inherent_associated_types,

compiler/rustc_span/src/symbol.rs

@@ -1509,6 +1509,7 @@ symbols! {
         ty,
         type_alias_enum_variants,
         type_alias_impl_trait,
+        type_alias_impl_trait_in_where_bounds,
         type_ascribe,
         type_ascription,
         type_changing_struct_update,

tests/codegen/sanitizer-cfi-emit-type-metadata-id-itanium-cxx-abi.rs

@@ -7,7 +7,13 @@
 #![allow(dead_code)]
 #![allow(incomplete_features)]
 #![allow(unused_must_use)]
-#![feature(adt_const_params, extern_types, inline_const, type_alias_impl_trait)]
+#![feature(
+    adt_const_params,
+    extern_types,
+    inline_const,
+    type_alias_impl_trait,
+    type_alias_impl_trait_in_where_bounds
+)]
 
 extern crate core;
 use core::ffi::c_void;

tests/ui/feature-gates/feature-gate-type_alias_impl_trait.rs

@@ -10,12 +10,8 @@ fn define() -> Bar {
     Bar(42)
 }
 
-type Foo2 = impl Debug;
-
-fn define2()
-where
-    Foo2: Debug,
-{
+fn define2() {
+    type Foo2 = impl Debug;
     let x = || -> Foo2 { 42 };
 }
 
@@ -24,19 +20,9 @@ type Foo3 = impl Debug;
 fn define3(x: Foo3) {
     let y: i32 = x;
 }
-fn define3_1()
-where
-    Foo3: Debug,
-{
-    define3(42)
-}
-
-type Foo4 = impl Debug;
 
-fn define4()
-where
-    Foo4: Debug,
-{
+fn define4() {
+    type Foo4 = impl Debug;
     let y: Foo4 = 42;
 }
 

tests/ui/feature-gates/feature-gate-type_alias_impl_trait_in_where_bounds.rs

@@ -0,0 +1,43 @@
+// ignore-compare-mode-chalk
+// check-pass
+#![feature(type_alias_impl_trait, type_alias_impl_trait_in_where_bounds)]
+use std::fmt::Debug;
+
+type Foo = impl Debug;
+
+struct Bar(Foo);
+fn define() -> Bar {
+    Bar(42)
+}
+
+type Foo2 = impl Debug;
+
+fn define2()
+where
+    Foo2: Debug,
+{
+    let x = || -> Foo2 { 42 };
+}
+
+type Foo3 = impl Debug;
+
+fn define3(x: Foo3) {
+    let y: i32 = x;
+}
+fn define3_1()
+where
+    Foo3: Debug,
+{
+    define3(42)
+}
+
+type Foo4 = impl Debug;
+
+fn define4()
+where
+    Foo4: Debug,
+{
+    let y: Foo4 = 42;
+}
+
+fn main() {}

tests/ui/impl-trait/deduce-signature-from-supertrait.rs

@@ -1,6 +1,6 @@
 // check-pass
 
-#![feature(type_alias_impl_trait)]
+#![feature(type_alias_impl_trait, type_alias_impl_trait_in_where_bounds)]
 
 trait SuperExpectation: Fn(i32) {}
 

tests/ui/type-alias-impl-trait/closure_args.rs

@@ -2,7 +2,7 @@
 
 // regression test for https://github.com/rust-lang/rust/issues/100800
 
-#![feature(type_alias_impl_trait)]
+#![feature(type_alias_impl_trait, type_alias_impl_trait_in_where_bounds)]
 
 trait Anything {}
 impl<T> Anything for T {}

tests/ui/type-alias-impl-trait/closure_args2.rs

@@ -1,6 +1,6 @@
 // run-pass
 
-#![feature(type_alias_impl_trait)]
+#![feature(type_alias_impl_trait, type_alias_impl_trait_in_where_bounds)]
 
 trait Foo {
     // This was reachable in https://github.com/rust-lang/rust/issues/100800

tests/ui/type-alias-impl-trait/generic_type_does_not_live_long_enough.rs

@@ -1,4 +1,4 @@
-#![feature(type_alias_impl_trait)]
+#![feature(type_alias_impl_trait, type_alias_impl_trait_in_where_bounds)]
 
 fn foo()
 where

tests/ui/type-alias-impl-trait/issue-65679-inst-opaque-ty-from-val-twice.rs

@@ -1,6 +1,6 @@
 // check-pass
 
-#![feature(type_alias_impl_trait, rustc_attrs)]
+#![feature(type_alias_impl_trait, rustc_attrs, type_alias_impl_trait_in_where_bounds)]
 
 type T = impl Sized;
 // The concrete type referred by impl-trait-type-alias(`T`) is guaranteed

tests/ui/type-alias-impl-trait/type_of_a_let.rs

@@ -1,4 +1,4 @@
-#![feature(type_alias_impl_trait)]
+#![feature(type_alias_impl_trait, type_alias_impl_trait_in_where_bounds)]
 #![allow(dead_code)]
 
 use std::fmt::Debug;