Feat: implement #[precond] #[hazard] and #[option] proc-macros

demo/rustc_driver/Cargo.toml

@@ -9,5 +9,9 @@ path = "src/bin/cargo-safe-tool.rs"
 
 [dependencies]
 
+[workspace]
+members = ["safety-tool-lib","safety-tool-macro", "safety-tool-parser"]
+exclude = ["tests/basic"]
+
 [package.metadata.rust-analyzer]
 rustc_private = true

demo/rustc_driver/run.sh

@@ -4,14 +4,14 @@ set -ex
 export LD_LIBRARY_PATH=$(rustc --print sysroot)/lib
 
 cargo build
-export TAG_STD=$PWD/target/debug/safe-tool
-export CARGO_TAG_STD=$PWD/target/debug/cargo-safe-tool
+export SAFE_TOOL=$PWD/target/debug/safe-tool
+export CARGO_SAFE_TOOL=$PWD/target/debug/cargo-safe-tool
 
 # Test basic demo
 cd ./tests/basic
 
 cargo clean
 
 # Analyze the lib and bin crates.
-# Same as `cargo tag-std` when tag-std and cargo-tag-std are installed.
-$CARGO_TAG_STD
+# Same as `cargo safe-tool` when tag-std and cargo-safe-tool are installed.
+$CARGO_SAFE_TOOL

demo/rustc_driver/safety-tool-lib/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "safety-tool-lib"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+safety-tool-macro = { path = "../safety-tool-macro" }
+safety-tool-parser = { path = "../safety-tool-parser" }

demo/rustc_driver/safety-tool-lib/src/lib.rs

@@ -0,0 +1,5 @@
+pub use safety_tool_parser;
+
+pub mod safety {
+    pub use safety_tool_macro::{hazard, option, precond};
+}

demo/rustc_driver/safety-tool-macro/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "safety-tool-macro"
+version = "0.1.0"
+edition = "2024"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+safety-tool-parser = { path = "../safety-tool-parser" }
+
+[dev-dependencies]
+expect-test = "1.5.1"

demo/rustc_driver/safety-tool-macro/src/lib.rs

@@ -0,0 +1,33 @@
+use proc_macro::TokenStream;
+use safety_tool_parser::{
+    precond::{FnItem, SafetyAttrArgs},
+    syn::*,
+};
+
+#[proc_macro_attribute]
+pub fn precond(attr: TokenStream, item: TokenStream) -> TokenStream {
+    generate("precond", attr, item)
+}
+
+#[proc_macro_attribute]
+pub fn hazard(attr: TokenStream, item: TokenStream) -> TokenStream {
+    generate("hazard", attr, item)
+}
+
+#[proc_macro_attribute]
+pub fn option(attr: TokenStream, item: TokenStream) -> TokenStream {
+    generate("option", attr, item)
+}
+
+fn generate(kind: &str, attr: TokenStream, item: TokenStream) -> TokenStream {
+    let item = parse_macro_input!(item as ItemFn);
+    let attr = parse_macro_input!(attr as SafetyAttrArgs);
+
+    let doc_comments = attr.generate_doc_comments();
+    let safety_tool_attr = attr.generate_safety_tool_attribute(kind);
+
+    let mut fn_item = FnItem::new(item);
+    fn_item.insert_attributes_to_the_back(doc_comments);
+    fn_item.insert_attributes_to_the_back(safety_tool_attr);
+    fn_item.into_token_stream().into()
+}

demo/rustc_driver/safety-tool-macro/tests/memo.rs

@@ -0,0 +1,10 @@
+use expect_test::expect_file;
+use std::process::Command;
+
+#[test]
+fn basic() {
+    let stdout =
+        Command::new("cargo").args(["expand", "--test", "memo_testcase"]).output().unwrap();
+    let expanded = std::str::from_utf8(&stdout.stdout).unwrap();
+    expect_file!["snapshots/memo_testcase.rs"].assert_eq(expanded);
+}

demo/rustc_driver/safety-tool-macro/tests/memo_testcase.rs

@@ -0,0 +1,60 @@
+#![feature(register_tool)]
+#![register_tool(Safety)]
+#![allow(dead_code, non_snake_case)]
+use safety_tool_macro as safety;
+
+#[safety::precond(Property, memo = "This is a single line.")]
+fn single_line() {}
+
+#[safety::hazard(Property, memo = "Line 1.\nLine 2.")]
+fn multi_lines() {}
+
+#[safety::option(
+    Property,
+    memo = "
+Line 1.
+Line 2."
+)]
+fn multi_lines2() {}
+
+/// Line 1.
+#[safety::precond(
+    Property,
+    memo = "
+    Line 2.
+    Line 3."
+)]
+fn multi_lines3() {}
+
+#[doc = " Line 1."]
+#[safety::hazard(
+    Property,
+    memo = "
+    Line 2.
+    Line 3."
+)]
+#[safety::option(Property, memo = "Line 4.")]
+fn multi_lines4() {}
+
+//  WARNING: dont't put `#[doc]` (i.e. `///`) after `#[safety(memo)]`
+// because the doc order will be messed up.
+
+#[safety::precond(
+    Property,
+    memo = "
+    Line 1.
+    Line 2."
+)]
+#[doc = " Line 3."] // don't do this.
+fn multi_lines3_DONT_DO_THIS() {}
+
+/// Line 1.
+#[safety::precond(Property, memo = "Line 2.\nLine 3.")]
+#[doc = " Line 4."] // don't do this.
+fn multi_lines4_DONT_DO_THIS() {}
+
+/// Line 1.
+#[safety::precond(Property, memo = "Line 2.\nLine 3.")]
+#[safety::precond(Property, memo = "Line 4.")]
+#[doc = " Line 5."] // don't do this.
+fn multi_lines5_DONT_DO_THIS() {}

