stuff

Author: tjhance

source/rustc_mir_build/src/expr_use_visitor.rs

@@ -2,6 +2,8 @@
 //! normal visitor, which just walks the entire body in one shot, the
 //! `ExprUseVisitor` determines how expressions are being used.
 
+#![allow(unused_imports)]
+
 use std::cell::{Ref, RefCell};
 use std::ops::Deref;
 use std::slice::from_ref;
@@ -29,8 +31,6 @@ use rustc_trait_selection::infer::InferCtxtExt;
 use tracing::{debug, trace};
 use ty::BorrowKind::ImmBorrow;
 
-use crate::fn_ctxt::FnCtxt;
-
 /// This trait defines the callbacks you can expect to receive when
 /// employing the ExprUseVisitor.
 pub trait Delegate<'tcx> {
@@ -150,6 +150,7 @@ pub trait TypeInformationCtxt<'tcx> {
     fn tcx(&self) -> TyCtxt<'tcx>;
 }
 
+/*
 impl<'tcx> TypeInformationCtxt<'tcx> for &FnCtxt<'_, 'tcx> {
     type TypeckResults<'a> = Ref<'a, ty::TypeckResults<'tcx>>
     where
@@ -238,6 +239,51 @@ impl<'tcx> TypeInformationCtxt<'tcx> for (&LateContext<'tcx>, LocalDefId) {
         self.0.tcx
     }
 }
+*/
+
+impl<'tcx> TypeInformationCtxt<'tcx> for &crate::upvar::FnCtxt<'_, 'tcx> {
+    type TypeckResults<'a> = &'tcx ty::TypeckResults<'tcx>
+    where
+        Self: 'a;
+
+    type Error = !;
+
+    fn typeck_results(&self) -> Self::TypeckResults<'_> {
+        self.typeck_results
+    }
+
+    fn try_structurally_resolve_type(&self, _span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
+        ty
+    }
+
+    fn resolve_vars_if_possible<T: TypeFoldable<TyCtxt<'tcx>>>(&self, t: T) -> T {
+        t
+    }
+
+    fn report_error(&self, span: Span, msg: impl ToString) -> ! {
+        span_bug!(span, "{}", msg.to_string())
+    }
+
+    fn error_reported_in_ty(&self, _ty: Ty<'tcx>) -> Result<(), !> {
+        Ok(())
+    }
+
+    fn tainted_by_errors(&self) -> Result<(), !> {
+        Ok(())
+    }
+
+    fn type_is_copy_modulo_regions(&self, ty: Ty<'tcx>) -> bool {
+        ty.is_copy_modulo_regions(self.tcx, self.param_env)
+    }
+
+    fn body_owner_def_id(&self) -> LocalDefId {
+        self.closure_def_id
+    }
+
+    fn tcx(&self) -> TyCtxt<'tcx> {
+        self.tcx
+    }
+}
 
 /// The ExprUseVisitor type
 ///
@@ -250,11 +296,13 @@ pub struct ExprUseVisitor<'tcx, Cx: TypeInformationCtxt<'tcx>, D: Delegate<'tcx>
     upvars: Option<&'tcx FxIndexMap<HirId, hir::Upvar>>,
 }
 
+/*
 impl<'a, 'tcx, D: Delegate<'tcx>> ExprUseVisitor<'tcx, (&'a LateContext<'tcx>, LocalDefId), D> {
     pub fn for_clippy(cx: &'a LateContext<'tcx>, body_def_id: LocalDefId, delegate: D) -> Self {
         Self::new((cx, body_def_id), delegate)
     }
 }
+*/
 
 impl<'tcx, Cx: TypeInformationCtxt<'tcx>, D: Delegate<'tcx>> ExprUseVisitor<'tcx, Cx, D> {
     /// Creates the ExprUseVisitor, configuring it with the various options provided:

source/rustc_mir_build/src/lib.rs

@@ -3,12 +3,15 @@
 // tidy-alphabetical-start
 #![allow(rustc::diagnostic_outside_of_impl)]
 #![allow(rustc::untranslatable_diagnostic)]
+#![allow(dead_code)]
+#![allow(noop_method_call)]
 #![feature(assert_matches)]
 #![feature(box_patterns)]
 #![feature(if_let_guard)]
 #![feature(let_chains)]
 #![feature(try_blocks)]
 #![feature(rustc_private)]
+#![feature(never_type)]
 #![warn(unreachable_pub)]
 // tidy-alphabetical-end
 

source/rustc_mir_build/src/thir/cx/expr.rs

@@ -559,9 +559,12 @@ impl<'tcx> Cx<'tcx> {
                 };
                 let def_id = def_id.expect_local();
 
-                let upvars = self
+                let (closure_captures, fake_reads) = crate::verus::get_upvars(self, expr, def_id);
+
+                let upvars = /*self
                     .tcx
-                    .closure_captures(def_id)
+                    .closure_captures(def_id)*/
+                    closure_captures
                     .iter()
                     .zip_eq(args.upvar_tys())
                     .filter(|(captured_place, ty)| {
@@ -575,16 +578,13 @@ impl<'tcx> Cx<'tcx> {
                     .collect();
 
                 // Convert the closure fake reads, if any, from hir `Place` to ExprRef
-                let fake_reads = match self.typeck_results.closure_fake_reads.get(&def_id) {
-                    Some(fake_reads) => fake_reads
+                let fake_reads = fake_reads
                         .iter()
                         .map(|(place, cause, hir_id)| {
                             let expr = self.convert_captured_hir_place(expr, place.clone());
                             (self.thir.exprs.push(expr), *cause, *hir_id)
                         })
-                        .collect(),
-                    None => Vec::new(),
-                };
+                        .collect();
 
                 ExprKind::Closure(Box::new(crate::verus::fix_closure(self, ClosureExpr {
                     closure_id: def_id,