@tishlang/tish-format 1.0.12 → 2.0.1

package/crates/tish/src/repl_completion.rs

@@ -0,0 +1,199 @@
+//! REPL tab completion: dotted (e.g. `a.` -> properties/methods) and bare-word (e.g. `con` -> console).
+//! Grey preview hint below the line (like Node) and Tab for full list.
+
+use std::borrow::Cow;
+
+use tishlang_core::VmRef;
+
+use rustyline::completion::{Completer, Pair};
+use rustyline::highlight::Highlighter;
+use rustyline::hint::Hinter;
+use rustyline::validate::Validator;
+use rustyline::Context;
+use rustyline::Helper;
+
+use tishlang_bytecode::{compile_for_repl, compile_for_repl_unoptimized};
+use tishlang_vm::Vm;
+
+/// Tish keywords for bare-word completion (Python-style).
+const KEYWORDS: &[&str] = &[
+    "async", "await", "break", "case", "catch", "const", "continue", "default", "do", "else",
+    "export", "false", "finally", "for", "fn", "function", "if", "import", "in", "let", "null",
+    "of", "return", "switch", "throw", "true", "try", "typeof", "void", "while",
+];
+
+/// ANSI dim (grey) for hint preview; reset after.
+const ANSI_DIM: &str = "\x1b[2m";
+const ANSI_RESET: &str = "\x1b[0m";
+
+/// Tab completer that evaluates the expression before the last `.` and suggests property/method names.
+pub struct ReplCompleter {
+    pub vm: VmRef<Vm>,
+    pub no_optimize: bool,
+}
+
+impl ReplCompleter {
+    /// Find the start of the identifier (or keyword) being typed before the cursor.
+    /// Returns (byte_start, prefix_string).
+    fn ident_prefix_at_cursor<'a>(&self, line_before_cursor: &'a str) -> (usize, &'a str) {
+        let s = line_before_cursor;
+        if s.is_empty() {
+            return (0, "");
+        }
+        let mut start = s.len();
+        for (i, c) in s.char_indices().rev() {
+            if c.is_alphanumeric() || c == '_' {
+                start = i;
+            } else {
+                break;
+            }
+        }
+        (start, &s[start..])
+    }
+
+    /// Bare-word completions: globals + keywords that start with prefix (Python-style).
+    /// When nothing is typed (empty prefix), return no completions so we don't show a hint at the prompt.
+    fn get_bare_completions(&self, line_before_cursor: &str) -> (usize, Vec<String>) {
+        let (start, prefix) = self.ident_prefix_at_cursor(line_before_cursor);
+        if prefix.is_empty() {
+            return (start, vec![]);
+        }
+        let mut names: Vec<String> = self.vm.borrow().global_names();
+        names.extend(KEYWORDS.iter().map(|s| (*s).to_string()));
+        names.sort();
+        names.dedup();
+        let filtered: Vec<String> = names
+            .into_iter()
+            .filter(|k| k.starts_with(prefix))
+            .collect();
+        (start, filtered)
+    }
+
+    /// Get completions for dotted expr (e.g. `a.` -> member names). Returns (start_offset, list).
+    fn get_dotted_completions(&self, line_before_cursor: &str) -> Option<(usize, Vec<String>)> {
+        let last_dot = line_before_cursor.rfind('.')?;
+        let prefix_expr = line_before_cursor[..last_dot].trim();
+        if prefix_expr.is_empty() {
+            return None;
+        }
+        let member_prefix = line_before_cursor[last_dot + 1..].trim();
+
+        let program = tishlang_parser::parse(prefix_expr).ok()?;
+        let compile_fn = if self.no_optimize {
+            compile_for_repl_unoptimized
+        } else {
+            compile_for_repl
+        };
+        let chunk = compile_fn(&program).ok()?;
+        let value = self.vm.borrow_mut().run_with_options(&chunk, true).ok()?;
+
+        let keys = value.completion_keys();
+        let filtered: Vec<String> = keys
+            .into_iter()
+            .filter(|k| k.starts_with(member_prefix))
+            .collect();
+        Some((last_dot + 1, filtered))
+    }
+
+    /// Unified: dotted if we have a dot and it works, else bare-word.
+    fn get_completions(&self, line_before_cursor: &str) -> (usize, Vec<String>) {
+        if line_before_cursor.contains('.') {
+            if let Some((start, filtered)) = self.get_dotted_completions(line_before_cursor) {
+                if !filtered.is_empty() || line_before_cursor.trim_end().ends_with('.') {
+                    return (start, filtered);
+                }
+            }
+        }
+        self.get_bare_completions(line_before_cursor)
+    }
+
+    /// Longest common prefix of a list of strings.
+    fn longest_common_prefix(items: &[String]) -> Option<String> {
+        let first = items.first()?;
+        let mut len = first.len();
+        for item in items.iter().skip(1) {
+            len = first
+                .bytes()
+                .zip(item.bytes())
+                .take_while(|(a, b)| a == b)
+                .count()
+                .min(len);
+        }
+        if len == 0 {
+            None
+        } else {
+            Some(first[..len].to_string())
+        }
+    }
+}
+
+impl Completer for ReplCompleter {
+    type Candidate = Pair;
+
+    fn complete(
+        &self,
+        line: &str,
+        pos: usize,
+        _ctx: &Context<'_>,
+    ) -> rustyline::Result<(usize, Vec<Pair>)> {
+        let line_before_cursor = &line[..pos];
+        let (start, filtered) = self.get_completions(line_before_cursor);
+        let pairs: Vec<Pair> = filtered
+            .into_iter()
+            .map(|k| Pair {
+                display: k.clone(),
+                replacement: k,
+            })
+            .collect();
+        Ok((start, pairs))
+    }
+}
+
+impl Hinter for ReplCompleter {
+    type Hint = String;
+
+    /// Grey preview: show first completion or common prefix below the line (Node-style).
+    fn hint(&self, line: &str, pos: usize, _ctx: &Context<'_>) -> Option<Self::Hint> {
+        let line_before_cursor = &line[..pos];
+        let (start, filtered) = self.get_completions(line_before_cursor);
+        if filtered.is_empty() {
+            return None;
+        }
+        let member_prefix = line_before_cursor.get(start..).unwrap_or("").trim();
+        // Hint = text to show after cursor (grey). Single match: full name; multiple: common prefix, or first suggestion.
+        let hint = if filtered.len() == 1 {
+            filtered[0].clone()
+        } else if let Some(lcp) = Self::longest_common_prefix(&filtered) {
+            if lcp.len() > member_prefix.len() {
+                lcp
+            } else {
+                // No useful common prefix (e.g. "a." -> many methods); show first as preview like Node.
+                filtered[0].clone()
+            }
+        } else {
+            filtered[0].clone()
+        };
+        // Only show the part not yet typed.
+        if hint.starts_with(member_prefix) && hint.len() > member_prefix.len() {
+            Some(hint[member_prefix.len()..].to_string())
+        } else if hint == member_prefix {
+            None
+        } else {
+            Some(hint)
+        }
+    }
+}
+
+impl Highlighter for ReplCompleter {
+    /// Show hint in dim grey (Node-style preview).
+    fn highlight_hint<'h>(&self, hint: &'h str) -> Cow<'h, str> {
+        if hint.is_empty() {
+            return Cow::Borrowed(hint);
+        }
+        Cow::Owned(format!("{ANSI_DIM}{hint}{ANSI_RESET}"))
+    }
+}
+
+impl Validator for ReplCompleter {}
+
+impl Helper for ReplCompleter {}

