gamer

Author: lcnr

compiler/rustc_mir_build/src/build/expr/stmt.rs

@@ -1,7 +1,7 @@
 use rustc_middle::middle::region;
 use rustc_middle::mir::*;
+use rustc_middle::span_bug;
 use rustc_middle::thir::*;
-use rustc_middle::{span_bug, ty};
 use rustc_span::source_map::Spanned;
 use tracing::debug;
 

compiler/rustc_mir_build/src/build/matches/test.rs

@@ -568,7 +568,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 let is_covering_range = |test_case: &TestCase<'_, 'tcx>| {
                     test_case.as_range().is_some_and(|range| {
                         matches!(
-                            range.contains(value, self.tcx, self.infcx.typing_env(self.param_env),),
+                            range.contains(value, self.tcx, self.typing_env(),),
                             None | Some(true)
                         )
                     })
@@ -587,7 +587,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                     None
                 } else {
                     fully_matched = true;
-                    let bits = value.eval_bits(self.tcx, self.infcx.typing_env(self.param_env));
+                    let bits = value.eval_bits(self.tcx, self.typing_env());
                     Some(TestBranch::Constant(value, bits))
                 }
             }
@@ -597,16 +597,12 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 // the values being tested. (This restricts what values can be
                 // added to the test by subsequent candidates.)
                 fully_matched = false;
-                let not_contained = sorted_candidates
-                    .keys()
-                    .filter_map(|br| br.as_constant())
-                    .copied()
-                    .all(|val| {
-                        matches!(
-                            range.contains(val, self.tcx, self.infcx.typing_env(self.param_env),),
-                            Some(false)
-                        )
-                    });
+                let not_contained =
+                    sorted_candidates.keys().filter_map(|br| br.as_constant()).copied().all(
+                        |val| {
+                            matches!(range.contains(val, self.tcx, self.typing_env(),), Some(false))
+                        },
+                    );
 
                 not_contained.then(|| {
                     // No switch values are contained in the pattern range,
@@ -617,11 +613,9 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
 
             (TestKind::If, TestCase::Constant { value }) => {
                 fully_matched = true;
-                let value = value
-                    .try_eval_bool(self.tcx, self.infcx.typing_env(self.param_env))
-                    .unwrap_or_else(|| {
-                        span_bug!(test.span, "expected boolean value but got {value:?}")
-                    });
+                let value = value.try_eval_bool(self.tcx, self.typing_env()).unwrap_or_else(|| {
+                    span_bug!(test.span, "expected boolean value but got {value:?}")
+                });
                 Some(if value { TestBranch::Success } else { TestBranch::Failure })
             }
 
@@ -699,7 +693,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                     fully_matched = false;
                     // If the testing range does not overlap with pattern range,
                     // the pattern can be matched only if this test fails.
-                    if !test.overlaps(pat, self.tcx, self.infcx.typing_env(self.param_env))? {
+                    if !test.overlaps(pat, self.tcx, self.typing_env())? {
                         Some(TestBranch::Failure)
                     } else {
                         None
@@ -708,7 +702,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             }
             (TestKind::Range(range), &TestCase::Constant { value }) => {
                 fully_matched = false;
-                if !range.contains(value, self.tcx, self.infcx.typing_env(self.param_env))? {
+                if !range.contains(value, self.tcx, self.typing_env())? {
                     // `value` is not contained in the testing range,
                     // so `value` can be matched only if this test fails.
                     Some(TestBranch::Failure)

compiler/rustc_mir_build/src/build/mod.rs

@@ -230,6 +230,10 @@ struct Capture<'tcx> {
 }
 
 impl<'a, 'tcx> Builder<'a, 'tcx> {
+    fn typing_env(&self) -> ty::TypingEnv<'tcx> {
+        self.infcx.typing_env(self.param_env)
+    }
+
     fn is_bound_var_in_guard(&self, id: LocalVarId) -> bool {
         self.guard_context.iter().any(|frame| frame.locals.iter().any(|local| local.id == id))
     }

compiler/rustc_mir_build/src/build/scope.rs

@@ -89,7 +89,7 @@ use rustc_index::{IndexSlice, IndexVec};
 use rustc_middle::middle::region;
 use rustc_middle::mir::*;
 use rustc_middle::thir::{ExprId, LintLevel};
-use rustc_middle::{bug, span_bug, ty};
+use rustc_middle::{bug, span_bug};
 use rustc_session::lint::Level;
 use rustc_span::source_map::Spanned;
 use rustc_span::{DUMMY_SP, Span};
@@ -1010,10 +1010,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
     ) {
         let needs_drop = match drop_kind {
             DropKind::Value => {
-                if !self.local_decls[local]
-                    .ty
-                    .needs_drop(self.tcx, ty::TypingEnv::from_param_env(self.param_env))
-                {
+                if !self.local_decls[local].ty.needs_drop(self.tcx, self.typing_env()) {
                     return;
                 }
                 true