Pass the parsed data from rustc_driver to the main thread

Author: devraymondsh

source/loaders/rs_loader/rust/Cargo.toml

@@ -15,3 +15,6 @@ opt-level = "z"
 
 [workspace]
 members = ["parser"]
+
+[dependencies]
+parser = { path = "./parser" }

source/loaders/rs_loader/rust/parser/src/function_parser.rs

@@ -0,0 +1,60 @@
+use rustc_ast::{ast::ItemKind::Fn, Crate, FnKind, FnRetTy, PatKind::Ident, TyKind};
+use std::borrow::Borrow;
+
+#[derive(Debug)]
+pub struct ParsedRustFunctionArguments {
+    name: String,
+    order_number: usize,
+    value_type: TyKind,
+}
+#[derive(Debug)]
+pub struct ParsedRustFunction {
+    name: String,
+    asyncness: rustc_ast::Async,
+    return_type: FnRetTy,
+    arguments_length: usize,
+    arguments: Vec<ParsedRustFunctionArguments>,
+}
+
+unsafe impl Send for ParsedRustFunction {}
+unsafe impl Sync for ParsedRustFunction {}
+
+pub fn parse_functions(parse_source: Crate) -> Vec<ParsedRustFunction> {
+    let mut parsed_rust_functions: Vec<ParsedRustFunction> = Vec::new();
+
+    for parsed_item in parse_source.items.iter() {
+        if let Fn(function) = parsed_item.kind.borrow() {
+            match function.borrow() {
+                FnKind(_the_final, function_signature, _generic, _some) => {
+                    let mut arguments: Vec<ParsedRustFunctionArguments> = Vec::new();
+
+                    let mut i: usize = 0;
+                    for function_input in function_signature.decl.inputs.iter() {
+                        arguments.push(ParsedRustFunctionArguments {
+                            order_number: i,
+                            name: match function_input.pat.kind {
+                                Ident(_by_value, name, _) => name.to_string(),
+                                _ => String::new(),
+                            },
+                            value_type: function_input.ty.kind.clone(),
+                        });
+
+                        i += 1;
+                    }
+
+                    let return_type = function_signature.decl.output.clone();
+
+                    parsed_rust_functions.push(ParsedRustFunction {
+                        arguments,
+                        return_type,
+                        name: parsed_item.ident.to_string(),
+                        asyncness: function_signature.header.asyncness,
+                        arguments_length: function_signature.decl.inputs.len(),
+                    });
+                }
+            }
+        }
+    }
+
+    parsed_rust_functions
+}

source/loaders/rs_loader/rust/parser/src/lib.rs

@@ -14,76 +14,70 @@ use rustc_hash::{FxHashMap, FxHashSet};
 use rustc_session::config;
 use rustc_session::config::CrateType;
 use rustc_span::source_map;
-use std::rc::Rc;
-use std::sync::Mutex;
 
-mod funtions_extractor;
+mod function_parser;
 
 pub struct Source {
-	code: String,
-	filename: String,
+    code: String,
+    filename: String,
 }
 impl Source {
-	pub fn new(code: String, filename: String) -> Source {
-		Source { code, filename }
-	}
+    pub fn new(code: String, filename: String) -> Source {
+        Source { code, filename }
+    }
 }
 
