Merge pull request #323 from MediosZ/fix-rs-package

Handle rs crate dependencies.

Author: viferga

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/ast.rs

@@ -27,7 +27,7 @@ pub fn handle_ty(ty: &rustc_ast::Ty) -> FunctionParameter {
                 "f32" => result.ty = FunctionType::f32,
                 "f64" => result.ty = FunctionType::f64,
                 "bool" => result.ty = FunctionType::bool,
-                "str" => result.ty = FunctionType::str,
+                "str" => result.ty = FunctionType::String,
                 "Vec" => {
                     result.ty = FunctionType::Array;
                     if let Some(args) = &segment.args {

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

@@ -4,7 +4,7 @@ use std::cell::RefCell;
 use std::cell::RefMut;
 use std::collections::HashMap;
 use std::convert::TryInto;
-use std::ffi::CStr;
+use std::ffi::{CStr, CString};
 use std::fmt;
 use std::sync::Arc;
 type Result<T, E = i32> = core::result::Result<T, E>;
@@ -546,7 +546,18 @@ impl ToMetaResult for f64 {
 
 impl ToMetaResult for String {
     fn to_meta_result(self) -> Result<MetacallValue> {
-        Ok(unsafe { metacall_value_create_string(self.as_ptr() as *const i8, self.len()) })
+        let length = self.len();
+        let cstring = CString::new(self).expect("Unable to cast String to CString");
+        let ptr = cstring.as_ptr();
+        Ok(unsafe { metacall_value_create_string(ptr, length) })
+    }
+}
+
+impl ToMetaResult for &str {
+    fn to_meta_result(self) -> Result<MetacallValue> {
+        let cstring = CString::new(self).expect("Unable to cast str to CString");
+        let ptr = cstring.as_ptr();
+        Ok(unsafe { metacall_value_create_string(ptr, self.len()) })
     }
 }
 
@@ -717,6 +728,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(

source/ports/py_port/metacall/api.py

@@ -164,6 +164,8 @@ def generate_module(handle_name, handle):
 		'dll': 'cs',
 		# WebAssembly Loader
 		'wasm': 'wasm',
+		# Rust Loader
+		'rlib': 'rs'
 	}
 
 	# Try to load it as a Python module

source/scripts/rust/CMakeLists.txt

@@ -10,3 +10,4 @@ list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
 include(RustProject)
 
 add_subdirectory(basic)
+add_subdirectory(melody)

source/scripts/rust/basic/source/basic.rs

@@ -56,3 +56,12 @@ pub fn string_len(s: String) -> usize {
 pub fn new_string(idx: i32) -> String {
     format!("get number {idx}")
 }
+
+pub fn str_slice(s: &str) -> &str {
+    if s.len() < 4 {
+        return s;
+    } else {
+        println!("{:?}", &s[0..3]);
+        &s[0..3]
+    }
+}

source/scripts/rust/cmake/RustProject.cmake

@@ -116,3 +116,63 @@ function(rust_package target version script)
 
 endfunction()
 
+function(cargo_package target version)
+
+	# Configuration
+	set(PACKAGE_NAME		${target})
+	set(PACKAGE_VERSION		${version})
+	set(PACKAGE_OUTPUT		"${CMAKE_CURRENT_BINARY_DIR}/build/timestamp")
+
+	set(configuration ${RUST_PROJECT_CONFIG_PATH}/RustProject.cmake.in)
+	set(language "rust")
+	# Define upper and lower versions of the language
+	string(TOLOWER ${language} language_lower)
+
+	# Define project target name
+	set(custom_target "${language_lower}-${target}")
+
+	# Define target for the configuration
+	set(PACKAGE_TARGET "${custom_target}")
+
+	# Create project file
+	configure_file(${configuration} ${custom_target}-config.cmake @ONLY)
+
+	# Set custom target
+	add_custom_target(${custom_target} ALL)
+
+	#
+	# Deployment
+	#
+
+	# Install cmake script config
+	#install(FILES  "${CMAKE_CURRENT_BINARY_DIR}/${custom_target}/${custom_target}-config.cmake"
+	#	DESTINATION ${INSTALL_CMAKE}/${custom_target}
+	#	COMPONENT   runtime
+	#)
+
+	# CMake config
+	#install(EXPORT  ${custom_target}-export
+	#	NAMESPACE   ${META_PROJECT_NAME}::
+	#	DESTINATION ${INSTALL_CMAKE}/${custom_target}
+	#	COMPONENT   dev
+	#)
+
+	# Set project properties
+	set_target_properties(${custom_target}
+		PROPERTIES
+		${DEFAULT_PROJECT_OPTIONS}
+		FOLDER "${IDE_FOLDER}/${language}"
+	)
+
+	# Compile project
+	add_custom_command(TARGET ${custom_target} PRE_BUILD
+		# fix the version of rustc
+		COMMAND ${Rust_RUSTUP_EXECUTABLE} default nightly-2021-12-04
+		COMMAND ${Rust_CARGO_EXECUTABLE} build 
+		--manifest-path ${CMAKE_CURRENT_SOURCE_DIR}/Cargo.toml 
+		--target-dir ${LOADER_SCRIPT_PATH}
+	)
+
+	# Include generated project file
+	include(${CMAKE_CURRENT_BINARY_DIR}/${custom_target}-config.cmake)
+endfunction()