@tishlang/tish 1.3.8 → 1.5.0

package/crates/tish_eval/src/eval.rs

@@ -515,6 +515,10 @@ impl Evaluator {
         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())
         })?;
@@ -1203,6 +1207,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 +1481,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 +2651,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_lint/Cargo.toml

@@ -12,6 +12,7 @@ path = "src/bin/tish-lint.rs"
 
 [dependencies]
 clap = { version = "4.6.0", features = ["derive"] }
+serde_json = "1.0"
 walkdir = "2"
 tishlang_ast = { path = "../tish_ast", version = ">=0.1" }
 tishlang_parser = { path = "../tish_parser", version = ">=0.1" }

package/crates/tish_lint/src/bin/tish-lint.rs

@@ -3,30 +3,54 @@
 use std::fs;
 use std::path::{Path, PathBuf};
 
-use clap::Parser;
+use clap::{Parser, ValueEnum};
+use serde_json::json;
+
+#[derive(Clone, Copy, Debug, ValueEnum)]
+enum OutputFormat {
+    Text,
+    Sarif,
+}
 
 #[derive(Parser)]
 #[command(name = "tish-lint")]
 #[command(about = "AST-based linter for Tish")]
 struct Cli {
+    /// Output format (SARIF 2.1.0 for code scanning integrations).
+    #[arg(long = "format", value_enum, default_value_t = OutputFormat::Text)]
+    output_format: OutputFormat,
+
     #[arg(required = true)]
     paths: Vec<String>,
 }
 
