@tishlang/tish-lint 2.43.8 → 3.1.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/tests/scope_merge.rs

@@ -77,3 +77,34 @@ fn scope_exports_tish_merges_as_source() {
 fn scope_plain_main_merges_as_source() {
     assert_merged_as_source(&setup(r#","main":"index.tish""#));
 }
+
+/// The other half of the #38 split: a `@scope/pkg` that opts in via `tish.crate` (the tish-apple
+/// hosts, published as `@tishlang/tish-macos` / `@tishlang/tish-ios`) routes to the NATIVE path —
+/// lowered to `NativeModuleLoad`, not merged as source.
+#[test]
+fn scope_tish_crate_routes_native() {
+    let dir = setup(r#","tish":{"module":true,"crate":"test-greet","export":"greet_object"}"#);
+    let root = dir.path();
+    let modules = resolve_project(&root.join("main.tish"), Some(root)).expect("resolve");
+    let merged = merge_modules(modules).expect("merge");
+    let native_scope = merged.program.statements.iter().any(|s| {
+        matches!(
+            s,
+            Statement::VarDecl { init: Some(Expr::NativeModuleLoad { spec, .. }), .. }
+            if spec.as_ref() == "@test/greet"
+        )
+    });
+    assert!(
+        native_scope,
+        "@scope package with tish.crate must lower to NativeModuleLoad (native Rust-crate path)"
+    );
+    let has_greet = merged
+        .program
+        .statements
+        .iter()
+        .any(|s| matches!(s, Statement::FunDecl { name, .. } if name.as_ref() == "greet"));
+    assert!(
+        !has_greet,
+        "@scope package with tish.crate must NOT be merged as Tish source"
+    );
+}

package/crates/tish_build_utils/src/lib.rs

@@ -3,10 +3,11 @@
 //! Provides workspace discovery, path resolution, and Cargo build orchestration
 //! used by tishlang_wasm, tishlang_cranelift, tishlang_native, and the tish CLI.
 
+use std::collections::BTreeSet;
 use std::fs;
 use std::path::{Path, PathBuf};
 use std::process::Command;
-use std::sync::Mutex;
+use std::sync::{Mutex, OnceLock};
 
 /// Serialize nested `cargo build` calls that share the workspace `target/` dir (tests + `tish build`).
 static NESTED_CARGO_MUTEX: Mutex<()> = Mutex::new(());
@@ -19,6 +20,56 @@ fn mold_available() -> bool {
         .unwrap_or(false)
 }
 
+/// The `target_feature="..."` values in `rustc --print cfg` output.
+fn parse_target_features(print_cfg_stdout: &str) -> BTreeSet<String> {
+    print_cfg_stdout
+        .lines()
+        .filter_map(|l| l.trim().strip_prefix("target_feature=\""))
+        .filter_map(|l| l.strip_suffix('"'))
+        .map(str::to_owned)
+        .collect()
+}
+
+/// Host target features rustc reports, optionally under one extra `-C` flag.
+fn rustc_target_features(codegen_flag: Option<&str>) -> Option<BTreeSet<String>> {
+    let rustc = std::env::var("RUSTC").unwrap_or_else(|_| "rustc".to_string());
+    let mut cmd = Command::new(rustc);
+    cmd.args(["--print", "cfg"]);
+    if let Some(flag) = codegen_flag {
+        cmd.args(["-C", flag]);
+    }
+    let out = cmd.output().ok()?;
+    if !out.status.success() {
+        return None;
+    }
+    Some(parse_target_features(&String::from_utf8_lossy(&out.stdout)))
+}
+
+/// True when `-C target-cpu=native` is worth passing on this host.
+///
+/// `native` asks LLVM to identify the host core. On hosts it cannot identify — notably
+/// the virtualized Apple Silicon behind GitHub Actions' macOS runners — it answers
+/// `generic`, which is *narrower* than the target's own default CPU. On
+/// aarch64-apple-darwin that silently drops `aes` and `sha2`, and crates that assert
+/// those are statically present then fail to compile at all; `ring` 0.17 trips
+/// `assertion failed: CAPS_STATIC == MIN_STATIC_FEATURES` in const-eval.
+///
+/// So this compares feature sets rather than trusting `native` blindly: keep the flag
+/// only when it is a strict win (every default feature survives). If rustc cannot be
+/// queried, skip the flag — the target default is always correct, just less tuned.
+fn native_target_cpu_is_safe() -> bool {
+    static SAFE: OnceLock<bool> = OnceLock::new();
+    *SAFE.get_or_init(|| {
+        match (
+            rustc_target_features(None),
+            rustc_target_features(Some("target-cpu=native")),
+        ) {
+            (Some(default), Some(native)) => default.is_subset(&native),
+            _ => false,
+        }
+    })
+}
+
 /// True if `root` looks like the Tish language repo (has `crates/tish_runtime`).
 ///
 /// Used so we do not treat unrelated workspaces (e.g. a parent `zectre-platform` repo) as Tish
@@ -347,7 +398,13 @@ pub fn cargo_target_name(stem: &str) -> String {
     // 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 { '_' })
+        .map(|c| {
+            if c.is_ascii_alphanumeric() || c == '_' {
+                c
+            } else {
+                '_'
+            }
+        })
         .collect();
     if name.is_empty() {
         return "tish_output".to_string();
@@ -371,6 +428,10 @@ pub fn create_build_dir(prefix: &str, out_name: &str) -> Result<PathBuf, String>
 }
 
 /// Run cargo build in the given directory.
+///
+/// `-C target-cpu=native` is added only for host builds, only when the caller has not
+/// already pinned a `target-cpu` in `RUSTFLAGS`, and only when `native` does not lose
+/// target features against the target default (see `native_target_cpu_is_safe`).
 /// If `cross_target` is Some, passes `--target` and skips `-C target-cpu=native`.
 pub fn run_cargo_build(
     build_dir: &Path,
@@ -395,10 +456,14 @@ pub fn run_cargo_build(
             merged_rustflags = format!("{} -C link-arg=-fuse-ld=mold", merged_rustflags.trim());
             merged_rustflags = merged_rustflags.trim().to_string();
         }
-    } else if merged_rustflags.is_empty() {
-        merged_rustflags = "-C target-cpu=native".to_string();
-    } else if !merged_rustflags.contains("target-cpu") {
-        merged_rustflags = format!("{} -C target-cpu=native", merged_rustflags);
+    } else if !merged_rustflags.contains("target-cpu") && native_target_cpu_is_safe() {
+        // Caller did not pin a CPU and `native` resolves to something at least as
+        // capable as the target default — see `native_target_cpu_is_safe`.
+        merged_rustflags = if merged_rustflags.is_empty() {
+            "-C target-cpu=native".to_string()
+        } else {
+            format!("{} -C target-cpu=native", merged_rustflags)
+        };
     }
 
     let mut cmd = Command::new("cargo");
@@ -438,6 +503,66 @@ pub fn run_cargo_build(
 mod protoc_tests {
     use super::*;
 
+    /// Trimmed `rustc --print cfg --target aarch64-apple-darwin`.
+    const APPLE_DARWIN_DEFAULT_CFG: &str = r#"
+debug_assertions
+panic="unwind"
+target_arch="aarch64"
+target_feature="aes"
+target_feature="neon"
+target_feature="sha2"
+target_feature="sha3"
+target_os="macos"
+"#;
+
+    #[test]
+    fn parses_target_features_from_print_cfg() {
+        let features = parse_target_features(APPLE_DARWIN_DEFAULT_CFG);
+        assert_eq!(
+            features.iter().map(String::as_str).collect::<Vec<_>>(),
+            ["aes", "neon", "sha2", "sha3"]
+        );
+        // Non-`target_feature` keys never leak in, and neither do the quotes.
+        assert!(!features.contains("aarch64"));
+        assert!(!features.contains("\"aes\""));
+    }
+
+    #[test]
+    fn native_cpu_rejected_when_it_drops_target_features() {
+        // What GitHub's virtualized Apple Silicon reports: `native` -> `generic`, which
+        // keeps only `neon`. Pinning it would break `ring`'s static feature assertions.
+        let default = parse_target_features(APPLE_DARWIN_DEFAULT_CFG);
+        let generic = parse_target_features("target_feature=\"neon\"\n");
+        assert!(!default.is_subset(&generic));
+    }
+
+    #[test]
+    fn native_cpu_accepted_when_it_only_adds() {
+        let default = parse_target_features(APPLE_DARWIN_DEFAULT_CFG);
+        let apple_m1 = parse_target_features(
+            "target_feature=\"aes\"\ntarget_feature=\"neon\"\n\
+             target_feature=\"sha2\"\ntarget_feature=\"sha3\"\ntarget_feature=\"lse\"\n",
+        );
+        assert!(default.is_subset(&apple_m1));
+        // Identical sets count as safe too — `native` matching the default is a no-op.
+        assert!(default.is_subset(&default));
+    }
+
+    #[test]
+    fn live_rustc_probe_still_parses() {
+        // Guards the parse against a `rustc --print cfg` format change: every target Tish
+        // builds on has at least one baseline target feature (x86_64 sse2, aarch64 neon).
+        // If this ever comes back empty the probe would silently disable target-cpu=native
+        // everywhere rather than only on hosts LLVM cannot identify.
+        let Some(features) = rustc_target_features(None) else {
+            return; // no rustc on PATH — nothing to assert
+        };
+        assert!(
+            !features.is_empty(),
+            "no target_feature in rustc --print cfg"
+        );
+    }
+
     #[test]
     fn cargo_target_name_replaces_hyphens() {
         assert_eq!(cargo_target_name("hello-ios"), "hello_ios");

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() {