TOML File Support

crates/sniff-test/Cargo.toml

@@ -16,6 +16,7 @@ serde = { version = "1", features = ["derive"] }
 regex = "1.11.2"
 anyhow = "1.0.100"
 itertools = "0.14.0"
+toml = "0.9.8"
 log = "0.4.28"
 
 [build-dependencies]

crates/sniff-test/src/annotations/mod.rs

@@ -1,6 +1,9 @@
 //! The utilities needed to find and parse code annotations.
 use crate::{
-    annotations::doc::{Attributeable, DocStr, get_doc_str},
+    annotations::{
+        doc::{Attributeable, DocStr, get_doc_str},
+        toml::TomlAnnotation,
+    },
     properties::Property,
 };
 use regex::Regex;
@@ -18,6 +21,7 @@ use std::{any::TypeId, borrow::Borrow, collections::HashMap, fmt::Debug, hash::H
 
 mod doc;
 mod span;
+pub mod toml;
 
 #[derive(Debug)]
 pub enum PropertyViolation {
@@ -67,17 +71,22 @@ impl DefAnnotation {
 /// annotated.
 pub fn parse_fn_def<P: Property>(
     tcx: TyCtxt<'_>,
+    toml_annotation: &TomlAnnotation,
     fn_def: impl Into<rustc_span::def_id::DefId>,
     property: P,
 ) -> Option<DefAnnotation> {
-    // TODO: add yash's logic here for checking the override toml file first.
-
-    // 1. get the doc string
+    // 1. Get the DefId
     let fn_def: rustc_span::def_id::DefId = fn_def.into();
-    let doc_str = get_doc_str(fn_def, tcx)?;
 
-    // 2. parse the doc string based on the property
-    parse_fn_def_src(doc_str, property)
+    // 2. Check if we have a TOML override for this function
+    if let Some(toml_str) = toml_annotation.get_requirements_string(&tcx.def_path_str(fn_def)) {
+        parse_fn_def_toml(toml_str, property)
+    } else {
+        // 3. No TOML override found, get the doc string from source code
+        let doc_str = get_doc_str(fn_def, tcx)?;
+        // 4. parse the doc string based on the property
+        parse_fn_def_src(doc_str, property)
+    }
 }
 
 fn parent_block_expr<'tcx>(
@@ -136,3 +145,15 @@ fn parse_fn_def_src<P: Property>(doc_str: DocStr, property: P) -> Option<DefAnno
             source: AnnotationSource::DocComment(doc_str.span_of_chars(found.range())),
         })
 }
+
+fn parse_fn_def_toml<P: Property>(toml_str: &str, property: P) -> Option<DefAnnotation> {
+    property
+        .fn_def_regex()
+        .find(toml_str)
+        .map(|found| DefAnnotation {
+            property_name: P::property_name(),
+            local_violation_annotation: PropertyViolation::Unconditional,
+            text: toml_str[found.end()..].to_string(),
+            source: AnnotationSource::TomlOverride,
+        })
+}

crates/sniff-test/src/annotations/toml.rs

@@ -0,0 +1,104 @@
+//! Module for parsing annotations from TOML files.
+//! Each top-level TOML table key is a function name with a `requirements` string.
+//! ```toml
+//! [function_name]
+//! requirements = """
+//! # Safety
+//! * 'requirement 1': Description of requirement 1
+//! * 'requirement 2': Description of requirement 2
+//! """
+//! ```
+
+use std::collections::HashMap;
+
+use rustc_span::{
+    DUMMY_SP,
+    source_map::{Spanned, respan},
+};
+
+use crate::annotations::DefAnnotation;
+
+/// Struct encapsulating annotations parsed from a TOML file.
+#[derive(Default)]
+pub struct TomlAnnotation {
+    function_to_requirements_string: HashMap<String, String>,
+}
+
+/// Errors that can occur when parsing TOML annotations.
+#[derive(Debug)]
+pub enum TomlParseError {
+    Io(std::io::Error),
+    Toml(toml::de::Error),
+    Schema(String),
+}
+
+impl From<std::io::Error> for TomlParseError {
+    fn from(err: std::io::Error) -> Self {
+        TomlParseError::Io(err)
+    }
+}
+
+impl From<toml::de::Error> for TomlParseError {
+    fn from(err: toml::de::Error) -> Self {
+        TomlParseError::Toml(err)
+    }
+}
+
+impl TomlAnnotation {
+    /// Parses a TOML annotation file and returns a [`TomlAnnotation`] struct.
+    /// Fails on any errors, never returning partial results.
+    /// If the file does not exist, returns an empty [`TomlAnnotation`].
+    /// TODO: Use real spans if possible.
+    pub fn from_file<P: AsRef<std::path::Path>>(path: P) -> Result<Self, TomlParseError> {
+        // Get the contents of the TOML file
+        let text = match std::fs::read_to_string(path) {
+            Ok(text) => text,
+            Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
+                // File does not exist, return empty annotations
+                return Ok(TomlAnnotation::default());
+            }
+            Err(e) => return Err(TomlParseError::Io(e)),
+        };
+
+        // Parse the TOML file into a map from function names to requirement strings
+        let value: toml::Value = toml::from_str(&text)?;
+        let Some(table) = value.as_table() else {
+            return Err(TomlParseError::Schema(
+                "Expected a TOML table at the top level".to_string(),
+            ));
+        };
+
+        // Parse each function's requirements
+        let mut function_to_requirements_string: HashMap<String, String> = HashMap::new();
+        for (function_name, value) in table {
+            let Some(inner_table) = value.as_table() else {
+                return Err(TomlParseError::Schema(format!(
+                    "Expected a TOML table for function {function_name}"
+                )));
+            };
+            let Some(requirements_value) = inner_table.get("requirements") else {
+                return Err(TomlParseError::Schema(format!(
+                    "Expected a 'requirements' string for function {function_name}"
+                )));
+            };
+            let Some(requirements_string) = requirements_value.as_str() else {
+                return Err(TomlParseError::Schema(format!(
+                    "Expected 'requirements' to be a string for function {function_name}"
+                )));
+            };
+
+            function_to_requirements_string
+                .insert(function_name.clone(), requirements_string.to_string());
+        }
+
+        // Return the parsed annotations
+        Ok(TomlAnnotation {
+            function_to_requirements_string,
+        })
+    }
+
+    /// Retrieves the requirements for a given function name, if any.
+    pub fn get_requirements_string(&self, function_name: &str) -> Option<&String> {
+        self.function_to_requirements_string.get(function_name)
+    }
+}