demo/rustc_driver/safety-tool-macro/tests/snapshots/memo_testcase.rs

@@ -0,0 +1,66 @@
+#![feature(prelude_import)]
+#![feature(register_tool)]
+#![register_tool(Safety)]
+#![allow(dead_code, non_snake_case)]
+#[prelude_import]
+use std::prelude::rust_2024::*;
+#[macro_use]
+extern crate std;
+use safety_tool_macro as safety;
+/// This is a single line.
+#[Safety::inner(Property, kind = "precond", memo = "This is a single line.")]
+fn single_line() {}
+/// Line 1.
+/// Line 2.
+#[Safety::inner(Property, kind = "hazard", memo = "Line 1.\nLine 2.")]
+fn multi_lines() {}
+/// Line 1.
+/// Line 2.
+#[Safety::inner(Property, kind = "option", memo = "
+Line 1.
+Line 2.")]
+fn multi_lines2() {}
+/// Line 1.
+/// Line 2.
+/// Line 3.
+#[Safety::inner(Property, kind = "precond", memo = "
+    Line 2.
+    Line 3.")]
+fn multi_lines3() {}
+/// Line 1.
+/// Line 2.
+/// Line 3.
+#[Safety::inner(Property, kind = "hazard", memo = "
+    Line 2.
+    Line 3.")]
+/// Line 4.
+#[Safety::inner(Property, kind = "option", memo = "Line 4.")]
+fn multi_lines4() {}
+/// Line 3.
+/// Line 1.
+/// Line 2.
+#[Safety::inner(Property, kind = "precond", memo = "
+    Line 1.
+    Line 2.")]
+fn multi_lines3_DONT_DO_THIS() {}
+/// Line 1.
+/// Line 4.
+/// Line 2.
+/// Line 3.
+#[Safety::inner(Property, kind = "precond", memo = "Line 2.\nLine 3.")]
+fn multi_lines4_DONT_DO_THIS() {}
+/// Line 1.
+/// Line 5.
+/// Line 2.
+/// Line 3.
+#[Safety::inner(Property, kind = "precond", memo = "Line 2.\nLine 3.")]
+/// Line 4.
+#[Safety::inner(Property, kind = "precond", memo = "Line 4.")]
+fn multi_lines5_DONT_DO_THIS() {}
+#[rustc_main]
+#[coverage(off)]
+#[doc(hidden)]
+pub fn main() -> () {
+    extern crate test;
+    test::test_main_static(&[])
+}

demo/rustc_driver/safety-tool-parser/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "safety-tool-parser"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+quote = "1"
+syn = { version = "2", features = ["extra-traits", "full"] }
+proc-macro2 = "1"

demo/rustc_driver/safety-tool-parser/src/lib.rs

@@ -0,0 +1,4 @@
+pub use quote;
+pub use syn;
+
+pub mod precond;

demo/rustc_driver/safety-tool-parser/src/precond/keep_doc_order.rs

@@ -0,0 +1,40 @@
+//! `#[safety]` attribute will generate safety doc (`#[doc]`), which will bring interactions
+//! with `#[doc]` from user.
+//!
+//! Consider the following doc strings:
+//!
+//! ```ignore
+//! /// Beginning
+//! #[safety(memo = "safety doc")]
+//! /// Tailling
+//! ```
+//!
+//! It'd be pretty bad if the order is messed up.
+//!
+//! Thus this module should solve this problem by ensuring the doc attribute
+//! emission is inserted to the tail. Because attribute macros are handled
+//! from top to buttom, this hopefully keeps doc orders.
+
+use proc_macro2::TokenStream;
+use quote::ToTokens;
+use syn::{parse::Parser, *};
+
+pub struct FnItem {
+    pub fn_: ItemFn,
+}
+
+impl FnItem {
+    pub fn new(fn_: ItemFn) -> Self {
+        FnItem { fn_ }
+    }
+
+    pub fn insert_attributes_to_the_back(&mut self, tokens: TokenStream) {
+        // Double check the given tokens are attributes.
+        let attrs = Attribute::parse_outer.parse2(tokens).unwrap();
+        self.fn_.attrs.extend(attrs);
+    }
+
+    pub fn into_token_stream(self) -> TokenStream {
+        self.fn_.to_token_stream()
+    }
+}