parametrisetheenvironment

Author: BoxyUwU

compiler/rustc_middle/src/ty/layout.rs

@@ -231,7 +231,7 @@ fn layout_raw<'tcx>(
             let layout = cx.layout_raw_uncached(ty);
             // Type-level uninhabitedness should always imply ABI uninhabitedness.
             if let Ok(layout) = layout {
-                if ty.conservative_is_privately_uninhabited(tcx) {
+                if ty.conservative_is_privately_uninhabited(tcx, param_env) {
                     assert!(layout.abi.is_uninhabited());
                 }
             }
@@ -583,7 +583,8 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> {
                 let size =
                     element.size.checked_mul(count, dl).ok_or(LayoutError::SizeOverflow(ty))?;
 
-                let abi = if count != 0 && ty.conservative_is_privately_uninhabited(tcx) {
+                let abi = if count != 0 && ty.conservative_is_privately_uninhabited(tcx, param_env)
+                {
                     Abi::Uninhabited
                 } else {
                     Abi::Aggregate { sized: true }

compiler/rustc_middle/src/ty/sty.rs

@@ -1691,44 +1691,61 @@ impl<'tcx> TyS<'tcx> {
     /// `ty.conservative_is_privately_uninhabited` implies that any value of type `ty`
     /// will be `Abi::Uninhabited`. (Note that uninhabited types may have nonzero
     /// size, to account for partial initialisation. See #49298 for details.)
-    pub fn conservative_is_privately_uninhabited(&self, tcx: TyCtxt<'tcx>) -> bool {
-        // FIXME(varkor): we can make this less conversative by substituting concrete
-        // type arguments.
+    #[instrument(level = "debug", skip(tcx))]
+    pub fn conservative_is_privately_uninhabited(
+        &self,
+        tcx: TyCtxt<'tcx>,
+        param_env: ty::ParamEnv<'tcx>,
+    ) -> bool {
         match self.kind() {
-            ty::Never => true,
+            ty::Never => {
+                debug!("ty::Never =>");
+                true
+            }
             ty::Adt(def, _) if def.is_union() => {
+                debug!("ty::Adt(def, _) if def.is_union() =>");
                 // For now, `union`s are never considered uninhabited.
                 false
             }
-            ty::Adt(def, _) => {
+            ty::Adt(def, substs) => {
+                debug!("ty::Adt(def, _) if def.is_not_union() =>");
                 // Any ADT is uninhabited if either:
                 // (a) It has no variants (i.e. an empty `enum`);
                 // (b) Each of its variants (a single one in the case of a `struct`) has at least
                 //     one uninhabited field.
                 def.variants.iter().all(|var| {
                     var.fields.iter().any(|field| {
-                        tcx.type_of(field.did).conservative_is_privately_uninhabited(tcx)
+                        tcx.type_of(field.did)
+                            .subst(tcx, substs)
+                            .conservative_is_privately_uninhabited(tcx, param_env)
                     })
                 })
             }
             ty::Tuple(..) => {
-                self.tuple_fields().any(|ty| ty.conservative_is_privately_uninhabited(tcx))
+                debug!("ty::Tuple(..) =>");
+                self.tuple_fields()
+                    .any(|ty| ty.conservative_is_privately_uninhabited(tcx, param_env))
             }
             ty::Array(ty, len) => {
-                match len.try_eval_usize(tcx, ParamEnv::empty()) {
+                debug!("ty::Array(ty, len) =>");
+                match len.try_eval_usize(tcx, param_env) {
                     Some(0) | None => false,
                     // If the array is definitely non-empty, it's uninhabited if
                     // the type of its elements is uninhabited.
-                    Some(1..) => ty.conservative_is_privately_uninhabited(tcx),
+                    Some(1..) => ty.conservative_is_privately_uninhabited(tcx, param_env),
                 }
             }
             ty::Ref(..) => {
+                debug!("ty::Ref(..) =>");
                 // References to uninitialised memory is valid for any type, including
                 // uninhabited types, in unsafe code, so we treat all references as
                 // inhabited.
                 false
             }
-            _ => false,
+            _ => {
+                debug!("_ =>");
+                false
+            }
         }
     }
 

compiler/rustc_mir/src/borrow_check/type_check/mod.rs

@@ -1730,7 +1730,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
                 }
             }
             None => {
-                if !sig.output().conservative_is_privately_uninhabited(self.tcx()) {
+                if !sig.output().conservative_is_privately_uninhabited(self.tcx(), self.param_env) {
                     span_mirbug!(self, term, "call to converging function {:?} w/o dest", sig);
                 }
             }

compiler/rustc_mir/src/transform/generator.rs

@@ -1007,9 +1007,9 @@ fn insert_panic_block<'tcx>(
     assert_block
 }
 
-fn can_return<'tcx>(tcx: TyCtxt<'tcx>, body: &Body<'tcx>) -> bool {
+fn can_return<'tcx>(tcx: TyCtxt<'tcx>, body: &Body<'tcx>, param_env: ty::ParamEnv<'tcx>) -> bool {
     // Returning from a function with an uninhabited return type is undefined behavior.
-    if body.return_ty().conservative_is_privately_uninhabited(tcx) {
+    if body.return_ty().conservative_is_privately_uninhabited(tcx, param_env) {
         return false;
     }
 
@@ -1320,7 +1320,7 @@ impl<'tcx> MirPass<'tcx> for StateTransform {
         // `storage_liveness` tells us which locals have live storage at suspension points
         let (remap, layout, storage_liveness) = compute_layout(liveness_info, body);
 
-        let can_return = can_return(tcx, body);
+        let can_return = can_return(tcx, body, tcx.param_env(body.source.def_id()));
 
         // Run the transformation which converts Places from Local to generator struct
         // accesses for locals in `remap`.

src/test/ui/const-generics/conservative_is_privately_uninhabited_uses_correct_param_env-1.rs

@@ -0,0 +1,27 @@
+// run-pass
+#![feature(const_generics, const_evaluatable_checked)]
+#![allow(incomplete_features)]
+
+// This tests that the `conservative_is_privately_uninhabited` fn doesn't cause
+// ices by trying to evaluate `T::ASSOC` with an incorrect `ParamEnv`
+
+trait Foo {
+    const ASSOC: usize = 1;
+}
+
+struct Iced<T: Foo>(T, [(); T::ASSOC])
+where
+    [(); T::ASSOC]: ;
+
+impl Foo for u32 {}
+
+fn foo<T: Foo>()
+where
+    [(); T::ASSOC]: ,
+{
+    let _iced: Iced<T> = return;
+}
+
+fn main() {
+    foo::<u32>();
+}

src/test/ui/const-generics/conservative_is_privately_uninhabited_uses_correct_param_env-2.rs

@@ -0,0 +1,20 @@
+// run-pass
+#![feature(const_generics, const_evaluatable_checked)]
+#![allow(incomplete_features)]
+
+// This tests that the `conservative_is_privately_uninhabited` fn doesn't cause
+// ices by trying to evaluate `T::ASSOC` with an incorrect `ParamEnv`
+
+trait Foo {
+    const ASSOC: usize = 1;
+}
+
+struct Iced<T: Foo>(T, [(); T::ASSOC])
+where
+    [(); T::ASSOC]: ;
+
+impl Foo for u32 {}
+
+fn main() {
+    let _iced: Iced<u32> = return;
+}