Reveal opaques defined in the body during analysis

Author: beamandala

compiler/rustc_middle/src/mir/mod.rs

@@ -418,11 +418,19 @@ impl<'tcx> Body<'tcx> {
 
     pub fn typing_env(&self, tcx: TyCtxt<'tcx>) -> TypingEnv<'tcx> {
         match self.phase {
-            // FIXME(#132279): we should reveal the opaques defined in the body during analysis.
-            MirPhase::Built | MirPhase::Analysis(_) => TypingEnv {
-                typing_mode: ty::TypingMode::non_body_analysis(),
-                param_env: tcx.param_env(self.source.def_id()),
-            },
+            MirPhase::Built | MirPhase::Analysis(_) => {
+                let def_id = self.source.def_id();
+                let typing_mode = match self.source.instance {
+                    InstanceKind::Item(item_def_id) => item_def_id
+                        .as_local()
+                        .map_or(ty::TypingMode::non_body_analysis(), |local_def_id| {
+                            ty::TypingMode::analysis_in_body(tcx, local_def_id)
+                        }),
+                    _ => ty::TypingMode::non_body_analysis(),
+                };
+
+                TypingEnv { typing_mode, param_env: tcx.param_env(def_id) }
+            }
             MirPhase::Runtime(_) => TypingEnv::post_analysis(tcx, self.source.def_id()),
         }
     }

compiler/rustc_mir_transform/src/validate.rs

@@ -619,6 +619,9 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
         if pred.has_opaque_types() {
             return true;
         }
+        if self.typing_env.typing_mode.may_define_opaque_types() {
+            return true;
+        }
 
         let (infcx, param_env) = self.tcx.infer_ctxt().build_with_typing_env(self.typing_env);
         let ocx = ObligationCtxt::new(&infcx);

compiler/rustc_type_ir/src/infer_ctxt.rs

@@ -133,6 +133,17 @@ impl<I: Interner> TypingMode<I> {
             TypingMode::PostBorrowckAnalysis { defined_opaque_types }
         }
     }
+
+    /// Returns `true` if this typing mode is allowed to define new opaque types.
+    pub fn may_define_opaque_types(&self) -> bool {
+        match self {
+            TypingMode::Analysis { defining_opaque_types_and_generators } => {
+                !defining_opaque_types_and_generators.is_empty()
+            }
+            TypingMode::Borrowck { defining_opaque_types } => !defining_opaque_types.is_empty(),
+            _ => false,
+        }
+    }
 }
 
 #[cfg_attr(feature = "nightly", rustc_diagnostic_item = "type_ir_infer_ctxt_like")]