package/crates/tish/tests/cargo_example_compile.rs

@@ -0,0 +1,67 @@
+//! `cargo:` + `tish.rustDependencies` using the in-repo fixture at `tests/fixtures/cargo_example_project/`
+//! (same layout as the standalone `tish-cargo-example` template).
+
+use std::path::PathBuf;
+
+use tishlang_ast::Statement;
+use tishlang_compile::{compile_project_full, merge_modules, resolve_project};
+
+fn native_build_features_from_cli(cli_features: &[String]) -> Vec<String> {
+    if cli_features.is_empty() {
+        let mut v: Vec<String> = tishlang_vm::all_compiled_capabilities()
+            .into_iter()
+            .collect();
+        v.sort();
+        v
+    } else {
+        cli_features.to_vec()
+    }
+}
+
+#[test]
+fn resolve_and_merge_cargo_example_fixture() {
+    let manifest_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    let input_path = manifest_dir
+        .join("tests/fixtures/cargo_example_project/src/main.tish")
+        .canonicalize()
+        .expect("cargo_example_project test fixture");
+    let project_root = input_path.parent().map(|p| {
+        if p.file_name().and_then(|n| n.to_str()) == Some("src") {
+            p.parent().unwrap_or(p)
+        } else {
+            p
+        }
+    });
+    let modules = resolve_project(&input_path, project_root).unwrap();
+    assert_eq!(modules.len(), 1, "expected single entry module");
+    let first = &modules[0].program.statements[0];
+    let Statement::Import { from, .. } = first else {
+        panic!("expected import, got {:?}", first);
+    };
+    assert_eq!(from.as_ref(), "cargo:demo_shim");
+    let _ = merge_modules(modules).unwrap();
+}
+
+#[test]
+fn compile_project_full_cargo_example_fixture() {
+    let manifest_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    let example_main = manifest_dir
+        .join("tests/fixtures/cargo_example_project/src/main.tish")
+        .canonicalize()
+        .expect("cargo_example_project test fixture");
+    let input_path = example_main;
+    let project_root = input_path.parent().map(|p| {
+        if p.file_name().and_then(|n| n.to_str()) == Some("src") {
+            p.parent().unwrap_or(p)
+        } else {
+            p
+        }
+    });
+    let features = native_build_features_from_cli(&[]);
+    let r = compile_project_full(&input_path, project_root, &features, true);
+    assert!(
+        r.is_ok(),
+        "compile_project_full failed: {:?}",
+        r.map_err(|e| e.message)
+    );
+}