crates/sniff-test/src/check/mod.rs

@@ -1,15 +1,21 @@
-use itertools::Itertools;
-use rustc_errors::{Diag, DiagCtxtHandle};
-use rustc_hir::def_id::{DefId, LocalDefId};
-use rustc_middle::ty::TyCtxt;
-use rustc_span::{ErrorGuaranteed, source_map::Spanned, sym::todo_macro};
-
 use crate::{
-    annotations::{self, parse_expr},
+    annotations::{
+        self, parse_expr,
+        toml::{TomlAnnotation, TomlParseError},
+    },
     properties::{self, Axiom, FoundAxiom, Property},
     reachability::{self, CallsWObligations, LocallyReachable},
     utils::SniffTestDiagnostic,
 };
+use itertools::Itertools;
+use rustc_errors::{Diag, DiagCtxtHandle};
+use rustc_hir::def_id::{DefId, LocalDefId};
+use rustc_middle::ty::TyCtxt;
+use rustc_span::{
+    DUMMY_SP, ErrorGuaranteed,
+    source_map::{Spanned, respan},
+    sym::todo_macro,
+};
 
 mod err;
 mod expr;
@@ -19,6 +25,20 @@ pub fn check_properly_annotated<P: Property>(
     tcx: TyCtxt,
     property: P,
 ) -> Result<(), ErrorGuaranteed> {
+    // Parse TOML annotations from file
+    let toml_path = "sniff-test.toml";
+    let toml_annotations = match TomlAnnotation::from_file(toml_path) {
+        Ok(annotations) => annotations,
+        Err(e) => {
+            tcx.dcx()
+                .struct_warn(format!(
+                    "Failed to parse TOML annotations from {toml_path}: {e:?}"
+                ))
+                .emit();
+            TomlAnnotation::default()
+        }
+    };
+
     let entry = reachability::analysis_entry_points::<P>(tcx);
 
     // Debug print all our entries and where they are in the src
@@ -40,19 +60,20 @@ pub fn check_properly_annotated<P: Property>(
 
     // For all reachable local function definitions, ensure their axioms align with their annotations.
     for func in reachable {
-        check_function_properties(tcx, func, property)?;
+        check_function_properties(tcx, &toml_annotations, func, property)?;
     }
 
     Ok(())
 }
 
 fn check_function_properties<P: Property>(
     tcx: TyCtxt,
+    toml_annotations: &TomlAnnotation,
     func: LocallyReachable,
     property: P,
 ) -> Result<(), ErrorGuaranteed> {
     // Look for the local annotation
-    let annotation = annotations::parse_fn_def(tcx, func.reach, property);
+    let annotation = annotations::parse_fn_def(tcx, toml_annotations, func.reach, property);
 
     // If the function we're analyzing is directly annotated, we trust the user's annotation
     // and don't need to analyze its body locally. Vitally, we'll still explore functions it calls
@@ -71,10 +92,11 @@ fn check_function_properties<P: Property>(
     log::debug!("fn {:?} has obligations {:?}", func.reach, annotation);
 
     // Find all calls that have obligations.
-    let unjustified_calls = reachability::find_calls_w_obligations(tcx, &func, property)
-        // Filter those with only callsites that haven't been justified.
-        .filter_map(only_unjustified_callsites(tcx, func.reach, property))
-        .collect::<Vec<_>>();
+    let unjustified_calls =
+        reachability::find_calls_w_obligations(tcx, toml_annotations, &func, property)
+            // Filter those with only callsites that haven't been justified.
+            .filter_map(only_unjustified_callsites(tcx, func.reach, property))
+            .collect::<Vec<_>>();
 
     // If we have obligations, we've dismissed them