+#[derive(Debug)]
+struct Issue {
+    path: PathBuf,
+    line: u32,
+    col: u32,
+    code: String,
+    message: String,
+    level: &'static str,
+}
+
 fn main() {
     let cli = Cli::parse();
-    if let Err(e) = run(&cli.paths) {
+    if let Err(e) = run(&cli.paths, cli.output_format) {
         eprintln!("{}", e);
         std::process::exit(1);
     }
 }
 
-fn run(paths: &[String]) -> Result<(), String> {
+fn collect_files(paths: &[String]) -> Result<Vec<PathBuf>, String> {
     let mut files: Vec<PathBuf> = Vec::new();
     for p in paths {
         let path = Path::new(p);
         if path.is_dir() {
-            for e in walkdir::WalkDir::new(path).into_iter().filter_map(|e| e.ok()) {
+            for e in walkdir::WalkDir::new(path)
+                .into_iter()
+                .filter_map(|e| e.ok())
+            {
                 if e.path().extension().map(|x| x == "tish").unwrap_or(false) {
                     files.push(e.path().to_path_buf());
                 }
@@ -40,38 +64,132 @@ fn run(paths: &[String]) -> Result<(), String> {
     if files.is_empty() {
         return Err("No .tish files to lint".into());
     }
-    let mut errors = 0;
+    Ok(files)
+}
+
+fn run(paths: &[String], format: OutputFormat) -> Result<(), String> {
+    let files = collect_files(paths)?;
+    let mut issues: Vec<Issue> = Vec::new();
     for f in files {
         let src = fs::read_to_string(&f).map_err(|e| format!("{}: {}", f.display(), e))?;
         match tishlang_lint::lint_source(&src) {
             Ok(diags) => {
                 for d in diags {
-                    let sev = match d.severity {
-                        tishlang_lint::Severity::Error => {
-                            errors += 1;
-                            "error"
-                        }
+                    let level = match d.severity {
+                        tishlang_lint::Severity::Error => "error",
                         tishlang_lint::Severity::Warning => "warning",
                     };
-                    println!(
-                        "{}:{}:{}: {} [{}] {}",
-                        f.display(),
-                        d.line,
-                        d.col,
-                        sev,
-                        d.code,
-                        d.message
-                    );
+                    issues.push(Issue {
+                        path: f.clone(),
+                        line: d.line,
+                        col: d.col,
+                        code: d.code.to_string(),
+                        message: d.message,
+                        level,
+                    });
                 }
             }
             Err(e) => {
-                eprintln!("{}: parse error: {}", f.display(), e);
-                errors += 1;
+                issues.push(Issue {
+                    path: f.clone(),
+                    line: 1,
+                    col: 1,
+                    code: "tish-parse-error".into(),
+                    message: e,
+                    level: "error",
+                });
             }
         }
     }
-    if errors > 0 {
-        return Err(format!("{} issue(s)", errors));
+
+    let error_count = issues.iter().filter(|i| i.level == "error").count();
+
+    match format {
+        OutputFormat::Text => {
+            for i in &issues {
+                println!(
+                    "{}:{}:{}: {} [{}] {}",
+                    i.path.display(),
+                    i.line,
+                    i.col,
+                    i.level,
+                    i.code,
+                    i.message
+                );
+            }
+            if error_count > 0 {
+                return Err(format!("{} issue(s)", error_count));
+            }
+        }
+        OutputFormat::Sarif => {
+            print_sarif(&issues)?;
+            if error_count > 0 {
+                return Err(format!("{} issue(s)", error_count));
+            }
+        }
     }
+
+    Ok(())
+}
+
+fn print_sarif(issues: &[Issue]) -> Result<(), String> {
+    let rules: Vec<_> = tishlang_lint::RULES
+        .iter()
+        .map(|(id, desc)| {
+            json!({
+                "id": id,
+                "name": id,
+                "shortDescription": { "text": desc },
+                "helpUri": "https://tishlang.com/docs/reference/linting/"
+            })
+        })
+        .chain(std::iter::once(json!({
+            "id": "tish-parse-error",
+            "name": "tish-parse-error",
+            "shortDescription": { "text": "Source failed to parse as Tish." },
+            "helpUri": "https://tishlang.com/docs/language/overview/"
+        })))
+        .collect();
+
+    let results: Vec<_> = issues
+        .iter()
+        .map(|i| {
+            let uri = i.path.to_str().unwrap_or("unknown").replace('\\', "/");
+            json!({
+                "ruleId": i.code,
+                "level": i.level,
+                "message": { "text": i.message },
+                "locations": [{
+                    "physicalLocation": {
+                        "artifactLocation": { "uri": uri },
+                        "region": {
+                            "startLine": i.line,
+                            "startColumn": i.col
+                        }
+                    }
+                }]
+            })
+        })
+        .collect();
+
+    let doc = json!({
+        "version": "2.1.0",
+        "$schema": "https://raw.githubusercontent.com/oasis-tcs/sarif-spec/master/Schemata/sarif-schema-2.1.0.json",
+        "runs": [{
+            "tool": {
+                "driver": {
+                    "name": "tish-lint",
+                    "informationUri": "https://tishlang.com/docs/reference/linting/",
+                    "rules": rules
+                }
+            },
+            "results": results
+        }]
+    });
+
+    println!(
+        "{}",
+        serde_json::to_string_pretty(&doc).map_err(|e| e.to_string())?
+    );
     Ok(())
 }

package/crates/tish_lint/src/lib.rs

@@ -246,7 +246,9 @@ fn lint_expr(e: &Expr, out: &mut Vec<LintDiagnostic>) {
         }
         Expr::Await { operand, .. } => lint_expr(operand, out),
         Expr::TypeOf { operand, .. } => lint_expr(operand, out),
-        Expr::JsxElement { props, children, .. } => {
+        Expr::JsxElement {
+            props, children, ..
+        } => {
             for pr in props {
                 match pr {
                     tishlang_ast::JsxProp::Attr { value, .. } => {

package/crates/tish_lsp/README.md

@@ -19,7 +19,7 @@ Binary: `target/release/tish-lsp` (stdio LSP).
 
 ## Client configuration
 
-See the [Tish docs — Language server](https://tishlang.github.io/tish-docs/reference/language-server/) and [Editor setup](https://tishlang.github.io/tish-docs/getting-started/editor/).
+See the [Tish docs — Language server](https://tishlang.com/docs/reference/language-server/) and [Editor setup](https://tishlang.com/docs/getting-started/editor/).
 
 ## Developing
 

package/crates/tish_native/src/build.rs

@@ -5,6 +5,29 @@ 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
+}
+
 pub fn build_via_cargo(
     rust_code: &str,
     native_modules: Vec<ResolvedNativeModule>,
@@ -19,15 +42,12 @@ pub fn build_via_cargo(
 
     let runtime_path = tishlang_build_utils::find_runtime_path()?;
 
-    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]");
@@ -114,3 +134,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,7 +57,7 @@ pub fn compile_to_native(
 
     match backend {
         Backend::Rust => {
-            let (rust_code, native_modules) = tishlang_compile::compile_project_full(
+            let (rust_code, native_modules, effective_features) = tishlang_compile::compile_project_full(
                 entry_path,
                 project_root,
                 features,
@@ -67,8 +67,13 @@ pub fn compile_to_native(
                 message: e.to_string(),
             })?;
 
-            crate::build::build_via_cargo(&rust_code, native_modules, output_path, features)
-                .map_err(|e| NativeError { message: e })
+            crate::build::build_via_cargo(
+                &rust_code,
+                native_modules,
+                output_path,
+                &effective_features,
+            )
+            .map_err(|e| NativeError { message: e })
         }
         Backend::Cranelift => {
             let modules = tishlang_compile::resolve_project(entry_path, project_root)

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 {