feat: allowing for multiple rust source files.

Author: madhav-madhusoodanan

crates/stdarch-gen-wasm/src/cli.rs

@@ -9,5 +9,5 @@ pub struct Args {
 
     /// The Rust source file path argument
     #[arg(short, long)]
-    pub rust: String,
+    pub rust: Vec<String>,
 }

crates/stdarch-gen-wasm/src/main.rs

@@ -14,7 +14,7 @@ use crate::structs::{CIntrinsic, RustIntrinsic};
 use crate::utils::leaf_nodes_from_grammar_name;
 
 /// Read the Rust source code and returns its AST
-fn process_rust_code(source: &String) -> (String, Tree) {
+fn process_rust_code(source: String) -> (String, Tree) {
     let mut parser = Parser::new();
     parser
         .set_language(&tree_sitter_rust::LANGUAGE.into())
@@ -31,7 +31,7 @@ fn process_rust_code(source: &String) -> (String, Tree) {
 }
 
 /// Reads the C source code and returns its AST
-fn process_c_code(source: &String) -> (String, Tree) {
+fn process_c_code(source: String) -> (String, Tree) {
     let mut parser = Parser::new();
     parser
         .set_language(&tree_sitter_c::LANGUAGE.into())
@@ -76,7 +76,7 @@ rust-return-type = {}",
 }
 
 /// Create the spec sheet.
-/// 
+///
 /// Fields that would be present in the spec sheet:
 /// 1. c-intrinsic-name
 /// 2. c-arguments
@@ -92,22 +92,33 @@ fn main() {
     // Read the file-paths from CLI arguments
     // obtain the tree of tokens from the code
     let args = Args::parse();
-    let (c_source, c_tree) = process_c_code(&args.c);
-    let (rust_source, rust_tree) = process_rust_code(&args.rust);
-
+    let (c_source, c_tree) = process_c_code(args.c);
     let preproc_node = c_tree.root_node();
 
     let c_intrinsics = leaf_nodes_from_grammar_name(preproc_node, "function_definition")
         .iter()
         .map(|&node| CIntrinsic::new(node, &c_source))
         .collect::<Vec<_>>();
 
-    let mut rust_cursor = rust_tree.root_node().walk();
-    let rust_intrinsics = rust_tree
-        .root_node()
-        .children(&mut rust_cursor)
-        .filter(|node| node.grammar_name() == "function_item")
-        .map(|node| RustIntrinsic::new(node, &rust_source))
+    let rust_intrinsics_interim = args
+        .rust
+        .into_iter()
+        .map(|path| process_rust_code(path))
+        .collect::<Vec<_>>();
+
+    let rust_intrinsics = rust_intrinsics_interim
+        .iter()
+        .map(|(rust_source, rust_tree)| {
+            let rust_source_str = rust_source.as_str();
+            let mut rust_cursor = rust_tree.root_node().walk();
+            rust_tree
+                .root_node()
+                .children(&mut rust_cursor)
+                .filter(|node| node.grammar_name() == "function_item")
+                .map(|node| RustIntrinsic::new(node, rust_source_str))
+                .collect::<Vec<_>>()
+        })
+        .flatten()
         .collect::<Vec<_>>();
 
     let matching_intrinsics = match_intrinsic_definitions(&c_intrinsics, &rust_intrinsics);

crates/stdarch-gen-wasm/src/matcher.rs

@@ -3,7 +3,7 @@ use std::collections::HashSet;
 use crate::structs::{CIntrinsic, RustIntrinsic};
 
 /// Matches the set of intrinsics in Rust to their C counterpart.
-/// 
+///
 /// This function assumes that the list of Rust definitions
 /// will be a subset of the list of definitions in C.
 pub fn match_intrinsic_definitions<'a>(
@@ -33,10 +33,10 @@ pub fn match_intrinsic_definitions<'a>(
 fn match_intrinsic_definition(c_definition: &str, rust_definition: &str) -> bool {
     // Most intrinsics in C are of the format: `wasm_v128_load`.
     // Its Rust counterpart is named `v128_load`.
-    // 
+    //
     // Another one is `wasm_i8x16_const_splat`, and its Rust counterpart is `i8x16_splat`.
-    // 
-    // The pattern that is observed is that, each keyword "chunk" that constructs 
+    //
+    // The pattern that is observed is that, each keyword "chunk" that constructs
     // the intrinsic name in Rust will also be used to construct the intrinsic name in C.
     // These names are constructed by joining the chunks with an underscore (_).
 

crates/stdarch-gen-wasm/src/structs.rs

@@ -22,14 +22,14 @@ pub struct CIntrinsic<'a> {
 }
 
 impl<'a> CIntrinsic<'a> {
-    pub fn new(node: Node, source: &'a String) -> Self {
+    pub fn new(node: Node, source: &'a str) -> Self {
         // Take an intrinsic definition for example:
-        // 
+        //
         // static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_u32x4_make(uint32_t __c0, uint32_t __c1, uint32_t __c2, uint32_t __c3) {...}
-        // 
+        //
         // For a C intrinsic, the immediate children
         // would have their grammar names as:
-        // 
+        //
         // "storage_class_specifier" (which is `static`)
         // "storage_class_specifier" (which is `__inline__`)
         // "identifier" (which is `v128_t`. The parser doesn't recognize that it is a type, instead thinks that it is an identifier)
@@ -54,7 +54,7 @@ impl<'a> CIntrinsic<'a> {
 
         // The immediate children of the `function_declarator` node would have
         // their grammar as follows:
-        // 
+        //
         // "identifier" (which is the intrinsic name)
         // "parameter_list" (which is the arguments to the intrinsic)
         let declarator_node = node
@@ -64,27 +64,27 @@ impl<'a> CIntrinsic<'a> {
 
         // The immediate children of a `parameter_list` node would have
         // their grammar as follows (assuming 2 arguments):
-        // 
+        //
         // "(" -> The opening bracket that denotes the start of the arguments definition
         // "parameter_declaration" -> The definition for the first argument
         // "," -> The comma that separates the first and the second arguments
         // "parameter_declaration" -> The definition for the first argument
         // ")"  -> The closing bracket that denotes the start of the arguments definition
-        // 
+        //
         // Each node with grammar name as `parameter_declaration` could have their children as
         // (incase of `int x`):
         // 1. "primitive_type" -> Points to `int`
         // 2. "indentifier" -> Points to `x`
-        // 
+        //
         // or have (incase of `v128_t x`):
         // 1. "identifier" -> Points to `v128_t` which is actually a type (but the parser is unaware of it)
         // 2. "identifier" -> Points to `x`
-        // 
+        //
         // or have (incase of `const void *__mem`):
         // 1. "type_qualifier" -> Points to `const`
         // 2. "primitive_type" -> Points to `void`
         // 3. "pointer_declarator" -> breaks down into "*" and "identifier" (which is `__mem`)
-        //  
+        //
         let intrinsic_name = source
             .get(
                 declarator_node
@@ -108,9 +108,9 @@ impl<'a> CIntrinsic<'a> {
                     // Since the type could be identified as either `primitive_type, `indentifier`,
                     // or a combination of `type_qualifier`, `primitive_type` and `*` (in the case of "const void *")
                     // this approach first calculates the end index (which is right before the start of an argument variable)
-                    // 
+                    //
                     // And then searches backwards until it finds a break (either a comma
-                    // or the opening bracket). The entire portion contained within this range 
+                    // or the opening bracket). The entire portion contained within this range
                     // is then considered as the type of the argument.
                     let end_index = arg_name_node.byte_range().start;
                     let start_index = source
@@ -149,10 +149,10 @@ impl<'a> CIntrinsic<'a> {
 }
 
 impl<'a> RustIntrinsic<'a> {
-    pub fn new(node: Node, source: &'a String) -> Self {
+    pub fn new(node: Node, source: &'a str) -> Self {
         // For a Rust intrinsic, the immediate children
         // would have their grammar names as:
-        // 
+        //
         // 1. "visibility_modifier"  (for `pub`)
         // 2. "function_modifiers" (for `unsafe`. May not always be present)
         // 3. "fn" (the actual keyword `fn`)
@@ -162,7 +162,7 @@ impl<'a> RustIntrinsic<'a> {
         // 7. "->" (the arrow used to specify return type)
         // 8. "identifier" (the return type of the function)
         // 9. "block" (the body of the function)
-        // 
+        //
         let mut cursor = node.walk();
         let intrinsic_name = source
             .get(
@@ -196,14 +196,13 @@ impl<'a> RustIntrinsic<'a> {
         if let Some(generic_args) = generic_args {
             // The children of this node have their grammar_names as the following
             // (assuming 2 generic arguments):
-            // 
+            //
             // "<" (The opening angle bracket that starts the generic arguments definition)
             // "const_parameter" (The first const generic argument)
             // "," (The comma that denotes the end of definition of the first const generic argument)
             // "const_parameter" (The second const generic argument)
             // ">" (The closing angle bracket that concludes the generic arguments definition)
-            // 
-
+            //
             (generic_arg_names, generic_arg_types) = generic_args
                 .children(&mut cursor)
                 .filter(|arg| arg.grammar_name() == "const_parameter")
@@ -225,13 +224,12 @@ impl<'a> RustIntrinsic<'a> {
         if let Some(args) = args {
             // The children of this node have their grammar_names as the following
             // (assuming 2 generic arguments):
-            // 
+            //
             // "(" (The opening circular bracket that starts the arguments definition)
             // "parameter" (The first argument)
             // "," (The comma that denotes the end of definition of the first argument)
             // "parameter" (The second argument)
             // ")" (The closing circular bracket that concludes the arguments definition)
-            // 
             (arg_names, arg_types) = args
                 .children(&mut cursor)
                 .filter(|arg| arg.grammar_name() == "parameter")

crates/stdarch-gen-wasm/src/utils.rs

@@ -1,6 +1,6 @@
 use tree_sitter::Node;
 
-/// Recursively searches the node and its children for a node 
+/// Recursively searches the node and its children for a node
 /// that matches its grammar name, using Depth-first search.
 pub fn leaf_nodes_from_grammar_name<'a>(node: Node<'a>, name: &str) -> Vec<Node<'a>> {
     if node.grammar_name() == name {