@tishlang/tish-lsp 2.39.0 → 3.0.0

package/Cargo.toml

@@ -36,7 +36,10 @@ members = [
 ]
 # Generated native-build projects (`tish build`) land under `target/` when TMPDIR points there;
 # never enroll anything beneath `target/` as a workspace member.
-exclude = ["target"]
+# GBA-only: depends on `agb`, which builds solely for thumbv4t. Excluded so host
+# `cargo build` doesn't try to cross-compile it; built explicitly with the target
+# (and consumed by path from generated GBA projects, not as a workspace member).
+exclude = ["target", "crates/tish_runtime_gba"]
 resolver = "2"
 
 [workspace.package]

package/crates/tish/src/cli_help.rs

@@ -557,6 +557,12 @@ pub(crate) struct BuildArgs {
     pub crate_type: String,
     #[arg(long, help_heading = "Options")]
     pub no_optimize: bool,
+    /// Platform for RN-style module resolution (`macos`, `ios`, `windows`, `linux`, `web`).
+    #[arg(long, value_name = "NAME", help_heading = "Options")]
+    pub platform: Option<String>,
+    /// Surface for module resolution: `native`, `webview`, or `web` (also `TISH_SURFACE`).
+    #[arg(long, value_name = "NAME", help_heading = "Options")]
+    pub surface: Option<String>,
     /// For `--target js` project builds: emit `OUTPUT.js.map` and `//# sourceMappingURL=…` so JS/TS tools can jump to original `.tish` (implies `--no-optimize` for that build).
     #[arg(long, help_heading = "Options")]
     pub source_map: bool,
@@ -599,6 +605,12 @@ pub(crate) struct CompileModuleArgs {
     /// Project root for resolving bare specifiers / `node_modules` (defaults to the file's parent).
     #[arg(long, value_name = "DIR", help_heading = "Options")]
     pub project_root: Option<String>,
+    /// Platform for RN-style module resolution (`macos`, `ios`, `windows`, `linux`, `web`).
+    #[arg(long, value_name = "NAME", help_heading = "Options")]
+    pub platform: Option<String>,
+    /// Surface for module resolution: `native`, `webview`, or `web`.
+    #[arg(long, value_name = "NAME", help_heading = "Options")]
+    pub surface: Option<String>,
     /// Disable AST optimizations (forced on when a source map is emitted).
     #[arg(long, help_heading = "Options")]
     pub no_optimize: bool,
@@ -626,6 +638,22 @@ pub(crate) enum Commands {
     /// Compile a single `.tish` module to one ES module (for Vite dev / HMR); prints to stdout
     #[command(name = "compile-module")]
     CompileModule(CompileModuleArgs),
+    /// Resolve a relative `.tish` import with platform/surface cascade (for Vite / tooling)
+    #[command(name = "resolve-id")]
+    ResolveId {
+        /// Import specifier (must be relative, e.g. `./Button` or `./Button.tish`).
+        #[arg(required = true, value_name = "SOURCE", help_heading = "Arguments")]
+        source: String,
+        /// Absolute path of the importing file (directory used as resolve base).
+        #[arg(long, value_name = "FILE", help_heading = "Options")]
+        importer: Option<String>,
+        /// Platform token (`macos`, `ios`, `windows`, `linux`, `web`).
+        #[arg(long, value_name = "NAME", help_heading = "Options")]
+        platform: Option<String>,
+        /// Surface token (`native`, `webview`, `web`).
+        #[arg(long, value_name = "NAME", help_heading = "Options")]
+        surface: Option<String>,
+    },
     /// Parse and dump AST
     #[command(name = "dump-ast")]
     DumpAst {

package/crates/tish/src/main.rs

@@ -73,7 +73,8 @@ fn native_build_features_from_cli(cli_features: &[String]) -> Vec<String> {
 fn argv_with_implicit_run(mut argv: Vec<String>) -> Vec<String> {
     if argv.len() >= 2 {
         let first = argv[1].as_str();
-        const SUBCOMMANDS: &[&str] = &["run", "repl", "build", "compile-module", "dump-ast"];
+        const SUBCOMMANDS: &[&str] =
+            &["run", "repl", "build", "compile-module", "resolve-id", "dump-ast"];
         let looks_like_file = !first.starts_with('-') && !SUBCOMMANDS.contains(&first);
         if looks_like_file {
             argv.insert(1, "run".to_string());
@@ -126,6 +127,13 @@ fn main() {
             if let Some(mode) = &a.check {
                 std::env::set_var("TISH_CHECK", mode);
             }
+            if let Err(e) = tishlang_compile::apply_resolve_env(
+                a.platform.as_deref(),
+                a.surface.as_deref(),
+            ) {
+                eprintln!("Error: {}", e);
+                std::process::exit(1);
+            }
             build_file(
                 &a.file,
                 &a.output,
@@ -140,7 +148,30 @@ fn main() {
                 &a.jsx_import_source,
             )
         }
-        Some(Commands::CompileModule(a)) => compile_module(&a),
+        Some(Commands::CompileModule(a)) => {
+            if let Err(e) = tishlang_compile::apply_resolve_env(
+                a.platform.as_deref(),
+                a.surface.as_deref(),
+            ) {
+                eprintln!("Error: {}", e);
+                std::process::exit(1);
+            }
+            compile_module(&a)
+        }
+        Some(Commands::ResolveId {
+            source,
+            importer,
+            platform,
+            surface,
+        }) => tishlang_compile::resolve_id_public(
+            &source,
+            importer.as_deref(),
+            platform.as_deref(),
+            surface.as_deref(),
+        )
+        .map(|path| {
+            println!("{path}");
+        }),
         Some(Commands::DumpAst {
             file,
             ignore_indent,
@@ -883,9 +914,9 @@ fn build_file(
         .map_err(|e| e.to_string());
     }
 
-    if target != "native" {
+    if target != "native" && target != "gba" {
         return Err(format!(
-            "Unknown target: {}. Use 'native', 'js', 'wasm', 'wasm-gpu', 'wasi', or 'bytecode'.",
+            "Unknown target: {}. Use 'native', 'gba', 'js', 'wasm', 'wasm-gpu', 'wasi', or 'bytecode'.",
             target
         ));
     }
@@ -899,7 +930,12 @@ fn build_file(
     });
     let features: Vec<String> = native_build_features_from_cli(cli_features);
 
-    let build_config = if let Some(triple) = ios_triple {
+    let build_config = if target == "gba" {
+        if is_js {
+            return Err("tish build --target gba requires a .tish entry file.".to_string());
+        }
+        tishlang_native::NativeBuildConfig::gba()
+    } else if let Some(triple) = ios_triple {
         tishlang_native::NativeBuildConfig::ios_staticlib(triple)
     } else if crate_type == "staticlib" {
         tishlang_native::NativeBuildConfig {

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

@@ -10,3 +10,24 @@ pub fn greet(args: &[Value]) -> Value {
     };
     Value::String(Arc::from(format!("Hello, {}!", name)))
 }
+
+/// Boxed shim kept for dynamic call sites (`Value::Function` dispatch / a spread call).
+pub fn add(args: &[Value]) -> Value {
+    let a = match args.first() {
+        Some(Value::Number(n)) => *n,
+        _ => 0.0,
+    };
+    let b = match args.get(1) {
+        Some(Value::Number(n)) => *n,
+        _ => 0.0,
+    };
+    Value::Number(a + b)
+}
+
+/// Typed extern (`declare fn add(a: number, b: number): number` in `tish.d.tish`): the direct, unboxed
+/// entry codegen calls as `demo_shim::add_typed(..)` when the args lower to the declared native types.
+/// `number` lowers to `f64` on every native target (unlike `i32`, which is native only under
+/// `--target gba`), so this direct call fires on the default desktop build too.
+pub fn add_typed(a: f64, b: f64) -> f64 {
+    a + b
+}

package/crates/tish/tests/fixtures/cargo_example_project/crates/demo-shim/tish.d.tish

@@ -0,0 +1,4 @@
+// Typed externs shipped by the `demo_shim` crate (auto-loaded from beside its source by codegen).
+// Declares the native signatures of exports so a call lowers to a DIRECT `demo_shim::<name>_typed(..)`
+// instead of the boxed `value_call` path — the consuming program never writes these declarations.
+declare fn add(a: number, b: number): number

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

@@ -1,3 +1,7 @@
-import { greet } from 'cargo:demo_shim'
+import { greet, add } from 'cargo:demo_shim'
 
 console.log(greet('from cargo'))
+
+// `add` has a typed signature shipped in the crate's `tish.d.tish` (auto-loaded) — this call lowers
+// to a direct `demo_shim::add_typed(2, 3)`, not the boxed namespace-object dispatch.
+console.log(add(2, 3))

package/crates/tish/tests/regr_typed_externs.rs

@@ -0,0 +1,59 @@
+//! Typed externs (perf lever): a native `cargo:` import whose typed signature is shipped in the
+//! crate's `tish.d.tish` (auto-loaded from beside the crate source) must lower a matching call to a
+//! DIRECT `<crate>::<name>_typed(..)` — no `Value` boxing of the args, no `value_call` dispatch —
+//! while a call with no typed signature keeps the boxed namespace path. Uses the in-repo
+//! `tests/fixtures/cargo_example_project/` fixture: `demo_shim` exports `greet` (untyped, stays boxed)
+//! and `add` (declared `add(a: i32, b: i32): i32` in `crates/demo-shim/tish.d.tish`).
+//!
+//! Covers the three branch pieces with no other coverage: the `tish.d.tish` auto-load
+//! (`compile_project_full_emit`), `collect_extern_fns` pairing, and the direct-call emission.
+
+use std::path::PathBuf;
+
+use tishlang_compile::compile_project_full;
+
+fn emit_fixture() -> String {
+    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
+        }
+    });
+    compile_project_full(&input_path, project_root, &[], true)
+        .expect("compile_project_full on the cargo example fixture")
+        .0
+}
+
+#[test]
+fn declared_extern_call_lowers_to_a_direct_typed_call() {
+    let rust = emit_fixture();
+    // The `add(2, 3)` call (typed via the auto-loaded tish.d.tish) must be a direct call into the
+    // crate's `add_typed`, not a boxed dispatch through the namespace object.
+    assert!(
+        rust.contains("add_typed"),
+        "typed extern `add` must lower to a direct `demo_shim::add_typed(..)` call; \
+         the auto-loaded tish.d.tish declaration was not honored.\n{rust}"
+    );
+    // The direct call targets the backing crate.
+    assert!(
+        rust.contains("demo_shim :: add_typed") || rust.contains("demo_shim::add_typed"),
+        "the direct typed-extern call must target the `demo_shim` crate.\n{rust}"
+    );
+}
+
+#[test]
+fn untyped_extern_call_stays_boxed() {
+    let rust = emit_fixture();
+    // `greet` has no typed signature (no tish.d.tish entry), so it must NOT gain a `_typed` call —
+    // it keeps the boxed namespace/`value_call` path. Guards against collect_extern_fns over-matching.
+    assert!(
+        !rust.contains("greet_typed"),
+        "untyped extern `greet` must stay boxed (no `greet_typed` direct call).\n{rust}"
+    );
+}

package/crates/tish/tests/scope_merge.rs

@@ -0,0 +1,79 @@
+//! Regression for #38: a merged `@scope/pkg` package (declared via `tish.module`, `exports.tish`,
+//! etc.) must resolve as merged **Tish source**, not be routed to the native Rust-crate path (which
+//! would reject it with "not a Tish native module" or mis-treat it as a crate). Native `@scope`
+//! crates (marked with `tish.crate` / `tish.rustDependencies`) remain native and are exercised by
+//! the downstream regression (tish-apple/tish-macos).
+
+use std::fs;
+
+use tishlang_ast::{Expr, Statement};
+use tishlang_compile::{merge_modules, resolve_project};
+
+/// Build a tempdir project whose `main.tish` imports a merged `@test/greet` package. `tish_field`
+/// is the extra package.json snippet declaring how the package presents itself (`,"tish":{…}` etc.).
+fn setup(tish_field: &str) -> tempfile::TempDir {
+    let dir = tempfile::tempdir().unwrap();
+    let root = dir.path();
+    let pkg = root.join("node_modules/@test/greet");
+    fs::create_dir_all(&pkg).unwrap();
+    fs::write(
+        pkg.join("package.json"),
+        format!(r#"{{"name":"@test/greet","version":"1.0.0"{tish_field}}}"#),
+    )
+    .unwrap();
+    fs::write(pkg.join("index.tish"), "export fn greet() { return \"hi\" }\n").unwrap();
+    fs::write(
+        root.join("main.tish"),
+        "import { greet } from \"@test/greet\"\nconsole.log(greet())\n",
+    )
+    .unwrap();
+    dir
+}
+
+fn assert_merged_as_source(dir: &tempfile::TempDir) {
+    let root = dir.path();
+    let modules = resolve_project(&root.join("main.tish"), Some(root)).expect("resolve");
+    let merged = merge_modules(modules).expect("merge");
+    // Merged as source ⇒ the package's `greet` fn is folded into the top-level program.
+    let has_greet = merged
+        .program
+        .statements
+        .iter()
+        .any(|s| matches!(s, Statement::FunDecl { name, .. } if name.as_ref() == "greet"));
+    assert!(
+        has_greet,
+        "merged @scope package's fn must be folded into the program (merged as Tish source)"
+    );
+    // ...and NOT lowered to a native module load (the #38 mis-routing).
+    let native_scope = merged.program.statements.iter().any(|s| {
+        matches!(
+            s,
+            Statement::VarDecl { init: Some(Expr::NativeModuleLoad { spec, .. }), .. }
+            if spec.contains("@test")
+        )
+    });
+    assert!(
+        !native_scope,
+        "a merged @scope package must NOT be routed to the native Rust-crate path (#38)"
+    );
+}
+
+#[test]
+fn scope_tish_module_true_merges_as_source() {
+    assert_merged_as_source(&setup(r#","tish":{"module":true}"#));
+}
+
+#[test]
+fn scope_tish_module_string_path_merges_as_source() {
+    assert_merged_as_source(&setup(r#","tish":{"module":"index.tish"}"#));
+}
+
+#[test]
+fn scope_exports_tish_merges_as_source() {
+    assert_merged_as_source(&setup(r#","exports":{"tish":"./index.tish"}"#));
+}
+
+#[test]
+fn scope_plain_main_merges_as_source() {
+    assert_merged_as_source(&setup(r#","main":"index.tish""#));
+}

package/crates/tish_build_utils/src/lib.rs

@@ -340,7 +340,22 @@ pub fn find_crate_path(crate_name: &str) -> Result<PathBuf, String> {
 
 /// Sanitize a user-chosen output stem for Cargo `[lib]` / `[[bin]]` target names.
 pub fn cargo_target_name(stem: &str) -> String {
-    stem.replace('-', "_")
+    // The result is emitted verbatim into a generated `Cargo.toml` (`name = "<stem>"`) and used as
+    // the crate/target name, so it must be a valid Rust identifier. Map every char that isn't
+    // ASCII-alphanumeric or `_` to `_` — a `-` (cargo normalizes it to `_` anyway), but also a `.`,
+    // space, or `"` from an odd `-o` path, which would otherwise break or inject the manifest.
+    // A leading digit is prefixed with `_`; an empty result falls back to a fixed default.
+    let mut name: String = stem
+        .chars()
+        .map(|c| if c.is_ascii_alphanumeric() || c == '_' { c } else { '_' })
+        .collect();
+    if name.is_empty() {
+        return "tish_output".to_string();
+    }
+    if name.starts_with(|c: char| c.is_ascii_digit()) {
+        name.insert(0, '_');
+    }
+    name
 }
 
 /// Create a temp build directory with src subdir.
@@ -428,6 +443,17 @@ mod protoc_tests {
         assert_eq!(cargo_target_name("hello-ios"), "hello_ios");
         assert_eq!(cargo_target_name("tish_out"), "tish_out");
     }
+
+    #[test]
+    fn cargo_target_name_sanitizes_invalid_chars() {
+        // Quotes / dots / spaces from an odd `-o` stem can't break or inject the manifest.
+        assert_eq!(cargo_target_name("a\"b"), "a_b");
+        assert_eq!(cargo_target_name("my.app"), "my_app");
+        assert_eq!(cargo_target_name("my game"), "my_game");
+        // A leading digit is made identifier-safe; empty falls back.
+        assert_eq!(cargo_target_name("3d"), "_3d");
+        assert_eq!(cargo_target_name(""), "tish_output");
+    }
 }
 
 /// Find the built static library in target/release (or target/$TRIPLE/release).

package/crates/tish_builtins/Cargo.toml

@@ -8,15 +8,23 @@ description = "Shared builtin implementations for Tish (array, string, object, m
 license-file = { workspace = true }
 repository = { workspace = true }
 [dependencies]
-ahash = "0.8.11"
-indexmap = "2"
-rand = "0.10.1"
-unicode-normalization = "0.1.25"
-tishlang_core = { path = "../tish_core", version = ">=0.1" }
+# std-only deps, optional so the `portable` build drops them (rand needs OS
+# entropy; ahash needs atomics — both replaced by tishlang_core hooks/FxHasher).
+ahash = { version = "0.8.11", optional = true }
+indexmap = { version = "2", default-features = false }
+rand = { version = "0.10.1", optional = true }
+# default-features=false keeps it no_std (it works on core+alloc via tinyvec);
+# tish only uses NFC/NFD/NFKC/NFKD, none of which need std.
+unicode-normalization = { version = "0.1.25", default-features = false }
+tishlang_core = { path = "../tish_core", version = ">=0.1", default-features = false }
 
 [features]
-default = []
+default = ["std"]
+std = ["tishlang_core/std", "dep:ahash", "dep:rand"]
 regex = ["tishlang_core/regex"]
+# no_std + alloc build for GBA. Inherits tishlang_core's portable vocabulary and
+# its clock/RNG hooks; float math routes through tishlang_core::FloatExt (libm).
+portable = ["tishlang_core/portable"]
 # Propagate the `send-values` feature from `tishlang_core` so that closures
 # handed to us via `NativeFn` pick up the `Send + Sync` bound automatically
 # when multi-threaded `Value`s are enabled upstream.