@tishlang/tish 1.4.2 → 1.6.0

package/crates/tish_eval/src/eval.rs

@@ -512,9 +512,18 @@ impl Evaluator {
 
     /// Load and evaluate a module, returning its exports object. Uses cache.
     fn load_module(&mut self, from: &str) -> Result<Value, EvalError> {
+        if from.starts_with("cargo:") {
+            return Err(EvalError::Error(
+                "cargo:… imports are only supported by `tish build` with the Rust native backend.".into(),
+            ));
+        }
         if from.starts_with("tish:") {
             return self.load_builtin_module(from);
         }
+        // Scoped native modules (e.g. `@tishlang/waterui`) registered via `TishNativeModule::virtual_builtin_modules`.
+        if self.virtual_builtins.borrow().get(from).is_some() {
+            return self.load_builtin_module(from);
+        }
         let dir = self.current_dir.borrow().clone().ok_or_else(|| {
             EvalError::Error("Cannot resolve imports: no current file directory (use run_file)".to_string())
         })?;
@@ -595,6 +604,11 @@ impl Evaluator {
 
     /// Load built-in module (tish:fs, tish:http, tish:process, …) or a virtual module from native crates.
     fn load_builtin_module(&self, spec: &str) -> Result<Value, EvalError> {
+        if spec.starts_with("cargo:") {
+            return Err(EvalError::Error(
+                "cargo:… imports are only supported when compiling with `tish build` and the Rust native backend. They link Cargo crates via package.json tish.rustDependencies and a generated native wrapper — not the interpreter or VM.".into(),
+            ));
+        }
         if let Some(v) = self.virtual_builtins.borrow().get(spec) {
             return Ok(v.clone());
         }
@@ -1203,6 +1217,9 @@ impl Evaluator {
                                 });
                                 return Ok(Value::Number(found.unwrap_or(-1.0)));
                             }
+                            "lastIndexOf" => {
+                                return Ok(Self::string_last_index_of_eval(&arg_vals, s));
+                            }
                             "includes" => {
                                 let search = match arg_vals.first() {
                                     Some(Value::String(ss)) => ss.as_ref(),
@@ -1474,7 +1491,13 @@ impl Evaluator {
                         }
                     }
                     
-                    // Fall through to normal function call
+                    // Fall through to normal function call. `get_prop` only implements `length` on
+                    // strings, so method calls would otherwise become `call_func(Null)` → Not a function.
+                    if let Value::String(s) = &obj {
+                        if method_name.as_ref() == "lastIndexOf" {
+                            return Ok(Self::string_last_index_of_eval(&arg_vals, s));
+                        }
+                    }
                     let f = self.get_prop(&obj, method_name).map_err(EvalError::Error)?;
                     return self.call_func(&f, &arg_vals);
                 }
@@ -2638,6 +2661,31 @@ impl Evaluator {
         Self::bind_destruct_pattern_scoped(&self.scope, pattern, value, mutable)
     }
 
+    /// `String.prototype.lastIndexOf` (interpreter). Kept as a helper so dispatch cannot fall
+    /// through to [`Self::get_prop`] + [`Self::call_func`] for string receivers.
+    fn string_last_index_of_eval(arg_vals: &[Value], receiver: &Arc<str>) -> Value {
+        let search = match arg_vals.first() {
+            Some(Value::String(ss)) => ss.as_ref(),
+            _ => return Value::Number(-1.0),
+        };
+        let position_core: tishlang_core::Value = match arg_vals.get(1) {
+            None => tishlang_core::Value::Number(f64::INFINITY),
+            Some(Value::Null) => tishlang_core::Value::Null,
+            Some(Value::Number(n)) => tishlang_core::Value::Number(*n),
+            Some(Value::Bool(b)) => tishlang_core::Value::Bool(*b),
+            Some(_) => tishlang_core::Value::Number(0.0),
+        };
+        let out = tishlang_builtins::string::last_index_of_str(
+            receiver.as_ref(),
+            search,
+            &position_core,
+        );
+        match out {
+            tishlang_core::Value::Number(n) => Value::Number(n),
+            _ => Value::Number(-1.0),
+        }
+    }
+
     fn get_prop(&self, obj: &Value, key: &str) -> Result<Value, String> {
         match obj {
             Value::Object(map) => Ok(map.borrow().get(key).cloned().unwrap_or(Value::Null)),

package/crates/tish_eval/src/lib.rs

@@ -3,7 +3,7 @@
 mod eval;
 #[cfg(feature = "http")]
 mod http;
-mod value_convert;
+pub mod value_convert;
 #[cfg(feature = "http")]
 mod promise;
 #[cfg(feature = "http")]

package/crates/tish_native/src/build.rs

@@ -5,11 +5,47 @@ use std::path::Path;
 
 use tishlang_compile::ResolvedNativeModule;
 
+/// `tishlang_runtime` Cargo feature names (subset of CLI / compile feature names).
+const RUNTIME_CARGO_FEATURES: &[&str] = &["http", "fs", "process", "regex", "ws"];
+
+/// Map CLI/compile features to flags passed to `tishlang_runtime` in the temp crate's Cargo.toml.
+/// `full` enables every optional runtime capability (matches `tish build --feature full` / LANGUAGE.md).
+fn runtime_features_for_cargo(features: &[String]) -> Vec<String> {
+    let mut out = Vec::new();
+    for f in features {
+        if f == "full" {
+            for name in RUNTIME_CARGO_FEATURES {
+                if !out.iter().any(|x: &String| x == *name) {
+                    out.push((*name).to_string());
+                }
+            }
+            continue;
+        }
+        if RUNTIME_CARGO_FEATURES.contains(&f.as_str()) && !out.contains(f) {
+            out.push(f.clone());
+        }
+    }
+    out
+}
+
+/// Inject `mod generated_native;` after the crate attribute so the binary crate can call `crate::generated_native::…`.
+fn inject_generated_native_mod(rust_code: &str) -> String {
+    if let Some(pos) = rust_code.find("\n\n") {
+        let (a, b) = rust_code.split_at(pos + 2);
+        format!("{}mod generated_native;\n{}", a, b)
+    } else {
+        format!("{}\n\nmod generated_native;\n", rust_code)
+    }
+}
+
 pub fn build_via_cargo(
     rust_code: &str,
     native_modules: Vec<ResolvedNativeModule>,
     output_path: &Path,
     features: &[String],
+    extra_dependencies_toml: &str,
+    generated_native_rs: Option<&str>,
+    project_root: Option<&Path>,
 ) -> Result<(), String> {
     let out_name = output_path
         .file_stem()
@@ -17,17 +53,14 @@ pub fn build_via_cargo(
         .unwrap_or("tish_out");
     let build_dir = tishlang_build_utils::create_build_dir("tish_build", out_name)?;
 
-    let runtime_path = tishlang_build_utils::find_runtime_path()?;
+    let runtime_path = tishlang_build_utils::find_runtime_path_for_project(project_root)?;
 
-    let runtime_features: Vec<&str> = features
-        .iter()
-        .filter(|f| ["http", "fs", "process", "regex", "ws"].contains(&f.as_str()))
-        .map(String::as_str)
-        .collect();
-    let features_str = if runtime_features.is_empty() {
+    let runtime_features = runtime_features_for_cargo(features);
+    let runtime_refs: Vec<&str> = runtime_features.iter().map(String::as_str).collect();
+    let features_str = if runtime_refs.is_empty() {
         String::new()
     } else {
-        format!(", features = {:?}", runtime_features)
+        format!(", features = {:?}", runtime_refs)
     };
 
     let needs_tokio = rust_code.contains("#[tokio::main]");
@@ -39,12 +72,28 @@ pub fn build_via_cargo(
 
     let native_deps: String = native_modules
         .iter()
+        .filter(|m| m.use_path_dependency)
         .map(|m| {
             let path = m.crate_path.display().to_string().replace('\\', "/");
             format!("{} = {{ path = {:?} }}\n", m.package_name, path)
         })
         .collect();
 
+    let mut more_deps = String::new();
+    more_deps.push_str(&tokio_dep);
+    if !native_deps.is_empty() {
+        more_deps.push_str(&format!("\n{}", native_deps));
+    }
+    if !extra_dependencies_toml.trim().is_empty() {
+        more_deps.push_str(&format!("\n{}", extra_dependencies_toml));
+    }
+
+    let rust_main = if generated_native_rs.is_some() {
+        inject_generated_native_mod(rust_code)
+    } else {
+        rust_code.to_string()
+    };
+
     let tish_ui_path = std::path::Path::new(&runtime_path)
         .parent()
         .ok_or_else(|| "invalid tishlang_runtime path (no parent)".to_string())?
@@ -76,23 +125,22 @@ codegen-units = 1
 lto = "thin"
 
 [dependencies]
-tishlang_runtime = {{ path = {:?}{} }}{}{}{}
-"#,
+tishlang_runtime = {{ path = {:?}{} }}
+{}{}"#,
         out_name,
         runtime_path,
         features_str,
-        tokio_dep,
-        if native_deps.is_empty() {
-            String::new()
-        } else {
-            format!("\n{}", native_deps)
-        },
+        more_deps,
         ui_dep
     );
 
     fs::write(build_dir.join("Cargo.toml"), cargo_toml)
         .map_err(|e| format!("Cannot write Cargo.toml: {}", e))?;
-    fs::write(build_dir.join("src/main.rs"), rust_code)
+    if let Some(gen) = generated_native_rs {
+        fs::write(build_dir.join("src/generated_native.rs"), gen)
+            .map_err(|e| format!("Cannot write generated_native.rs: {}", e))?;
+    }
+    fs::write(build_dir.join("src/main.rs"), rust_main)
         .map_err(|e| format!("Cannot write main.rs: {}", e))?;
 
     let workspace_target = Path::new(&runtime_path)
@@ -114,3 +162,24 @@ tishlang_runtime = {{ path = {:?}{} }}{}{}{}
     Ok(())
 }
 
+#[cfg(test)]
+mod tests {
+    use super::runtime_features_for_cargo;
+
+    #[test]
+    fn runtime_features_full_expands() {
+        let f = runtime_features_for_cargo(&["full".to_string()]);
+        assert!(f.contains(&"http".to_string()));
+        assert!(f.contains(&"fs".to_string()));
+        assert!(f.contains(&"process".to_string()));
+        assert!(f.contains(&"regex".to_string()));
+        assert!(f.contains(&"ws".to_string()));
+    }
+
+    #[test]
+    fn runtime_features_merges_full_and_specific() {
+        let f = runtime_features_for_cargo(&["full".to_string(), "http".to_string()]);
+        assert_eq!(f.len(), 5);
+    }
+}
+

package/crates/tish_native/src/lib.rs

@@ -57,18 +57,27 @@ pub fn compile_to_native(
 
     match backend {
         Backend::Rust => {
-            let (rust_code, native_modules) = tishlang_compile::compile_project_full(
-                entry_path,
+            let (rust_code, native_modules, effective_features, native_build) =
+                tishlang_compile::compile_project_full(
+                    entry_path,
+                    project_root,
+                    features,
+                    optimize,
+                )
+                .map_err(|e| NativeError {
+                    message: e.to_string(),
+                })?;
+
+            crate::build::build_via_cargo(
+                &rust_code,
+                native_modules,
+                output_path,
+                &effective_features,
+                &native_build.rust_dependencies_toml,
+                native_build.generated_native_rs.as_deref(),
                 project_root,
-                features,
-                optimize,
             )
-            .map_err(|e| NativeError {
-                message: e.to_string(),
-            })?;
-
-            crate::build::build_via_cargo(&rust_code, native_modules, output_path, features)
-                .map_err(|e| NativeError { message: e })
+            .map_err(|e| NativeError { message: e })
         }
         Backend::Cranelift => {
             let modules = tishlang_compile::resolve_project(entry_path, project_root)
@@ -91,7 +100,7 @@ pub fn compile_to_native(
 
             if tishlang_compile::has_external_native_imports(&program) {
                 return Err(NativeError {
-                    message: "Cranelift backend does not support external native imports (tish:egui, @scope/pkg). Built-in tish:fs, tish:http, tish:process are supported. Use --native-backend rust for external modules.".to_string(),
+                    message: "Cranelift backend does not support external native imports (tish:…, cargo:…, @scope/pkg). Built-in tish:fs, tish:http, tish:process are supported. Use --native-backend rust for external modules.".to_string(),
                 });
             }
 
@@ -127,7 +136,7 @@ pub fn compile_to_native(
             };
             if tishlang_compile::has_external_native_imports(&program) {
                 return Err(NativeError {
-                    message: "LLVM backend does not support external native imports. Built-in tish:fs, tish:http, tish:process are supported.".to_string(),
+                    message: "LLVM backend does not support external native imports (tish:…, cargo:…, @scope/pkg). Built-in tish:fs, tish:http, tish:process are supported.".to_string(),
                 });
             }
             let chunk = if optimize {
@@ -175,6 +184,8 @@ pub fn compile_program_to_native(
             let root = project_root.unwrap_or_else(|| Path::new("."));
             let native_modules = tishlang_compile::resolve_native_modules(&program, root)
                 .map_err(|e| NativeError { message: e })?;
+            let native_build = tishlang_compile::compute_native_build_artifacts(&program, root, &native_modules)
+                .map_err(|e| NativeError { message: e })?;
             let mut all_features = features.to_vec();
             for f in tishlang_compile::extract_native_import_features(&program) {
                 if !all_features.contains(&f) {
@@ -186,18 +197,27 @@ pub fn compile_program_to_native(
                 project_root,
                 &all_features,
                 &native_modules,
+                &native_build.native_init,
                 optimize,
             )
             .map_err(|e| NativeError {
                 message: e.message,
             })?;
-            crate::build::build_via_cargo(&rust_code, native_modules, output_path, &all_features)
-                .map_err(|e| NativeError { message: e })
+            crate::build::build_via_cargo(
+                &rust_code,
+                native_modules,
+                output_path,
+                &all_features,
+                &native_build.rust_dependencies_toml,
+                native_build.generated_native_rs.as_deref(),
+                Some(root),
+            )
+            .map_err(|e| NativeError { message: e })
         }
         Backend::Cranelift => {
             if tishlang_compile::has_external_native_imports(program) {
                 return Err(NativeError {
-                    message: "Cranelift backend does not support external native imports. Built-in tish:fs, tish:http, tish:process are supported.".to_string(),
+                    message: "Cranelift backend does not support external native imports (tish:…, cargo:…, @scope/pkg). Built-in tish:fs, tish:http, tish:process are supported.".to_string(),
                 });
             }
             let program = if optimize { tishlang_opt::optimize(program) } else { program.clone() };
@@ -213,7 +233,7 @@ pub fn compile_program_to_native(
         Backend::Llvm => {
             if tishlang_compile::has_external_native_imports(program) {
                 return Err(NativeError {
-                    message: "LLVM backend does not support external native imports.".to_string(),
+                    message: "LLVM backend does not support external native imports (tish:…, cargo:…, @scope/pkg).".to_string(),
                 });
             }
             let program = if optimize { tishlang_opt::optimize(program) } else { program.clone() };

package/crates/tish_runtime/src/lib.rs

@@ -71,6 +71,7 @@ pub use tishlang_builtins::string::{
     repeat as string_repeat_impl,
     pad_start as string_pad_start_impl,
     pad_end as string_pad_end_impl,
+    last_index_of as string_last_index_of_impl,
 };
 
 // Wrapper functions to maintain API compatibility
@@ -119,6 +120,9 @@ pub fn string_char_code_at(s: &Value, idx: &Value) -> Value { string_char_code_a
 pub fn string_repeat(s: &Value, count: &Value) -> Value { string_repeat_impl(s, count) }
 pub fn string_pad_start(s: &Value, target_len: &Value, pad: &Value) -> Value { string_pad_start_impl(s, target_len, pad) }
 pub fn string_pad_end(s: &Value, target_len: &Value, pad: &Value) -> Value { string_pad_end_impl(s, target_len, pad) }
+pub fn string_last_index_of(s: &Value, search: &Value, position: &Value) -> Value {
+    string_last_index_of_impl(s, search, position)
+}
 
 /// Number.prototype.toFixed(digits) - format number with fixed decimal places (0-20)
 pub fn number_to_fixed(n: &Value, digits: &Value) -> Value {

package/crates/tish_vm/src/lib.rs

@@ -2,7 +2,7 @@
 
 mod vm;
 
-pub use vm::{run, Vm};
+pub use vm::{all_compiled_capabilities, run, run_with_options, Vm, VmRunOptions};
 
 #[cfg(test)]
 mod tests {