-pub fn extract_functions(source: Source) {
-	let Source { code, filename } = source;
+pub fn parse_functions(source: Source) {
+    let Source { code, filename } = source;
 
-	let config = rustc_interface::Config {
-		// Command line options
-		opts: config::Options {
-			crate_types: vec![CrateType::Cdylib],
-			..config::Options::default()
-		},
-		// cfg! configuration in addition to the default ones
-		crate_cfg: FxHashSet::default(), // FxHashSet<(String, Option<String>)>
-		input: config::Input::Str {
-			name: source_map::FileName::Custom(filename.clone()),
-			input: code.clone(),
-		},
-		input_path: None,  // Option<PathBuf>
-		output_dir: None,  // Option<PathBuf>
-		output_file: None, // Option<PathBuf>
-		file_loader: None, // Option<Box<dyn FileLoader + Send + Sync>>
-		diagnostic_output: rustc_session::DiagnosticOutput::Default,
-		// Set to capture stderr output during compiler execution
-		stderr: None,					// Option<Arc<Mutex<Vec<u8>>>>
-		lint_caps: FxHashMap::default(), // FxHashMap<lint::LintId, lint::Level>
-		// This is a callback from the driver that is called when [`ParseSess`] is created.
-		parse_sess_created: None, //Option<Box<dyn FnOnce(&mut ParseSess) + Send>>
-		// This is a callback from the driver that is called when we're registering lints;
-		// it is called during plugin registration when we have the LintStore in a non-shared state.
-		//
-		// Note that if you find a Some here you probably want to call that function in the new
-		// function being registered.
-		register_lints: None, // Option<Box<dyn Fn(&Session, &mut LintStore) + Send + Sync>>
-		// This is a callback from the driver that is called just after we have populated
-		// the list of queries.
-		//
-		// The second parameter is local providers and the third parameter is external providers.
-		override_queries: None, // Option<fn(&Session, &mut ty::query::Providers<'_>, &mut ty::query::Providers<'_>)>
-		// Registry of diagnostics codes.
-		registry: registry::Registry::new(&rustc_error_codes::DIAGNOSTICS),
-		make_codegen_backend: None,
-	};
+    let config = rustc_interface::Config {
+        // Command line options
+        opts: config::Options {
+            crate_types: vec![CrateType::Cdylib],
+            ..config::Options::default()
+        },
+        // cfg! configuration in addition to the default ones
+        crate_cfg: FxHashSet::default(), // FxHashSet<(String, Option<String>)>
+        input: config::Input::Str {
+            name: source_map::FileName::Custom(filename.clone()),
+            input: code.clone(),
+        },
+        input_path: None,  // Option<PathBuf>
+        output_dir: None,  // Option<PathBuf>
+        output_file: None, // Option<PathBuf>
+        file_loader: None, // Option<Box<dyn FileLoader + Send + Sync>>
+        diagnostic_output: rustc_session::DiagnosticOutput::Default,
+        // Set to capture stderr output during compiler execution
+        stderr: None,                    // Option<Arc<Mutex<Vec<u8>>>>
+        lint_caps: FxHashMap::default(), // FxHashMap<lint::LintId, lint::Level>
+        // This is a callback from the driver that is called when [`ParseSess`] is created.
+        parse_sess_created: None, //Option<Box<dyn FnOnce(&mut ParseSess) + Send>>
+        // This is a callback from the driver that is called when we're registering lints;
+        // it is called during plugin registration when we have the LintStore in a non-shared state.
+        //
+        // Note that if you find a Some here you probably want to call that function in the new
+        // function being registered.
+        register_lints: None, // Option<Box<dyn Fn(&Session, &mut LintStore) + Send + Sync>>
+        // This is a callback from the driver that is called just after we have populated
+        // the list of queries.
+        //
+        // The second parameter is local providers and the third parameter is external providers.
+        override_queries: None, // Option<fn(&Session, &mut ty::query::Providers<'_>, &mut ty::query::Providers<'_>)>
+        // Registry of diagnostics codes.
+        registry: registry::Registry::new(&rustc_error_codes::DIAGNOSTICS),
+        make_codegen_backend: None,
+    };
 
-	let rc = Rc::new(Mutex::new<Option<Vec<funtions_extractor::ParsedRustFunction>>>(None));
+    let parsed_functions = rustc_interface::run_compiler(config, move |compiler| {
+        compiler.enter(move |queries| {
+            // Parse the program and print the syntax tree.
+            let parsed_source: rustc_ast::Crate = queries.parse().unwrap().take();
 
-	let rc_compiler = Rc::clone(&rc);
+            let extracted_functions = function_parser::parse_functions(parsed_source);
 
-	rustc_interface::run_compiler(config, move |compiler| {
-		compiler.enter(move |queries| {
-			// Parse the program and print the syntax tree.
-			let parsed_source: rustc_ast::Crate = queries.parse().unwrap().take();
+            extracted_functions
+        })
+    });
 
-			let extracted_functions = rc_compiler.lock().unwrap();
-
-			extracted_functions = funtions_extractor::functionss_extractor(parsed_source)
-
-			// tx.send(extracted_functions).unwrap();
-		})
-	});
+    println!("Parsed: {:#?}", parsed_functions);
 }

source/loaders/rs_loader/rust/parser/src/parser.rs

@@ -1,4 +1,7 @@
 use crate::{bridge_api, c_char, c_int, c_void, CStr, PathBuf};
+use parser::{self, Source};
+
+use std::fs;
 
 #[no_mangle]
 pub extern "C" fn rs_loader_impl_execution_path(
@@ -17,5 +20,11 @@ pub extern "C" fn rs_loader_impl_execution_path(
             .push(PathBuf::from(path_slice));
     }
 
+    parser::parse_functions(Source::new(
+        fs::read_to_string("/home/raymond/projects/side-projects/metacall/core/build/test.rs")
+            .unwrap(),
+        String::from("test.rs"),
+    ));
+
     0 as c_int
 }