analyze: add function attrs for testing

c2rust-analyze/src/main.rs

@@ -23,7 +23,8 @@ use crate::dataflow::DataflowConstraints;
 use crate::equiv::{GlobalEquivSet, LocalEquivSet};
 use crate::labeled_ty::LabeledTyCtxt;
 use crate::log::init_logger;
-use crate::util::Callee;
+use crate::panic_detail::PanicDetail;
+use crate::util::{Callee, TestAttr};
 use context::AdtMetadataTable;
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::{DefId, LocalDefId};
@@ -38,6 +39,7 @@ use rustc_span::Span;
 use std::collections::{HashMap, HashSet};
 use std::env;
 use std::fmt::{Debug, Display};
+use std::iter;
 use std::ops::{Deref, DerefMut, Index};
 use std::panic::AssertUnwindSafe;
 
@@ -493,6 +495,30 @@ fn run(tcx: TyCtxt) {
         info.lasn.set(lasn);
     }
 
+    // For testing, putting #[c2rust_analyze_test::fixed_signature] on a function makes all
+    // pointers in its signature FIXED.
+    for &ldid in &all_fn_ldids {
+        if !util::has_test_attr(tcx, ldid, TestAttr::FixedSignature) {
+            continue;
+        }
+        let lsig = match gacx.fn_sigs.get(&ldid.to_def_id()) {
+            Some(x) => x,
+            None => continue,
+        };
+        make_sig_fixed(&mut gasn, lsig);
+    }
+
+    // For testing, putting #[c2rust_analyze_test::fail_analysis] on a function marks it as failed.
+    for &ldid in &all_fn_ldids {
+        if !util::has_test_attr(tcx, ldid, TestAttr::FailAnalysis) {
+            continue;
+        }
+        gacx.mark_fn_failed(
+            ldid.to_def_id(),
+            PanicDetail::new("explicit fail_analysis for testing".to_owned()),
+        );
+    }
+
     eprintln!("=== ADT Metadata ===");
     eprintln!("{:?}", gacx.adt_metadata);
 
@@ -597,6 +623,10 @@ fn run(tcx: TyCtxt) {
 
         eprintln!();
 
+        if util::has_test_attr(tcx, ldid, TestAttr::SkipRewrite) {
+            continue;
+        }
+
         let r = panic_detail::catch_unwind(AssertUnwindSafe(|| {
             let hir_body_id = tcx.hir().body_owned_by(ldid);
             let expr_rewrites = rewrite::gen_expr_rewrites(&acx, &asn, &mir, hir_body_id);
@@ -738,6 +768,21 @@ impl<'tcx> AssignPointerIds<'tcx> for AnalysisCtxt<'_, 'tcx> {
     }
 }
 
+fn make_ty_fixed(gasn: &mut GlobalAssignment, lty: LTy) {
+    for lty in lty.iter() {
+        let ptr = lty.label;
+        if !ptr.is_none() {
+            gasn.flags[ptr].insert(FlagSet::FIXED);
+        }
+    }
+}
+
+fn make_sig_fixed(gasn: &mut GlobalAssignment, lsig: &LFnSig) {
+    for lty in lsig.inputs.iter().copied().chain(iter::once(lsig.output)) {
+        make_ty_fixed(gasn, lty);
+    }
+}
+
 fn describe_local(tcx: TyCtxt, decl: &LocalDecl) -> String {
     let mut span = decl.source_info.span;
     if let Some(ref info) = decl.local_info {

c2rust-analyze/src/util.rs

@@ -1,15 +1,17 @@
 use crate::labeled_ty::LabeledTy;
 use crate::trivial::IsTrivial;
+use rustc_ast::ast::AttrKind;
 use rustc_const_eval::interpret::Scalar;
 use rustc_hir::def::DefKind;
-use rustc_hir::def_id::DefId;
+use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_middle::mir::{
     BasicBlock, BasicBlockData, Constant, Field, Local, Location, Mutability, Operand, Place,
     PlaceElem, PlaceRef, ProjectionElem, Rvalue, Statement, StatementKind,
 };
 use rustc_middle::ty::{
     self, AdtDef, DefIdTree, EarlyBinder, Subst, SubstsRef, Ty, TyCtxt, TyKind, UintTy,
 };
+use rustc_span::symbol::Symbol;
 use std::fmt::Debug;
 
 #[derive(Debug)]
@@ -353,3 +355,44 @@ pub fn is_null_const(constant: Constant) -> bool {
 
 pub trait PhantomLifetime<'a> {}
 impl<'a, T: ?Sized> PhantomLifetime<'a> for T {}
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug, Hash)]
+pub enum TestAttr {
+    /// `#[c2rust_analyze_test::fixed_signature]`: Mark all pointers in the function signature as
+    /// [`FIXED`](crate::context::FlagSet::FIXED).
+    FixedSignature,
+    /// `#[c2rust_analyze_test::fail_analysis]`: Force an analysis failure for the function.
+    FailAnalysis,
+    /// `#[c2rust_analyze_test::skip_rewrite]`: Skip generating rewrites for the function.
+    SkipRewrite,
+}
+
+impl TestAttr {
+    pub fn name(self) -> &'static str {
+        match self {
+            TestAttr::FixedSignature => "fixed_signature",
+            TestAttr::FailAnalysis => "fail_analysis",
+            TestAttr::SkipRewrite => "skip_rewrite",
+        }
+    }
+}
+
+pub fn has_test_attr(tcx: TyCtxt, ldid: LocalDefId, attr: TestAttr) -> bool {
+    let tool_sym = Symbol::intern("c2rust_analyze_test");
+    let name_sym = Symbol::intern(attr.name());
+
+    for attr in tcx.get_attrs_unchecked(ldid.to_def_id()) {
+        let path = match attr.kind {
+            AttrKind::Normal(ref item, _) => &item.path,
+            AttrKind::DocComment(..) => continue,
+        };
+        let (a, b) = match &path.segments[..] {
+            &[ref a, ref b] => (a, b),
+            _ => continue,
+        };
+        if a.ident.name == tool_sym && b.ident.name == name_sym {
+            return true;
+        }
+    }
+    false
+}

c2rust-analyze/tests/filecheck.rs

@@ -54,6 +54,7 @@ define_tests! {
     offset2,
     ptrptr1,
     statics,
+    test_attrs,
     trivial,
     type_annotation_rewrite,
 }

c2rust-analyze/tests/filecheck/test_attrs.rs

@@ -0,0 +1,24 @@
+#![feature(register_tool)]
+#![register_tool(c2rust_analyze_test)]
+
+// CHECK-LABEL: type assignment for "f":
+// CHECK: _0 ({{.*}}: *mut i32): *mut i32
+// CHECK: _1 ({{.*}}: x): *mut i32
+#[c2rust_analyze_test::fixed_signature]
+fn f(x: *mut i32) -> *mut i32 {
+    x
+}
+
+// CHECK-LABEL: type assignment for "g":
+// CHECK: _0 ({{.*}}: *mut i32): &i32
+// CHECK: _1 ({{.*}}: x): &i32
+#[c2rust_analyze_test::skip_rewrite]
+fn g(x: *mut i32) -> *mut i32 {
+    x
+}
+
+// CHECK: analysis of DefId({{.*}} ~ test_attrs[{{.*}}]::h) failed: [unknown]: explicit fail_analysis for testing
+#[c2rust_analyze_test::fail_analysis]
+fn h(x: *mut i32) -> *mut i32 {
+    x
+}