thir building: use typing_env directly

lcnr · lcnr · commit 743ce3b4e19e · 2024-11-22T12:01:29.000+01:00
diff --git a/compiler/rustc_mir_build/src/thir/cx/expr.rs b/compiler/rustc_mir_build/src/thir/cx/expr.rs
@@ -237,88 +237,88 @@ impl<'tcx> Cx<'tcx> {
     ///
     /// Dealing with user type annotations is left to the caller.
     fn mirror_expr_cast(
-        &mut self,
-        source: &'tcx hir::Expr<'tcx>,
-        temp_lifetime: TempLifetime,
-        span: Span,
-    ) -> ExprKind<'tcx> {
-        let tcx = self.tcx;
-
-        // Check to see if this cast is a "coercion cast", where the cast is actually done
-        // using a coercion (or is a no-op).
-        if self.typeck_results().is_coercion_cast(source.hir_id) {
-            // Convert the lexpr to a vexpr.
-            ExprKind::Use { source: self.mirror_expr(source) }
-        } else if self.typeck_results().expr_ty(source).is_ref() {
-            // Special cased so that we can type check that the element
-            // type of the source matches the pointed to type of the
-            // destination.
-            ExprKind::PointerCoercion {
-                source: self.mirror_expr(source),
-                cast: PointerCoercion::ArrayToPointer,
-                is_from_as_cast: true,
-            }
-        } else if let hir::ExprKind::Path(ref qpath) = source.kind
-            && let res = self.typeck_results().qpath_res(qpath, source.hir_id)
-            && let ty = self.typeck_results().node_type(source.hir_id)
-            && let ty::Adt(adt_def, args) = ty.kind()
-            && let Res::Def(DefKind::Ctor(CtorOf::Variant, CtorKind::Const), variant_ctor_id) = res
-        {
-            // Check whether this is casting an enum variant discriminant.
-            // To prevent cycles, we refer to the discriminant initializer,
-            // which is always an integer and thus doesn't need to know the
-            // enum's layout (or its tag type) to compute it during const eval.
-            // Example:
-            // enum Foo {
-            //     A,
-            //     B = A as isize + 4,
-            // }
-            // The correct solution would be to add symbolic computations to miri,
-            // so we wouldn't have to compute and store the actual value
-
-            let idx = adt_def.variant_index_with_ctor_id(variant_ctor_id);
-            let (discr_did, discr_offset) = adt_def.discriminant_def_for_variant(idx);
-
-            use rustc_middle::ty::util::IntTypeExt;
-            let ty = adt_def.repr().discr_type();
-            let discr_ty = ty.to_ty(tcx);
-
-            let size = tcx
-                .layout_of(self.typing_env().as_query_input(discr_ty))
-                .unwrap_or_else(|e| panic!("could not compute layout for {discr_ty:?}: {e:?}"))
-                .size;
-
-            let (lit, overflowing) = ScalarInt::truncate_from_uint(discr_offset as u128, size);
-            if overflowing {
-                // An erroneous enum with too many variants for its repr will emit E0081 and E0370
-                self.tcx.dcx().span_delayed_bug(
-                    source.span,
-                    "overflowing enum wasn't rejected by hir analysis",
-                );
+    &mut self,
+    source: &'tcx hir::Expr<'tcx>,
+    temp_lifetime: TempLifetime,
+    span: Span,
+) -> ExprKind<'tcx> {
+    let tcx = self.tcx;
+
+    // Check to see if this cast is a "coercion cast", where the cast is actually done
+    // using a coercion (or is a no-op).
+    if self.typeck_results().is_coercion_cast(source.hir_id) {
+        // Convert the lexpr to a vexpr.
+        ExprKind::Use { source: self.mirror_expr(source) }
+    } else if self.typeck_results().expr_ty(source).is_ref() {
+        // Special cased so that we can type check that the element
+        // type of the source matches the pointed to type of the
+        // destination.
+        ExprKind::PointerCoercion {
+            source: self.mirror_expr(source),
+            cast: PointerCoercion::ArrayToPointer,
+            is_from_as_cast: true,
+        }
+    } else if let hir::ExprKind::Path(ref qpath) = source.kind
+        && let res = self.typeck_results().qpath_res(qpath, source.hir_id)
+        && let ty = self.typeck_results().node_type(source.hir_id)
+        && let ty::Adt(adt_def, args) = ty.kind()
+        && let Res::Def(DefKind::Ctor(CtorOf::Variant, CtorKind::Const), variant_ctor_id) = res
+    {
+        // Check whether this is casting an enum variant discriminant.
+        // To prevent cycles, we refer to the discriminant initializer,
+        // which is always an integer and thus doesn't need to know the
+        // enum's layout (or its tag type) to compute it during const eval.
+        // Example:
+        // enum Foo {
+        //     A,
+        //     B = A as isize + 4,
+        // }
+        // The correct solution would be to add symbolic computations to miri,
+        // so we wouldn't have to compute and store the actual value
+
+        let idx = adt_def.variant_index_with_ctor_id(variant_ctor_id);
+        let (discr_did, discr_offset) = adt_def.discriminant_def_for_variant(idx);
+
+        use rustc_middle::ty::util::IntTypeExt;
+        let ty = adt_def.repr().discr_type();
+        let discr_ty = ty.to_ty(tcx);
+
+        let size = tcx
+            .layout_of(self.typing_env.as_query_input(discr_ty))
+            .unwrap_or_else(|e| panic!("could not compute layout for {discr_ty:?}: {e:?}"))
+            .size;
+
+        let (lit, overflowing) = ScalarInt::truncate_from_uint(discr_offset as u128, size);
+        if overflowing {
+            // An erroneous enum with too many variants for its repr will emit E0081 and E0370
+            self.tcx.dcx().span_delayed_bug(
+                source.span,
+                "overflowing enum wasn't rejected by hir analysis",
+            );
+        }
+        let kind = ExprKind::NonHirLiteral { lit, user_ty: None };
+        let offset = self.thir.exprs.push(Expr { temp_lifetime, ty: discr_ty, span, kind });
+
+        let source = match discr_did {
+            // in case we are offsetting from a computed discriminant
+            // and not the beginning of discriminants (which is always `0`)
+            Some(did) => {
+                let kind = ExprKind::NamedConst { def_id: did, args, user_ty: None };
+                let lhs =
+                    self.thir.exprs.push(Expr { temp_lifetime, ty: discr_ty, span, kind });
+                let bin = ExprKind::Binary { op: BinOp::Add, lhs, rhs: offset };
+                self.thir.exprs.push(Expr { temp_lifetime, ty: discr_ty, span, kind: bin })
             }
-            let kind = ExprKind::NonHirLiteral { lit, user_ty: None };
-            let offset = self.thir.exprs.push(Expr { temp_lifetime, ty: discr_ty, span, kind });
-
-            let source = match discr_did {
-                // in case we are offsetting from a computed discriminant
-                // and not the beginning of discriminants (which is always `0`)
-                Some(did) => {
-                    let kind = ExprKind::NamedConst { def_id: did, args, user_ty: None };
-                    let lhs =
-                        self.thir.exprs.push(Expr { temp_lifetime, ty: discr_ty, span, kind });
-                    let bin = ExprKind::Binary { op: BinOp::Add, lhs, rhs: offset };
-                    self.thir.exprs.push(Expr { temp_lifetime, ty: discr_ty, span, kind: bin })
-                }
-                None => offset,
-            };
+            None => offset,
+        };
 
-            ExprKind::Cast { source }
-        } else {
-            // Default to `ExprKind::Cast` for all explicit casts.
-            // MIR building then picks the right MIR casts based on the types.
-            ExprKind::Cast { source: self.mirror_expr(source) }
-        }
+        ExprKind::Cast { source }
+    } else {
+        // Default to `ExprKind::Cast` for all explicit casts.
+        // MIR building then picks the right MIR casts based on the types.
+        ExprKind::Cast { source: self.mirror_expr(source) }
     }
+}
 
     #[instrument(level = "debug", skip(self), ret)]
     fn make_mirror_unadjusted(&mut self, expr: &'tcx hir::Expr<'tcx>) -> Expr<'tcx> {
