Handle rs crate dependencies.

Signed-off-by: Tricster <[email protected]>

Author: MediosZ

source/loaders/rs_loader/rust/compiler/Cargo.toml

@@ -10,4 +10,5 @@ rustc_private = true
 dlopen = "0.1.8"
 libffi = "3.0.0"
 cargo_toml = "0.11.5"
-lazy_static = "1.4.0"
+lazy_static = "1.4.0"
+itertools = "0.10.3"

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

@@ -4,6 +4,8 @@
 #![feature(box_patterns)]
 #![feature(let_else)]
 #![feature(iter_zip)]
+// allow us to get file prefix
+#![feature(path_file_prefix)]
 extern crate rustc_ast;
 extern crate rustc_ast_pretty;
 extern crate rustc_attr;
@@ -19,13 +21,17 @@ extern crate rustc_session;
 extern crate rustc_span;
 
 use dlopen;
+use itertools::Itertools;
 use rustc_ast::{visit, Impl, Item, ItemKind, VariantData};
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::DefId;
 use rustc_interface::{interface::Compiler, Config, Queries};
 use rustc_middle::hir::exports::Export;
 use rustc_middle::ty::Visibility;
-use rustc_session::config::{self, CrateType, ExternEntry, ExternLocation, Externs, Input};
+use rustc_session::config::{
+    self, CrateType, ErrorOutputType, ExternEntry, ExternLocation, Externs, Input,
+};
+use rustc_session::search_paths::SearchPath;
 use rustc_session::utils::CanonicalizedPath;
 use rustc_span::source_map;
 use std::io::Write;
@@ -393,25 +399,36 @@ impl CompilerCallbacks {
     }
     fn analyze_metadata<'tcx>(&mut self, queries: &'tcx Queries<'tcx>) {
         let mut class_map: HashMap<DefId, Class> = HashMap::new();
-        let crate_num = queries
+        let krates = queries
             .expansion()
             .expect("Unable to get Expansion")
             .peek_mut()
             .1
             .borrow_mut()
             .access(|resolver| {
                 let c_store = resolver.cstore().clone();
-                c_store
-                    .crates_untracked()
-                    .last()
-                    .cloned()
-                    .expect("Unable to get last element of crates.")
+                c_store.crates_untracked()
             });
         queries
             .global_ctxt()
             .expect("Unable to get global ctxt")
             .peek_mut()
             .enter(|ctxt| {
+                // since we are loading a package, input_path should be lib<crate_name>.rlib
+                let crate_name = &self
+                    .source
+                    .input_path
+                    .file_prefix()
+                    .expect("Unable to get file prefix.")
+                    .to_str()
+                    .expect("Unable to cast OsStr to str")[3..];
+                // find our krate
+                let crate_num = krates
+                    .iter()
+                    .find_or_first(|&&x| {
+                        ctxt.crate_name(x) == rustc_span::Symbol::intern(crate_name)
+                    })
+                    .expect("unable to find crate");
                 // parse public functions and structs
                 for child in ctxt.item_children(crate_num.as_def_id()) {
                     let Export {
@@ -466,7 +483,7 @@ impl CompilerCallbacks {
                     }
                 }
                 // after parsing all structs, parse tarit implementations.
-                for trait_impl in ctxt.all_trait_implementations(crate_num) {
+                for trait_impl in ctxt.all_trait_implementations(*crate_num) {
                     use rustc_middle::ty::fast_reject::SimplifiedTypeGen::AdtSimplifiedType;
                     if let Some(AdtSimplifiedType(def_id)) = trait_impl.1 {
                         if let Some(class) = class_map.get_mut(&def_id) {
@@ -519,6 +536,19 @@ impl rustc_driver::Callbacks for CompilerCallbacks {
             }
 
             config.opts.externs = Externs::new(externs);
+            // we hardcode the dependency path for now.
+            let dep_path = self
+                .source
+                .input_path
+                .clone()
+                .parent()
+                .expect("Unable to get parent dir")
+                .join("deps");
+            // println!("include dep: {}", dep_path.display());
+            config.opts.search_paths.push(SearchPath::from_cli_opt(
+                format!("dependency={}", dep_path.display()).as_str(),
+                ErrorOutputType::default(),
+            ));
             // Set up inputs
             let wrapped_script_path = self
                 .source

source/loaders/rs_loader/rust/compiler/src/wrapper/class.rs

@@ -550,6 +550,12 @@ impl ToMetaResult for String {
     }
 }
 
+impl ToMetaResult for &str {
+    fn to_meta_result(self) -> Result<MetacallValue> {
+        Ok(unsafe { metacall_value_create_string(self.as_ptr() as *const i8, self.len()) })
+    }
+}
+
 impl<T> ToMetaResult for Vec<T>
 where
     T: Clone + ToMetaResult,
@@ -717,6 +723,17 @@ impl FromMeta for String {
     }
 }
 
+impl FromMeta for &str {
+    fn from_meta(val: MetacallValue) -> Result<Self> {
+        Ok(unsafe {
+            let s = metacall_value_to_string(val);
+            CStr::from_ptr(s)
+                .to_str()
+                .expect("Unable to cast Cstr to str")
+        })
+    }
+}
+
 impl<T> FromMeta for Vec<T>
 where
     T: Clone + FromMeta,

source/loaders/rs_loader/rust/compiler/src/wrapper/mod.rs

@@ -140,11 +140,11 @@ pub fn generate_wrapper(callbacks: CompilerCallbacks) -> std::io::Result<Compile
             let source_dir = path.parent().expect("input path has no parent");
 
             // create metacall_class file
-            println!("create: {:?}", source_dir.join("metacall_class.rs"));
+            // println!("create: {:?}", source_dir.join("metacall_class.rs"));
             let mut class_file = File::create(source_dir.join("metacall_class.rs"))?;
             let bytes = include_bytes!("class.rs");
             class_file.write_all(bytes)?;
-            println!("open: {:?}", source_dir.join("metacall_wrapped_package.rs"));
+            // println!("open: {:?}", source_dir.join("metacall_wrapped_package.rs"));
             let mut wrapper_file = std::fs::OpenOptions::new()
                 .append(true)
                 .open(source_dir.join("metacall_wrapped_package.rs"))?;

source/loaders/rs_loader/rust/src/lifecycle/initialize.rs

@@ -7,7 +7,9 @@ pub extern "C" fn rs_loader_impl_initialize(
     loader_impl: *mut c_void,
     _config: *mut c_void,
 ) -> *mut c_void {
-    let boxed_loader_lifecycle_state = Box::new(api::LoaderLifecycleState::new(Vec::new()));
+    // add current_dir to execution path to allow relative search path
+    let search_paths = vec![std::env::current_dir().expect("Unable to get current dir")];
+    let boxed_loader_lifecycle_state = Box::new(api::LoaderLifecycleState::new(search_paths));
     compiler::initialize();
 
     api::define_type(