Weaken the closure parameters in calls using rust-call

[coord-e]

4e2836c

fn apply<F>(f: F) -> i32
where
 F: FnMut(i32) -> i32,
{
 f(1)
}

fn main() {
 let x = 1;
 let closure = |y: i32| x + y;
 let result = apply(closure);
 assert!(result == 2);
}

In the example above, the closure only refers to the outer environment via an immutable reference. This results in a MIR function for the closure that takes the environment by immutable reference:

// MIR for `main::{closure#0}` after runtime-optimized

fn main::{closure#0}(_1: &{closure@closure_param_weaken.rs:10:19: 10:27}, _2: i32) -> i32 {
 debug y => _2;
 debug x => (*((*_1).0: &i32));
 let mut _0: i32;
 let mut _3: i32;
 let mut _4: &i32;

 bb0: {
 _4 = deref_copy ((*_1).0: &i32);
 _3 = (*_4);
 _0 = Add(move _3, _2);
 return;
 }
}

However, in apply, the closure f is called via FnMut (call_mut), so it takes &mut even though FnMut::call_mut resolves to main::{closure#0}:

// MIR for `apply` after runtime-optimized

fn apply(_1: F) -> i32 {
 debug f => _1;
 let mut _0: i32;
 let mut _2: &mut F;
 let mut _3: (i32,);

 bb0: {
 _2 = &mut _1;
 _3 = (const 1_i32,);
 _0 = <F as FnMut<(i32,)>>::call_mut(move _2, move _3) -> [return: bb1, unwind: bb3];
 }

 bb1: {
 drop(_1) -> [return: bb2, unwind continue];
 }

 bb2: {
 return;
 }

 bb3 (cleanup): {
 drop(_1) -> [return: bb4, unwind terminate(cleanup)];
 }

 bb4 (cleanup): {
 resume;
 }
}

This leads to a type mismatch during subtyping.

thread 'rustc' panicked at src/rty/subtyping.rs:117:18:
inconsistent types: got=&mut (own (&immut int),
), expected=&immut (own (&immut int),
)
stack backtrace:
 0: rust_begin_unwind
 at /rustc/9c3ad802d9b9633d60d3a74668eb1be819212d34/library/std/src/panicking.rs:645:5
 1: core::panicking::panic_fmt
 at /rustc/9c3ad802d9b9633d60d3a74668eb1be819212d34/library/core/src/panicking.rs:72:14
 2: <C as thrust::rty::subtyping::Subtyping>::relate_sub_type
 at ./src/rty/subtyping.rs:117:18
 3: thrust::analyze::basic_block::Analyzer::relate_fn_sub_type
 at ./src/analyze/basic_block.rs:155:28
 4: thrust::analyze::basic_block::Analyzer::type_call
 at ./src/analyze/basic_block.rs:595:27
 5: thrust::analyze::basic_block::Analyzer::analyze_terminator_binds
 at ./src/analyze/basic_block.rs:785:13
 6: thrust::analyze::basic_block::Analyzer::run
 at ./src/analyze/basic_block.rs:1129:9
 7: thrust::analyze::local_def::Analyzer::analyze_basic_blocks
 at ./src/analyze/local_def.rs:683:13
 8: thrust::analyze::local_def::Analyzer::run
 at ./src/analyze/local_def.rs:816:9
 9: thrust::analyze::Analyzer::def_ty_with_args
 at ./src/analyze.rs:343:9
 10: thrust::analyze::basic_block::Analyzer::type_call
 at ./src/analyze/basic_block.rs:582:13
 11: thrust::analyze::basic_block::Analyzer::analyze_terminator_binds
 at ./src/analyze/basic_block.rs:785:13
 12: thrust::analyze::basic_block::Analyzer::run
 at ./src/analyze/basic_block.rs:1129:9
 13: thrust::analyze::local_def::Analyzer::analyze_basic_blocks
 at ./src/analyze/local_def.rs:683:13
 14: thrust::analyze::local_def::Analyzer::run
 at ./src/analyze/local_def.rs:816:9
 15: thrust::analyze::crate_::Analyzer::analyze_local_defs
 at ./src/analyze/crate_.rs:135:13
 16: thrust::analyze::crate_::Analyzer::run
 at ./src/analyze/crate_.rs:240:9
 17: <thrust_rustc::CompilerCalls as rustc_driver_impl::Callbacks>::after_analysis::{{closure}}
 at ./src/main.rs:54:13
 18: rustc_middle::ty::context::GlobalCtxt::enter::{{closure}}
 at /rustc/9c3ad802d9b9633d60d3a74668eb1be819212d34/compiler/rustc_middle/src/ty/context.rs:649:37
 19: rustc_middle::ty::context::tls::enter_context::{{closure}}
 at /rustc/9c3ad802d9b9633d60d3a74668eb1be819212d34/compiler/rustc_middle/src/ty/context/tls.rs:82:9
 20: std::thread::local::LocalKey<T>::try_with
 at /rustc/9c3ad802d9b9633d60d3a74668eb1be819212d34/library/std/src/thread/local.rs:284:16
 21: std::thread::local::LocalKey<T>::with
 at /rustc/9c3ad802d9b9633d60d3a74668eb1be819212d34/library/std/src/thread/local.rs:260:9
 22: rustc_middle::ty::context::tls::enter_context
 at /rustc/9c3ad802d9b9633d60d3a74668eb1be819212d34/compiler/rustc_middle/src/ty/context/tls.rs:79:9
 23: rustc_middle::ty::context::GlobalCtxt::enter
 at /rustc/9c3ad802d9b9633d60d3a74668eb1be819212d34/compiler/rustc_middle/src/ty/context.rs:649:9
 24: rustc_interface::queries::QueryResult<&rustc_middle::ty::context::GlobalCtxt>::enter
 at /rustc/9c3ad802d9b9633d60d3a74668eb1be819212d34/compiler/rustc_interface/src/queries.rs:71:9
 25: <thrust_rustc::CompilerCalls as rustc_driver_impl::Callbacks>::after_analysis
 at ./src/main.rs:51:9
 26: rustc_interface::interface::run_compiler::<core::result::Result<(), rustc_span::ErrorGuaranteed>, rustc_driver_impl::run_compiler::{closure#0}>::{closure#0}
note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.

[coord-e]

#48 addresses the case mentioned above, but calling an FnMut closure via FnOnce seems to require more work.

fn apply<F>(f: F) -> i32
where
 F: FnOnce(i32) -> i32,
{
 f(1)
}

fn main() {
 let mut x = 1;
 let closure = |y: i32| {
 x += 1;
 y + x
 };
 let result = apply(closure);
 assert!(result == 3 && x == 2);
}

The following patch fixes the panics, but it cannot prove the assertion (incompleteness), so further investigation is required.

diff --git a/src/analyze/basic_block/visitor/rust_call.rs b/src/analyze/basic_block/visitor/rust_call.rs
index 5b4a24d..18f2b3e 100644
--- a/src/analyze/basic_block/visitor/rust_call.rs
+++ b/src/analyze/basic_block/visitor/rust_call.rs
@@ -8,6 +8,17 @@ pub struct RustCallVisitor<'a, 'tcx, 'ctx> {

 // TODO: consolidate logic with ReborrowVisitor
 impl<'tcx> RustCallVisitor<'_, 'tcx, '_> {
+ fn insert_mut_borrow(&mut self, place: mir::Place<'tcx>, inner_ty: mir_ty::Ty<'tcx>) -> Local {
+ let r = mir_ty::Region::new_from_kind(self.tcx, mir_ty::RegionKind::ReErased);
+ let ty = mir_ty::Ty::new_mut_ref(self.tcx, r, inner_ty);
+ let decl = mir::LocalDecl::new(ty, Default::default()).immutable();
+ let new_local = self.analyzer.local_decls.push(decl);
+ let new_local_ty = self.analyzer.borrow_place_(place, inner_ty);
+ self.analyzer.bind_local(new_local, new_local_ty);
+ tracing::info!(old_place = ?place, ?new_local, "implicitly borrowed");
+ new_local
+ }
+
 fn insert_immut_borrow(
 &mut self,
 place: mir::Place<'tcx>,
@@ -108,7 +119,10 @@ impl<'a, 'tcx, 'ctx> mir::visit::MutVisitor<'tcx> for RustCallVisitor<'a, 'tcx,
 if arg_closure_ty.ref_mutability().is_none()
 ) {
 // case 3: {closure} -> &mut {closure}
- unimplemented!();
+ let borrowed_closure_local =
+ self.insert_mut_borrow(arg_closure_place, arg_closure_ty);
+ args[0].node = mir::Operand::Move(borrowed_closure_local.into());
+ tracing::debug!("applied mut-borrow for closure argument");
 }
 }
 }
diff --git a/src/analyze/local_def.rs b/src/analyze/local_def.rs
index 826d906..2e395b9 100644
--- a/src/analyze/local_def.rs
+++ b/src/analyze/local_def.rs
@@ -531,6 +531,24 @@ impl<'tcx, 'ctx> Analyzer<'tcx, 'ctx> {
 self.super_operand(operand, location);
 }

+ fn visit_terminator(
+ &mut self,
+ terminator: &mir::Terminator<'tcx>,
+ location: mir::Location,
+ ) {
+ if let mir::TerminatorKind::Call { func, args, .. } = &terminator.kind {
+ if let Some((def_id, generic_args)) = func.const_fn_def() {
+ if let Some(trait_did) = self.tcx.trait_of_item(def_id) {
+ if trait_did == self.tcx.lang_items().fn_once_trait().unwrap() {
+ // TODO: check generic_args[0].0 fn sig is &mut
+ self.locals.insert(args[0].node.place().unwrap().local);
+ }
+ }
+ }
+ }
+ self.super_terminator(terminator, location);
+ }
+
 fn visit_assign(
 &mut self,
 place: &mir::Place<'tcx>,