@tishlang/tish-lsp 2.43.8 → 3.0.0

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_builtins/src/globals.rs

@@ -354,12 +354,23 @@ pub fn object_keys(args: &[Value]) -> Value {
                 .collect();
             Value::Array(VmRef::new(keys))
         }
+        // A by-reference boxed typed struct (GBA/portable): materialise it to its ordered object and
+        // enumerate that, so `Object.keys(s)` / `for (k in s)` (lowered to `for-of Object.keys`) see
+        // the field names instead of nothing. (JSON/display already materialise; this closes the
+        // reflection paths so the boxed struct is enumerable exactly like the object it stands for.)
+        #[cfg(feature = "portable")]
+        Some(Value::Struct(s)) => object_keys(&[s.borrow().tish_to_object()]),
         _ => Value::Array(VmRef::new(Vec::new())),
     }
 }
 
 /// Object.values(obj)
 pub fn object_values(args: &[Value]) -> Value {
+    // A boxed typed struct materialises to its ordered object first (see `object_keys`).
+    #[cfg(feature = "portable")]
+    if let Some(Value::Struct(s)) = args.first() {
+        return object_values(&[s.borrow().tish_to_object()]);
+    }
     if let Some(Value::Object(obj)) = args.first() {
         let obj_borrow = obj.borrow();
         let values: Vec<Value> = obj_borrow.strings.values().cloned().collect();
@@ -371,6 +382,11 @@ pub fn object_values(args: &[Value]) -> Value {
 
 /// Object.entries(obj)
 pub fn object_entries(args: &[Value]) -> Value {
+    // A boxed typed struct materialises to its ordered object first (see `object_keys`).
+    #[cfg(feature = "portable")]
+    if let Some(Value::Struct(s)) = args.first() {
+        return object_entries(&[s.borrow().tish_to_object()]);
+    }
     if let Some(Value::Object(obj)) = args.first() {
         let obj_borrow = obj.borrow();
         let entries: Vec<Value> = obj_borrow
@@ -407,6 +423,17 @@ pub fn object_assign(args: &[Value]) -> Value {
     target_mut.strings.reserve(additional_capacity);
 
     for source in args.iter().skip(1) {
+        // A boxed typed struct source materialises to its ordered object first (GBA/portable), so
+        // `Object.assign(t, s)` copies its fields instead of silently skipping it (see `object_keys`).
+        #[cfg(feature = "portable")]
+        let struct_obj;
+        #[cfg(feature = "portable")]
+        let source: &Value = if let Value::Struct(s) = source {
+            struct_obj = s.borrow().tish_to_object();
+            &struct_obj
+        } else {
+            source
+        };
         if let Value::Object(src) = source {
             let src_borrow = src.borrow();
             for (k, v) in src_borrow.strings.iter() {