package/crates/tish/tests/error_source_location.rs

@@ -0,0 +1,36 @@
+//! Issue #74: a runtime error from the bytecode VM carries its source location (`file:line`)
+//! instead of a bare message, so embedders/users can find where it came from.
+
+use std::path::PathBuf;
+use std::process::Command;
+
+#[test]
+fn runtime_error_reports_source_file_and_line() {
+    let tish = PathBuf::from(env!("CARGO_BIN_EXE_tish"));
+    let fixture = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+        .join("tests")
+        .join("fixtures")
+        .join("runtime_error_location.tish");
+    assert!(fixture.is_file(), "missing fixture {}", fixture.display());
+
+    // `obj.field.deep` reads `.field` of `null` on line 4 of the fixture.
+    let out = Command::new(&tish)
+        .args(["run", "--backend", "vm", fixture.to_str().unwrap()])
+        .output()
+        .expect("spawn tish run");
+    assert!(!out.status.success(), "expected a runtime error");
+    let stderr = String::from_utf8_lossy(&out.stderr);
+
+    assert!(
+        stderr.contains(":4"),
+        "error should report the source line (4):\n{stderr}"
+    );
+    assert!(
+        stderr.contains("runtime_error_location.tish"),
+        "error should report the source file:\n{stderr}"
+    );
+    assert!(
+        stderr.contains("Cannot read property 'field' of null"),
+        "error should keep the original message:\n{stderr}"
+    );
+}

package/crates/tish/tests/fixtures/cargo_example_project/Cargo.toml

@@ -0,0 +1,3 @@
+[workspace]
+resolver = "2"
+members = ["crates/demo-shim"]

package/crates/tish/tests/fixtures/cargo_example_project/crates/demo-shim/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "demo_shim"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+crate-type = ["rlib"]
+
+[dependencies]
+# Fixture lives at crates/tish/tests/fixtures/cargo_example_project/crates/demo-shim → repo crates/tish_core
+tishlang_core = { path = "../../../../../../../crates/tish_core" }

package/crates/tish/tests/fixtures/cargo_example_project/crates/demo-shim/src/lib.rs

@@ -0,0 +1,12 @@
+//! Rust exports for `import { … } from 'cargo:demo_shim'` (test fixture).
+
+use std::sync::Arc;
+use tishlang_core::Value;
+
+pub fn greet(args: &[Value]) -> Value {
+    let name = match args.first() {
+        Some(Value::String(s)) => s.as_ref(),
+        _ => "world",
+    };
+    Value::String(Arc::from(format!("Hello, {}!", name)))
+}

package/crates/tish/tests/fixtures/cargo_example_project/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "tish-cargo-example-fixture",
+  "version": "0.0.0",
+  "private": true,
+  "tish": {
+    "rustDependencies": {
+      "demo_shim": { "path": "./crates/demo-shim" }
+    }
+  }
+}

package/crates/tish/tests/fixtures/cargo_example_project/src/main.tish

@@ -0,0 +1,3 @@
+import { greet } from 'cargo:demo_shim'
+
+console.log(greet('from cargo'))

package/crates/tish/tests/fixtures/runtime_error_location.tish

@@ -0,0 +1,5 @@
+let a = 1
+let b = 2
+let obj = null
+let x = obj.field.deep
+console.log(x)

package/crates/tish/tests/fixtures/trycatch_runtime_errors.tish

@@ -0,0 +1,15 @@
+// try/catch catches runtime errors (null property/method access, "not a function")
+// AND throws that cross function-call frames, with the thrown value preserved (issue #60).
+try { let x = null; x.foo() } catch (e) { console.log("A caught") }
+function f() { throw new Error("boom") }
+try { f() } catch (e) { console.log("B caught:", e.message) }
+function g() { let y = null; y.baz() }
+try { g() } catch (e) { console.log("C caught") }
+console.log("D done")
+try { try { throw "inner" } catch (e) { throw "rethrown" } } catch (e) { console.log("E caught:", e) }
+try { console.log("F ok") } catch (e) { console.log("F should not happen") }
+let total = 0
+function risky(n) { if (n > 3) { throw n }; return n }
+let i = 0
+while (i < 6) { try { total = total + risky(i) } catch (e) { total = total + 100 }; i = i + 1 }
+console.log("G total:", total)

package/crates/tish/tests/fixtures/tty_capability.tish

@@ -0,0 +1,9 @@
+// tish:tty capability (issue #101). Asserts the module loads and degrades gracefully when
+// stdout/stdin is not a terminal (CI), so the output is deterministic without a real TTY.
+import { isTTY, size, setRawMode, enterAltScreen, leaveAltScreen, read, readLine } from 'tish:tty'
+console.log("isTTY:", typeof isTTY())
+console.log("size:", size() ? "object" : "null")
+console.log("setRawMode:", typeof setRawMode)
+console.log("read:", typeof read)
+console.log("readLine:", typeof readLine)
+console.log("alt:", typeof enterAltScreen, typeof leaveAltScreen)