Added feature gate.

Author: Alexander Regueiro

src/librustc_feature/active.rs

@@ -497,7 +497,7 @@ declare_features! (
     /// Allows the use of raw-dylibs (RFC 2627).
     (active, raw_dylib, "1.40.0", Some(58713), None),
 
-    /// Allows `#[track_caller]` to be used which provides
+    /// Allows `#[track_caller]` to be used, which provides
     /// accurate caller location reporting during panic (RFC 2091).
     (active, track_caller, "1.40.0", Some(47809), None),
 
@@ -524,7 +524,7 @@ declare_features! (
     /// Allows the use of `if` and `match` in constants.
     (active, const_if_match, "1.41.0", Some(49146), None),
 
-    /// Allows the use of `#[cfg(sanitize = "option")]`; set when -Zsanitizer is used.
+    /// Allows the use of `#[cfg(sanitize = "option")]`; set when `-Zsanitizer` is used.
     (active, cfg_sanitize, "1.41.0", Some(39699), None),
 
     /// Allows using `..X`, `..=X`, `...X`, and `X..` as a pattern.
@@ -553,10 +553,10 @@ declare_features! (
     /// Allows the use of `no_sanitize` attribute.
     (active, no_sanitize, "1.42.0", Some(39699), None),
 
-    // Allows limiting the evaluation steps of const expressions
+    /// Allows limiting the evaluation steps of const expressions.
     (active, const_eval_limit, "1.43.0", Some(67217), None),
 
-    /// Allow negative trait implementations.
+    /// Allows negative trait implementations.
     (active, negative_impls, "1.44.0", Some(68318), None),
 
     /// Allows the use of `#[target_feature]` on safe functions.
@@ -565,6 +565,10 @@ declare_features! (
     /// Allow conditional compilation depending on rust version
     (active, cfg_version, "1.45.0", Some(64796), None),
 
+    /// Allows upcasting trait objects via supertraits.
+    /// Trait upcasting is casting, e.g., `dyn Foo -> dyn Bar` where `Foo: Bar`.
+    (active, trait_upcasting, "1.45.0", Some(65991), None),
+
     // -------------------------------------------------------------------------
     // feature-group-end: actual feature gates
     // -------------------------------------------------------------------------

src/librustc_infer/infer/error_reporting/mod.rs

@@ -1686,7 +1686,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
         let trait_ref = Binder::bind(TraitRef::identity(self.tcx, exp_found.found));
         let supertraits = crate::traits::supertraits(self.tcx, trait_ref);
         if supertraits.into_iter().any(|trait_ref| trait_ref.def_id() == exp_found.expected) {
-            diag.note("enable the `trait_upcasting` feature to permit upcasting of trait objects");
+            diag.note("add `#![feature(trait_upcasting)]` to the crate attributes to enable");
         }
     }
 

src/librustc_span/symbol.rs

@@ -751,6 +751,7 @@ symbols! {
         transparent,
         transparent_enums,
         transparent_unions,
+        trait_upcasting,
         trivial_bounds,
         Try,
         try_blocks,

src/librustc_trait_selection/traits/select.rs

@@ -2956,52 +2956,51 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 });
                 let source_ty = tcx.mk_dynamic(existential_predicates, region_b);
 
-                /*
-                // Require that the traits involved in this upcast are **equal**;
-                // only the **lifetime bound** is changed.
-                //
-                // FIXME: This condition is arguably too strong -- it would
-                // suffice for the source trait to be a *subtype* of the target
-                // trait. In particular, changing from something like
-                // `for<'a, 'b> Foo<'a, 'b>` to `for<'a> Foo<'a, 'a>` should be
-                // permitted. And, indeed, in the in commit
-                // 904a0bde93f0348f69914ee90b1f8b6e4e0d7cbc, this
-                // condition was loosened. However, when the leak check was
-                // added back, using subtype here actually guides the coercion
-                // code in such a way that it accepts `old-lub-glb-object.rs`.
-                // This is probably a good thing, but I've modified this to `.eq`
-                // because I want to continue rejecting that test (as we have
-                // done for quite some time) before we are firmly comfortable
-                // with what our behavior should be there. -nikomatsakis
-                let InferOk { obligations, .. } = self
-                    .infcx
-                    .at(&obligation.cause, obligation.param_env)
-                    .eq(target, source_ty) // FIXME -- see above
-                    .map_err(|_| Unimplemented)?;
-                nested.extend(obligations);
-                */
-
-                // Register obligations for `dyn TraitA1 [TraitA2...]: TraitB1 [TraitB2...]`.
-                nested.extend(
-                    data_b.iter()
-                        // HACK(alexreg | nikomatsakis): we handle auto traits specially here
-                        // because of cases like like `dyn Foo + Send + 'a` ->
-                        // `dyn Foo + Send + 'b`, which requires proving the obligation
-                        // `dyn Foo + Send: Send`. This is unfortunately ambiguous under the
-                        // current trait solver model: it holds both because `Send` is a supertrait
-                        // of `Foo + Send` and because there's an automatic impl of `Send` for the
-                        // trait object.
-                        .filter(|predicate| {
-                            match predicate.skip_binder() {
-                                ty::ExistentialPredicate::AutoTrait(did) =>
-                                    !data_a.auto_traits().any(|did_a| did_a == *did),
-                                _ => true,
-                            }
-                        })
-                        .map(|predicate|
-                            predicate_to_obligation(predicate.with_self_ty(tcx, source_ty))
-                        ),
-                );
+                if tcx.features().trait_upcasting {
+                    // Register obligations for `dyn TraitA1 [TraitA2...]: TraitB1 [TraitB2...]`.
+                    nested.extend(
+                        data_b.iter()
+                            // HACK(alexreg | nikomatsakis): we handle auto traits specially here
+                            // because of cases like like `dyn Foo + Send + 'a` ->
+                            // `dyn Foo + Send + 'b`, which requires proving the obligation
+                            // `dyn Foo + Send: Send`. This is unfortunately ambiguous under the
+                            // current trait solver model: it holds both because `Send` is a
+                            // supertrait of `Foo + Send` and because there's an automatic impl of
+                            // `Send` for the trait object.
+                            .filter(|predicate| {
+                                match predicate.skip_binder() {
+                                    ty::ExistentialPredicate::AutoTrait(did) =>
+                                        !data_a.auto_traits().any(|did_a| did_a == *did),
+                                    _ => true,
+                                }
+                            })
+                            .map(|predicate|
+                                predicate_to_obligation(predicate.with_self_ty(tcx, source_ty))
+                            ),
+                    );
+                } else {
+                    // Require that the traits involved in this upcast are **equal**;
+                    // only the **lifetime bound** is changed.
+                    //
+                    // FIXME: This condition is arguably too strong -- it would
+                    // suffice for the source trait to be a *subtype* of the target
+                    // trait. In particular, changing from something like
+                    // `for<'a, 'b> Foo<'a, 'b>` to `for<'a> Foo<'a, 'a>` should be
+                    // permitted. And, indeed, in the in commit
+                    // 904a0bde93f0348f69914ee90b1f8b6e4e0d7cbc, this
+                    // condition was loosened. However, when the leak check was
+                    // added back, using subtype here actually guides the coercion
+                    // code in such a way that it accepts `old-lub-glb-object.rs`.
+                    // This is probably a good thing, but I've modified this to `.eq`
+                    // because I want to continue rejecting that test (as we have
+                    // done for quite some time) before we are firmly comfortable
+                    // with what our behavior should be there. -nikomatsakis
+                    let InferOk { obligations, .. } = self.infcx
+                        .at(&obligation.cause, obligation.param_env)
+                        .eq(target, source_ty) // FIXME: see above.
+                        .map_err(|_| Unimplemented)?;
+                    nested.extend(obligations);
+                }
 
                 // Register an obligation for `'a: 'b`.
                 let outlives = ty::OutlivesPredicate(region_a, region_b);

src/test/ui/feature-gates/feature-gate-trait_upcasting.rs

@@ -0,0 +1,16 @@
+trait Foo {}
+
+trait Bar: Foo {}
+
+impl Foo for () {}
+
+impl Bar for () {}
+
+fn main() {
+    let bar: &dyn Bar = &();
+    let foo: &dyn Foo = bar;
+    //~^ ERROR mismatched types [E0308]
+    //~| NOTE expected type `&dyn Foo`
+    //~| NOTE expected trait `Foo`, found trait `Bar`
+    //~| NOTE add `#![feature(trait_upcasting)]` to the crate attributes to enable
+}

src/test/ui/feature-gates/feature-gate-trait_upcasting.stderr

@@ -0,0 +1,13 @@
+error[E0308]: mismatched types
+  --> $DIR/feature-gate-trait_upcasting.rs:11:25
+   |
+LL |     let foo: &dyn Foo = bar;
+   |                         ^^^ expected trait `Foo`, found trait `Bar`
+   |
+   = note: add `#![feature(trait_upcasting)]` to the crate attributes to enable
+   = note: expected type `&dyn Foo`
+              found type `&dyn Bar`
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0308`.