@@ -1040,7 +1040,7 @@ impl<'tcx> Cx<'tcx> {
             // but distinguish between &STATIC and &THREAD_LOCAL as they have different semantics
             Res::Def(DefKind::Static { .. }, id) => {
                 // this is &raw for extern static or static mut, and & for other statics
-                let ty = self.tcx.static_ptr_ty(id, self.typing_env());
+                let ty = self.tcx.static_ptr_ty(id, self.typing_env);
                 let (temp_lifetime, backwards_incompatible) = self
                     .rvalue_scopes
                     .temporary_scope(self.region_scope_tree, expr.hir_id.local_id);
@@ -1240,14 +1240,14 @@ impl<'tcx> Cx<'tcx> {
 
     /// Converts a list of named fields (i.e., for struct-like struct/enum ADTs) into FieldExpr.
     fn field_refs(&mut self, fields: &'tcx [hir::ExprField<'tcx>]) -> Box<[FieldExpr]> {
-        fields
-            .iter()
-            .map(|field| FieldExpr {
-                name: self.typeck_results.field_index(field.hir_id),
-                expr: self.mirror_expr(field.expr),
-            })
-            .collect()
-    }
+    fields
+        .iter()
+        .map(|field| FieldExpr {
+            name: self.typeck_results.field_index(field.hir_id),
+            expr: self.mirror_expr(field.expr),
+        })
+        .collect()
+}
 }
 
 trait ToBorrowKind {
diff --git a/compiler/rustc_mir_build/src/thir/cx/mod.rs b/compiler/rustc_mir_build/src/thir/cx/mod.rs
@@ -12,7 +12,6 @@ use rustc_hir::lang_items::LangItem;
 use rustc_middle::bug;
 use rustc_middle::middle::region;
 use rustc_middle::thir::*;
-use rustc_middle::ty::solve::Reveal;
 use rustc_middle::ty::{self, RvalueScopes, TyCtxt};
 use tracing::instrument;
 
@@ -57,7 +56,7 @@ struct Cx<'tcx> {
     tcx: TyCtxt<'tcx>,
     thir: Thir<'tcx>,
 
-    param_env: ty::ParamEnv<'tcx>,
+    typing_env: ty::TypingEnv<'tcx>,
 
     region_scope_tree: &'tcx region::ScopeTree,
     typeck_results: &'tcx ty::TypeckResults<'tcx>,
@@ -98,7 +97,9 @@ impl<'tcx> Cx<'tcx> {
         Cx {
             tcx,
             thir: Thir::new(body_type),
-            param_env: tcx.param_env(def),
+            // FIXME(#132279): We're in a body, we should use a typing
+            // mode which reveals the opaque types defined by that body.
+            typing_env: ty::TypingEnv::non_body_analysis(tcx, def),
             region_scope_tree: tcx.region_scope_tree(def),
             typeck_results,
             rvalue_scopes: &typeck_results.rvalue_scopes,
@@ -110,20 +111,9 @@ impl<'tcx> Cx<'tcx> {
         }
     }
 
-    fn typing_mode(&self) -> ty::TypingMode<'tcx> {
-        debug_assert_eq!(self.param_env.reveal(), Reveal::UserFacing);
-        // FIXME(#132279): In case we're in a body, we should use a typing
-        // mode which reveals the opaque types defined by that body.
-        ty::TypingMode::non_body_analysis()
-    }
-
-    fn typing_env(&self) -> ty::TypingEnv<'tcx> {
-        ty::TypingEnv { typing_mode: self.typing_mode(), param_env: self.param_env }
-    }
-
     #[instrument(level = "debug", skip(self))]
     fn pattern_from_hir(&mut self, p: &'tcx hir::Pat<'tcx>) -> Box<Pat<'tcx>> {
