Upgrade rust toolchain to 2024-02-17 (model-checking#3040)

Upgrade toolchain to 2024-02-17. Relevant PR:

- rust-lang/rust#120500
- rust-lang/rust#100603

Fixes model-checking#87
Fixes model-checking#3034
Fixes model-checking#3037

kani-compiler/src/codegen_cprover_gotoc/codegen/intrinsic.rs

@@ -12,7 +12,7 @@ use cbmc::goto_program::{
 use rustc_middle::ty::layout::ValidityRequirement;
 use rustc_middle::ty::ParamEnv;
 use rustc_smir::rustc_internal;
-use stable_mir::mir::mono::{Instance, InstanceKind};
+use stable_mir::mir::mono::Instance;
 use stable_mir::mir::{BasicBlockIdx, Operand, Place};
 use stable_mir::ty::{GenericArgs, RigidTy, Span, Ty, TyKind, UintTy};
 use tracing::debug;
@@ -45,17 +45,15 @@ impl<'tcx> GotocCtx<'tcx> {
     /// there is no terminator.
     pub fn codegen_funcall_of_intrinsic(
         &mut self,
-        func: &Operand,
+        instance: Instance,
         args: &[Operand],
         destination: &Place,
         target: Option<BasicBlockIdx>,
         span: Span,
     ) -> Stmt {
-        let instance = self.get_intrinsic_instance(func).unwrap();
-
         if let Some(target) = target {
             let loc = self.codegen_span_stable(span);
-            let fargs = self.codegen_funcall_args(args, false);
+            let fargs = args.iter().map(|arg| self.codegen_operand_stable(arg)).collect::<Vec<_>>();
             Stmt::block(
                 vec![
                     self.codegen_intrinsic(instance, fargs, destination, span),
@@ -68,23 +66,6 @@ impl<'tcx> GotocCtx<'tcx> {
         }
     }
 
-    /// Returns `Some(instance)` if the function is an intrinsic; `None` otherwise
-    fn get_intrinsic_instance(&self, func: &Operand) -> Option<Instance> {
-        let funct = self.operand_ty_stable(func);
-        match funct.kind() {
-            TyKind::RigidTy(RigidTy::FnDef(def, args)) => {
-                let instance = Instance::resolve(def, &args).unwrap();
-                if matches!(instance.kind, InstanceKind::Intrinsic) { Some(instance) } else { None }
-            }
-            _ => None,
-        }
-    }
-
-    /// Returns true if the `func` is a call to a compiler intrinsic; false otherwise.
-    pub fn is_intrinsic(&self, func: &Operand) -> bool {
-        self.get_intrinsic_instance(func).is_some()
-    }
-
     /// Handles codegen for non returning intrinsics
     /// Non returning intrinsics are not associated with a destination
     pub fn codegen_never_return_intrinsic(&mut self, instance: Instance, span: Span) -> Stmt {

kani-compiler/src/codegen_cprover_gotoc/codegen/operand.rs

@@ -557,6 +557,17 @@ impl<'tcx> GotocCtx<'tcx> {
         alloc_vals
     }
 
+    /// Returns `Some(instance)` if the function is an intrinsic; `None` otherwise
+    pub fn get_instance(&self, func: &Operand) -> Option<Instance> {
+        let funct = self.operand_ty_stable(func);
+        match funct.kind() {
+            TyKind::RigidTy(RigidTy::FnDef(def, args)) => {
+                Some(Instance::resolve(def, &args).unwrap())
+            }
+            _ => None,
+        }
+    }
+
     /// Generate a goto expression for a MIR "function item" reference.
     ///
     /// A "function item" is a ZST that corresponds to a specific single function.

kani-compiler/src/codegen_cprover_gotoc/codegen/statement.rs

@@ -7,14 +7,16 @@ use crate::codegen_cprover_gotoc::{GotocCtx, VtableCtx};
 use crate::unwrap_or_return_codegen_unimplemented_stmt;
 use cbmc::goto_program::{Expr, Location, Stmt, Type};
 use rustc_middle::ty::layout::LayoutOf;
+use rustc_middle::ty::{List, ParamEnv};
 use rustc_smir::rustc_internal;
 use rustc_target::abi::{FieldsShape, Primitive, TagEncoding, Variants};
+use stable_mir::abi::{ArgAbi, FnAbi, PassMode};
 use stable_mir::mir::mono::{Instance, InstanceKind};
 use stable_mir::mir::{
     AssertMessage, BasicBlockIdx, CopyNonOverlapping, NonDivergingIntrinsic, Operand, Place,
     Statement, StatementKind, SwitchTargets, Terminator, TerminatorKind, RETURN_LOCAL,
 };
-use stable_mir::ty::{RigidTy, Span, Ty, TyKind, VariantIdx};
+use stable_mir::ty::{Abi, RigidTy, Span, Ty, TyKind, VariantIdx};
 use tracing::{debug, debug_span, trace};
 
 impl<'tcx> GotocCtx<'tcx> {
@@ -432,31 +434,21 @@ impl<'tcx> GotocCtx<'tcx> {
     /// as subsequent parameters.
     ///
     /// See [GotocCtx::ty_needs_untupled_args] for more details.
-    fn codegen_untupled_args(
-        &mut self,
-        instance: Instance,
-        fargs: &mut Vec<Expr>,
-        last_mir_arg: Option<&Operand>,
-    ) {
-        debug!("codegen_untuple_closure_args instance: {:?}, fargs {:?}", instance.name(), fargs);
-        if !fargs.is_empty() {
-            let tuple_ty = self.operand_ty_stable(last_mir_arg.unwrap());
-            if self.is_zst_stable(tuple_ty) {
-                // Don't pass anything if all tuple elements are ZST.
-                // ZST arguments are ignored.
-                return;
-            }
-            let tupe = fargs.remove(fargs.len() - 1);
-            if let TyKind::RigidTy(RigidTy::Tuple(tupled_args)) = tuple_ty.kind() {
-                for (idx, arg_ty) in tupled_args.iter().enumerate() {
-                    if !self.is_zst_stable(*arg_ty) {
-                        // Access the tupled parameters through the `member` operation
-                        let idx_expr = tupe.clone().member(&idx.to_string(), &self.symbol_table);
-                        fargs.push(idx_expr);
-                    }
-                }
-            }
-        }
+    fn codegen_untupled_args(&mut self, op: &Operand, args_abi: &[ArgAbi]) -> Vec<Expr> {
+        let tuple_ty = self.operand_ty_stable(op);
+        let tuple_expr = self.codegen_operand_stable(op);
+        let TyKind::RigidTy(RigidTy::Tuple(tupled_args)) = tuple_ty.kind() else { unreachable!() };
+        tupled_args
+            .iter()
+            .enumerate()
+            .filter_map(|(idx, _)| {
+                let arg_abi = &args_abi[idx];
+                (arg_abi.mode != PassMode::Ignore).then(|| {
+                    // Access the tupled parameters through the `member` operation
+                    tuple_expr.clone().member(idx.to_string(), &self.symbol_table)
+                })
+            })
+            .collect()
     }
 
     /// Because function calls terminate basic blocks, to "end" a function call, we
@@ -472,25 +464,24 @@ impl<'tcx> GotocCtx<'tcx> {
     /// Generate Goto-C for each argument to a function call.
     ///
     /// N.B. public only because instrinsics use this directly, too.
-    /// When `skip_zst` is set to `true`, the return value will not include any argument that is ZST.
-    /// This is used because we ignore ZST arguments, except for intrinsics.
-    pub(crate) fn codegen_funcall_args(&mut self, args: &[Operand], skip_zst: bool) -> Vec<Expr> {
-        let fargs = args
+    pub(crate) fn codegen_funcall_args(&mut self, fn_abi: &FnAbi, args: &[Operand]) -> Vec<Expr> {
+        let fargs: Vec<Expr> = args
             .iter()
-            .filter_map(|op| {
-                let op_ty = self.operand_ty_stable(op);
-                if op_ty.kind().is_bool() {
+            .enumerate()
+            .filter_map(|(i, op)| {
+                // Functions that require caller info will have an extra parameter.
+                let arg_abi = &fn_abi.args.get(i);
+                let ty = self.operand_ty_stable(op);
+                if ty.kind().is_bool() {
                     Some(self.codegen_operand_stable(op).cast_to(Type::c_bool()))
-                } else if !self.is_zst_stable(op_ty) || !skip_zst {
+                } else if arg_abi.map_or(true, |abi| abi.mode != PassMode::Ignore) {
                     Some(self.codegen_operand_stable(op))
                 } else {
-                    // We ignore ZST types.
-                    debug!(arg=?op, "codegen_funcall_args ignore");
                     None
                 }
             })
             .collect();
-        debug!(?fargs, "codegen_funcall_args");
+        debug!(?fargs, args_abi=?fn_abi.args, "codegen_funcall_args");
         fargs
     }
 
@@ -515,9 +506,12 @@ impl<'tcx> GotocCtx<'tcx> {
         span: Span,
     ) -> Stmt {
         debug!(?func, ?args, ?destination, ?span, "codegen_funcall");
-        if self.is_intrinsic(&func) {
+        let instance_opt = self.get_instance(func);
+        if let Some(instance) = instance_opt
+            && matches!(instance.kind, InstanceKind::Intrinsic)
+        {
             return self.codegen_funcall_of_intrinsic(
-                &func,
+                instance,
                 &args,
                 &destination,
                 target.map(|bb| bb),
@@ -526,16 +520,23 @@ impl<'tcx> GotocCtx<'tcx> {
         }
 
         let loc = self.codegen_span_stable(span);
-        let funct = self.operand_ty_stable(func);
-        let mut fargs = self.codegen_funcall_args(&args, true);
-        match funct.kind() {
-            TyKind::RigidTy(RigidTy::FnDef(def, subst)) => {
-                let instance = Instance::resolve(def, &subst).unwrap();
-
-                // TODO(celina): Move this check to be inside codegen_funcall_args.
-                if self.ty_needs_untupled_args(rustc_internal::internal(self.tcx, funct)) {
-                    self.codegen_untupled_args(instance, &mut fargs, args.last());
-                }
+        let fn_ty = self.operand_ty_stable(func);
+        match fn_ty.kind() {
+            fn_def @ TyKind::RigidTy(RigidTy::FnDef(..)) => {
+                let instance = instance_opt.unwrap();
+                let fn_abi = instance.fn_abi().unwrap();
+                let mut fargs = if args.is_empty()
+                    || fn_def.fn_sig().unwrap().value.abi != Abi::RustCall
+                {
+                    self.codegen_funcall_args(&fn_abi, &args)
+                } else {
+                    let (untupled, first_args) = args.split_last().unwrap();
+                    let mut fargs = self.codegen_funcall_args(&fn_abi, &first_args);
+                    fargs.append(
+                        &mut self.codegen_untupled_args(untupled, &fn_abi.args[first_args.len()..]),
+                    );
+                    fargs
+                };
 
                 if let Some(hk) = self.hooks.hook_applies(self.tcx, instance) {
                     return hk.handle(self, instance, fargs, destination, *target, span);
@@ -573,7 +574,16 @@ impl<'tcx> GotocCtx<'tcx> {
                 Stmt::block(stmts, loc)
             }
             // Function call through a pointer
-            TyKind::RigidTy(RigidTy::FnPtr(_)) => {
+            TyKind::RigidTy(RigidTy::FnPtr(fn_sig)) => {
+                let fn_sig_internal = rustc_internal::internal(self.tcx, fn_sig);
+                let fn_ptr_abi = rustc_internal::stable(
+                    self.tcx
+                        .fn_abi_of_fn_ptr(
+                            ParamEnv::reveal_all().and((fn_sig_internal, &List::empty())),
+                        )
+                        .unwrap(),
+                );
+                let fargs = self.codegen_funcall_args(&fn_ptr_abi, &args);
                 let func_expr = self.codegen_operand_stable(func).dereference();
                 // Actually generate the function call and return.
                 Stmt::block(

kani-compiler/src/codegen_cprover_gotoc/codegen/ty_stable.rs

@@ -115,6 +115,11 @@ impl<'tcx> GotocCtx<'tcx> {
     pub fn pretty_ty(&self, ty: Ty) -> String {
         rustc_internal::internal(self.tcx, ty).to_string()
     }
+
+    pub fn requires_caller_location(&self, instance: Instance) -> bool {
+        let instance_internal = rustc_internal::internal(self.tcx, instance);
+        instance_internal.def.requires_caller_location(self.tcx)
+    }
 }
 /// If given type is a Ref / Raw ref, return the pointee type.
 pub fn pointee_type(mir_type: Ty) -> Option<Ty> {

kani-compiler/src/codegen_cprover_gotoc/codegen/typ.rs

@@ -21,7 +21,6 @@ use rustc_target::abi::{
     Abi::Vector, FieldIdx, FieldsShape, Integer, LayoutS, Primitive, Size, TagEncoding,
     TyAndLayout, VariantIdx, Variants,
 };
-use rustc_target::spec::abi::Abi;
 use stable_mir::abi::{ArgAbi, FnAbi, PassMode};
 use stable_mir::mir::mono::Instance as InstanceStable;
 use stable_mir::mir::Body;
@@ -731,39 +730,6 @@ impl<'tcx> GotocCtx<'tcx> {
         self.codegen_struct_fields(flds, &layout.layout.0, Size::ZERO)
     }
 
-    /// A closure / some shims in Rust MIR takes two arguments:
-    ///
-    ///    0. a struct representing the environment
-    ///    1. a tuple containing the parameters
-    ///
-    /// However, during codegen/lowering from MIR, the 2nd tuple of parameters
-    /// is flattened into subsequent parameters.
-    ///
-    /// Checking whether the type's kind is a closure is insufficient, because
-    /// a virtual method call through a vtable can have the trait's non-closure
-    /// type. For example:
-    ///
-    /// ```
-    ///         let p: &dyn Fn(i32) = &|x| assert!(x == 1);
-    ///         p(1);
-    /// ```
-    ///
-    /// Here, the call `p(1)` desugars to an MIR trait call `Fn::call(&p, (1,))`,
-    /// where the second argument is a tuple. The instance type kind for
-    /// `Fn::call` is not a closure, because dynamically, the pointer may be to
-    /// a function definition instead. We still need to untuple in this case,
-    /// so we follow the example elsewhere in Rust to use the ABI call type.
-    ///
-    /// See `make_call_args` in `rustc_mir_transform/src/inline.rs`
-    pub fn ty_needs_untupled_args(&self, ty: Ty<'tcx>) -> bool {
-        // Note that [Abi::RustCall] is not [Abi::Rust].
-        // Documentation is sparse, but it does seem to correspond to the need for untupling.
-        match ty.kind() {
-            ty::FnDef(..) | ty::FnPtr(..) => ty.fn_sig(self.tcx).abi() == Abi::RustCall,
-            _ => unreachable!("Can't treat type as a function: {:?}", ty),
-        }
-    }
-
     /// A closure is a struct of all its environments. That is, a closure is
     /// just a tuple with a unique type identifier, so that Fn related traits
     /// can find its impl.
@@ -1647,13 +1613,12 @@ impl<'tcx> GotocCtx<'tcx> {
     /// 1. In some cases, an argument can be ignored (e.g.: ZST arguments in regular Rust calls).
     /// 2. We currently don't support `track_caller`, so we ignore the extra argument that is added to support that.
     ///    Tracked here: <https://github.com/model-checking/kani/issues/374>
-    fn codegen_args<'a>(
+    pub fn codegen_args<'a>(
         &self,
         instance: InstanceStable,
         fn_abi: &'a FnAbi,
     ) -> impl Iterator<Item = (usize, &'a ArgAbi)> {
-        let instance_internal = rustc_internal::internal(self.tcx, instance);
-        let requires_caller_location = instance_internal.def.requires_caller_location(self.tcx);
+        let requires_caller_location = self.requires_caller_location(instance);
         let num_args = fn_abi.args.len();
         fn_abi.args.iter().enumerate().filter(move |(idx, arg_abi)| {
             arg_abi.mode != PassMode::Ignore && !(requires_caller_location && idx + 1 == num_args)

kani-compiler/src/kani_middle/intrinsics.rs

@@ -101,8 +101,8 @@ fn resolve_rust_intrinsic<'tcx>(
     func_ty: Ty<'tcx>,
 ) -> Option<(Symbol, GenericArgsRef<'tcx>)> {
     if let ty::FnDef(def_id, args) = *func_ty.kind() {
-        if tcx.is_intrinsic(def_id) {
-            return Some((tcx.item_name(def_id), args));
+        if let Some(symbol) = tcx.intrinsic(def_id) {
+            return Some((symbol, args));
         }
     }
     None

kani-compiler/src/main.rs

@@ -13,6 +13,7 @@
 #![feature(lazy_cell)]
 #![feature(more_qualified_paths)]
 #![feature(iter_intersperse)]
+#![feature(let_chains)]
 extern crate rustc_abi;
 extern crate rustc_ast;
 extern crate rustc_ast_pretty;

rust-toolchain.toml

@@ -2,5 +2,5 @@
 # SPDX-License-Identifier: Apache-2.0 OR MIT
 
 [toolchain]
-channel = "nightly-2024-02-14"
+channel = "nightly-2024-02-17"
 components = ["llvm-tools-preview", "rustc-dev", "rust-src", "rustfmt"]

tests/kani/Closure/zst_unwrap.rs

@@ -0,0 +1,16 @@
+// Copyright Kani Contributors
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+//! Test that Kani can properly handle closure to fn ptr when an argument type is Never (`!`).
+//! See <https://github.com/model-checking/kani/issues/3034> for more details.
+#![feature(never_type)]
+
+pub struct Foo {
+    _x: i32,
+    _never: !,
+}
+
+#[kani::proof]
+fn check_unwrap_never() {
+    let res = Result::<i32, Foo>::Ok(3);
+    let _x = res.unwrap_or_else(|_f| 5);
+}