-        pat_from_hir(self.tcx, self.typing_env(), self.typeck_results(), p)
+        pat_from_hir(self.tcx, self.typing_env, self.typeck_results(), p)
     }
 
     fn closure_env_param(&self, owner_def: LocalDefId, expr_id: HirId) -> Option<Param<'tcx>> {
diff --git a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
@@ -7,7 +7,6 @@ use rustc_errors::{Applicability, ErrorGuaranteed, MultiSpan, struct_span_code_e
 use rustc_hir::def::*;
 use rustc_hir::def_id::LocalDefId;
 use rustc_hir::{self as hir, BindingMode, ByRef, HirId};
-use rustc_infer::traits::Reveal;
 use rustc_middle::bug;
 use rustc_middle::middle::limits::get_limit_size;
 use rustc_middle::thir::visit::Visitor;
@@ -39,7 +38,8 @@ pub(crate) fn check_match(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Result<(), Err
         tcx,
         thir: &*thir,
         typeck_results,
-        param_env: tcx.param_env(def_id),
+        // FIXME(#132279): We're in a body, should handle opaques.
+        typing_env: ty::TypingEnv::non_body_analysis(tcx, def_id),
         lint_level: tcx.local_def_id_to_hir_id(def_id),
         let_source: LetSource::None,
         pattern_arena: &pattern_arena,
@@ -86,7 +86,7 @@ enum LetSource {
 
 struct MatchVisitor<'p, 'tcx> {
     tcx: TyCtxt<'tcx>,
-    param_env: ty::ParamEnv<'tcx>,
+    typing_env: ty::TypingEnv<'tcx>,
     typeck_results: &'tcx ty::TypeckResults<'tcx>,
     thir: &'p Thir<'tcx>,
     lint_level: HirId,
@@ -192,15 +192,6 @@ impl<'p, 'tcx> Visitor<'p, 'tcx> for MatchVisitor<'p, 'tcx> {
 }
 
 impl<'p, 'tcx> MatchVisitor<'p, 'tcx> {
-    fn typing_env(&self) -> ty::TypingEnv<'tcx> {
-        // FIXME(#132279): We're in a body, should handle opaques.
-        debug_assert_eq!(self.param_env.reveal(), Reveal::UserFacing);
-        ty::TypingEnv {
-            typing_mode: ty::TypingMode::non_body_analysis(),
-            param_env: self.param_env,
-        }
-    }
-
     #[instrument(level = "trace", skip(self, f))]
     fn with_let_source(&mut self, let_source: LetSource, f: impl FnOnce(&mut Self)) {
         let old_let_source = self.let_source;
@@ -391,7 +382,7 @@ impl<'p, 'tcx> MatchVisitor<'p, 'tcx> {
         PatCtxt {
             tcx: self.tcx,
             typeck_results: self.typeck_results,
-            param_env: self.param_env,
+            typing_env: self.typing_env,
             module: self.tcx.parent_module(self.lint_level).to_def_id(),
             dropless_arena: self.dropless_arena,
             match_lint_level: self.lint_level,
@@ -745,8 +736,8 @@ impl<'p, 'tcx> MatchVisitor<'p, 'tcx> {
                 .variant(*variant_index)
                 .inhabited_predicate(self.tcx, *adt)
                 .instantiate(self.tcx, args);
-            variant_inhabited.apply(self.tcx, cx.typing_env(), cx.module)
-                && !variant_inhabited.apply_ignore_module(self.tcx, cx.typing_env())
+            variant_inhabited.apply(self.tcx, cx.typing_env, cx.module)
+                && !variant_inhabited.apply_ignore_module(self.tcx, cx.typing_env)
         } else {
             false
         };
@@ -785,7 +776,7 @@ fn check_borrow_conflicts_in_at_patterns<'tcx>(cx: &MatchVisitor<'_, 'tcx>, pat:
         return;
     };
 
-    let is_binding_by_move = |ty: Ty<'tcx>| !ty.is_copy_modulo_regions(cx.tcx, cx.typing_env());
+    let is_binding_by_move = |ty: Ty<'tcx>| !ty.is_copy_modulo_regions(cx.tcx, cx.typing_env);
 
     let sess = cx.tcx.sess;
 
@@ -1149,7 +1140,7 @@ fn report_non_exhaustive_match<'p, 'tcx>(
     }
 
     if let ty::Ref(_, sub_ty, _) = scrut_ty.kind() {
-        if !sub_ty.is_inhabited_from(cx.tcx, cx.module, cx.typing_env()) {
+        if !sub_ty.is_inhabited_from(cx.tcx, cx.module, cx.typing_env) {
             err.note("references are always considered inhabited");
         }
     }
