@tishlang/tish-lint 3.9.2 → 3.10.3

package/Cargo.toml

@@ -22,8 +22,6 @@ members = [
     "crates/tish_vm",
     "crates/tish_llvm",
     "crates/tish_ffi",
-    "examples/ffi/mathext",
-
     "crates/tish_native",
     "crates/tish_wasm",
     "crates/tish",

package/crates/tish_compile/src/resolve.rs

@@ -756,31 +756,60 @@ pub fn compute_native_build_artifacts(
     })
 }
 
+/// Names a directory may declare and still satisfy `package_name`.
+///
+/// A `tish:foo` import asks for the package `tish-foo`, which is what the in-repo crate
+/// directories under `tish-apple/crates/` are called. The SAME code is published to npm under the
+/// scoped name `@tishlang/tish-foo`, so a project that depends on the published package has it at
+/// `node_modules/@tishlang/tish-foo` declaring that scoped name. Treat the two as one identity,
+/// or a pinned published dependency is silently ignored in favour of a sibling checkout.
+fn acceptable_package_names(package_name: &str) -> Vec<String> {
+    let mut names = vec![package_name.to_string()];
+    if !package_name.starts_with('@') {
+        names.push(format!("@tishlang/{package_name}"));
+    }
+    names
+}
+
+fn declares_one_of(pkg_dir: &Path, names: &[String]) -> bool {
+    let pkg_json = pkg_dir.join("package.json");
+    if !pkg_json.exists() {
+        return false;
+    }
+    match read_package_name(&pkg_json) {
+        Some(found) => names.iter().any(|n| *n == found),
+        None => false,
+    }
+}
+
 fn find_package_dir(package_name: &str, project_root: &Path) -> Result<PathBuf, String> {
+    let names = acceptable_package_names(package_name);
     let mut search = project_root.to_path_buf();
     loop {
+        // node_modules first, and the scoped published name before the sibling checkout: an
+        // explicit dependency pin must beat a directory that merely happens to sit alongside.
         let node_mod = search.join("node_modules").join(package_name);
-        if node_mod.join("package.json").exists()
-            && read_package_name(&node_mod.join("package.json")) == Some(package_name.to_string())
-        {
+        if declares_one_of(&node_mod, &names) {
             return Ok(node_mod);
         }
+        if !package_name.starts_with('@') {
+            let scoped = search
+                .join("node_modules")
+                .join("@tishlang")
+                .join(package_name);
+            if declares_one_of(&scoped, &names) {
+                return Ok(scoped);
+            }
+        }
         let apple_crate = search.join("tish-apple").join("crates").join(package_name);
-        if apple_crate.join("package.json").exists()
-            && read_package_name(&apple_crate.join("package.json"))
-                == Some(package_name.to_string())
-        {
+        if declares_one_of(&apple_crate, &names) {
             return Ok(apple_crate);
         }
         let sibling = search.join(package_name);
-        if sibling.join("package.json").exists()
-            && read_package_name(&sibling.join("package.json")) == Some(package_name.to_string())
-        {
+        if declares_one_of(&sibling, &names) {
             return Ok(sibling);
         }
-        if search.join("package.json").exists()
-            && read_package_name(&search.join("package.json")) == Some(package_name.to_string())
-        {
+        if declares_one_of(&search, &names) {
             return Ok(search);
         }
         if let Some(parent) = search.parent() {
@@ -2385,4 +2414,53 @@ mod find_package_dir_tests {
         let hit = find_package_dir("tish-macos", &project).expect("resolve");
         assert_eq!(hit.canonicalize().unwrap(), apple.canonicalize().unwrap());
     }
+
+    /// The published npm package for `tish:macos` is named `@tishlang/tish-macos`, so a bare
+    /// name-equality check rejects it and silently falls through to a sibling checkout --
+    /// pulling that checkout's path-dep copy of tishlang_core in beside the registry one and
+    /// failing the build on mismatched `Value` types. An explicit dependency must win.
+    #[test]
+    fn prefers_scoped_node_modules_over_tish_apple_crates() {
+        let dir = tempfile::tempdir().expect("tempdir");
+        let root = dir.path();
+        let apple = root.join("tish-apple").join("crates").join("tish-macos");
+        std::fs::create_dir_all(&apple).unwrap();
+        std::fs::write(
+            apple.join("package.json"),
+            r#"{"name":"tish-macos","tish":{"module":true,"crate":"tishlang_macos","export":"macos_object"}}"#,
+        )
+        .unwrap();
+        let project = root.join("app");
+        let scoped = project
+            .join("node_modules")
+            .join("@tishlang")
+            .join("tish-macos");
+        std::fs::create_dir_all(&scoped).unwrap();
+        std::fs::write(
+            scoped.join("package.json"),
+            r#"{"name":"@tishlang/tish-macos","tish":{"module":true,"crate":"tishlang_macos","export":"macos_object"}}"#,
+        )
+        .unwrap();
+        let hit = find_package_dir("tish-macos", &project).expect("resolve");
+        assert_eq!(hit.canonicalize().unwrap(), scoped.canonicalize().unwrap());
+    }
+
+    /// npm alias installs (`"tish-macos": "npm:@tishlang/tish-macos@1.2.0"`) put the scoped
+    /// package at the UNSCOPED directory, so the directory name matches but the declared name
+    /// does not. That must resolve too.
+    #[test]
+    fn accepts_scoped_name_at_unscoped_node_modules_dir() {
+        let dir = tempfile::tempdir().expect("tempdir");
+        let root = dir.path();
+        let project = root.join("app");
+        let aliased = project.join("node_modules").join("tish-macos");
+        std::fs::create_dir_all(&aliased).unwrap();
+        std::fs::write(
+            aliased.join("package.json"),
+            r#"{"name":"@tishlang/tish-macos","tish":{"module":true,"crate":"tishlang_macos","export":"macos_object"}}"#,
+        )
+        .unwrap();
+        let hit = find_package_dir("tish-macos", &project).expect("resolve");
+        assert_eq!(hit.canonicalize().unwrap(), aliased.canonicalize().unwrap());
+    }
 }

package/crates/tish_fmt/src/lib.rs

@@ -905,6 +905,9 @@ impl Printer {
         if lead_indent {
             self.indent(level);
         }
+        if self.try_inline_block(statements, span, level) {
+            return;
+        }
         self.buf.push_str("{\n");
         // Fresh sequence: suppress any blank line immediately after `{`.
         self.emitted = 0;
@@ -920,6 +923,80 @@ impl Printer {
         self.emitted = span.start.0;
     }
 
+    /// True when the source wrote this whole block on one line (`{ … }` with its
+    /// matching brace on the same line). The codebase uses `if (c) { return x }`
+    /// and `while (c) { a; b }` as a deliberate idiom; exploding those into
+    /// multi-line blocks was by far the largest source of reformat churn, so a
+    /// block that arrived on one line is kept on one line when it still fits.
+    fn source_one_liner(&self, span: Span) -> bool {
+        match self.braces.get(&span.start) {
+            Some(&(close_line, _)) => close_line == span.start.0,
+            None => false,
+        }
+    }
+
+    /// Statements simple enough to sit inside a preserved one-liner block. Anything
+    /// carrying a block of its own is excluded — nesting one-liners reads worse than
+    /// breaking, and the inline printer here emits no newlines or indentation.
+    fn inlinable_stmt(s: &Statement) -> bool {
+        matches!(
+            s,
+            Statement::ExprStmt { .. }
+                | Statement::Return { .. }
+                | Statement::Break { .. }
+                | Statement::Continue { .. }
+                | Statement::VarDecl { .. }
+                | Statement::VarDeclDestructure { .. }
+                | Statement::Throw { .. }
+        )
+    }
+
+    /// Re-emit a source one-liner block as `{ a; b }`. Returns false (leaving `buf`
+    /// untouched) when the block does not qualify or the flat form would overflow
+    /// [`WIDTH`], in which case the caller falls through to the normal broken form.
+    fn try_inline_block(&mut self, statements: &[Statement], span: Span, _level: usize) -> bool {
+        if self.src.is_empty() || statements.is_empty() {
+            return false;
+        }
+        if !self.source_one_liner(span) {
+            return false;
+        }
+        if !statements.iter().all(Self::inlinable_stmt) {
+            return false;
+        }
+        // A comment anywhere inside would be dropped by the inline path, which emits
+        // no comments at all. Bail out and let the broken form place it properly.
+        let close = self.braces.get(&span.start).copied().unwrap_or(span.start);
+        if self
+            .comments
+            .get(self.ci)
+            .is_some_and(|c| c.start >= span.start && c.start < close)
+        {
+            return false;
+        }
+
+        let mark = self.buf.len();
+        let col = self.col();
+        let was_flat = self.force_flat;
+        self.force_flat = true;
+        self.buf.push_str("{ ");
+        for (i, st) in statements.iter().enumerate() {
+            if i > 0 {
+                self.buf.push_str("; ");
+            }
+            self.stmt(st, 0);
+        }
+        self.buf.push_str(" }");
+        self.force_flat = was_flat;
+
+        if col + (self.buf.len() - mark) <= WIDTH && !self.buf[mark..].contains('\n') {
+            self.emitted = span.start.0;
+            return true;
+        }
+        self.buf.truncate(mark);
+        false
+    }
+
     fn stmt_inline_or_block(&mut self, s: &Statement, level: usize) {
         if let Statement::Block { statements, span } = s {
             self.block(statements, *span, level, false);

package/crates/tish_lint/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tishlang_lint"
-version = "3.9.2"
+version = "3.10.3"
 edition = "2021"
 description = "AST-based linter for Tish"
 license-file = { workspace = true }

package/crates/tish_runtime_gba/Cargo.toml

@@ -3,6 +3,14 @@ name = "tishlang_runtime_gba"
 version = "0.1.0"
 edition = "2021"
 description = "no_std runtime facade for Tish compiled output on the Game Boy Advance (agb)"
+# Spelled out, NOT `{ workspace = true }`: this crate is in the workspace `exclude` list, so it has
+# no workspace root to inherit from. Without these, `cargo publish` refuses the crate outright,
+# which is why it is the one tishlang_* crate that never shipped.
+#
+# The LICENSE is a COPY, not the root one: cargo requires license-file to resolve inside the
+# package directory, and `../../LICENSE` is not packaged.
+license-file = "LICENSE"
+repository = "https://github.com/tishlang/tish"
 
 # The GBA `Gba` emit mode declares the generated crate's dependency as
 #   tishlang_runtime = { package = "tishlang_runtime_gba", path = ... }
@@ -11,6 +19,6 @@ description = "no_std runtime facade for Tish compiled output on the Game Boy Ad
 # tishlang_core / tishlang_builtins and adds the GBA `gba::{init, halt, hooks}`.
 
 [dependencies]
-tishlang_core = { path = "../tish_core", default-features = false, features = ["portable"] }
-tishlang_builtins = { path = "../tish_builtins", default-features = false, features = ["portable"] }
+tishlang_core = { path = "../tish_core", version = ">=0.1", default-features = false, features = ["portable"] }
+tishlang_builtins = { path = "../tish_builtins", version = ">=0.1", default-features = false, features = ["portable"] }
 agb = "0.25.0"

package/crates/tish_runtime_gba/LICENSE

@@ -0,0 +1,13 @@
+Pay It Forward License (PIF)
+
+Copyright (c) 2025-present The Tish Project Authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+This license includes a perpetual, worldwide, non-exclusive, royalty-free, irrevocable (except as stated below) grant for patent claims necessarily infringed by the use of the Software or any contributions submitted to it; terminating automatically when an entity initiates patent litigation (including a cross-claim or counterclaim) alleging that the Software or any portion thereof infringes a patent.
+
+The software is provided "as is," without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose, and non-infringement. In no event shall the authors or copyright holders be liable for any claim, damages, or other liability, whether in an action of contract, tort, or otherwise, arising from, out of, or in connection with the software or the use or other dealings in the software.
+
+Recipients of the Software should pay it forward by contributing to the open-source community through actions including but not limited to providing code, documentation, tutorials, guides, support, feedback, or promoting open-source projects through advocacy or related efforts that advance innovation and community growth.

package/crates/tish_ui/src/jsx.rs

@@ -1,6 +1,7 @@
 //! Shared JSX lowering: emit `h(tag, props, children)` as JavaScript or Rust (`Value`) source.
 
 use std::collections::HashSet;
+use std::sync::Arc;
 
 use tishlang_ast::{
     ArrayElement, ArrowBody, CallArg, ExportDeclaration, Expr, JsxAttrValue, JsxChild, JsxProp,
@@ -401,6 +402,7 @@ where
     match expr {
         Expr::JsxElement {
             tag,
+            tag_span,
             props,
             children,
             ..
@@ -412,7 +414,16 @@ where
                 .unwrap_or(false);
             let tag_rust = if is_component {
                 if fun_decls.contains(tag.as_ref()) {
-                    escape_ident_rust(tag.as_ref())
+                    // Lower the component reference through the caller's own identifier path
+                    // rather than writing the bare name. A module-scope function is promoted to a
+                    // `__TISH_GF_<name>` static, and there is no local of the original name to
+                    // reference — emitting it verbatim produced
+                    // `error[E0425]: cannot find value \`Comp\` in this scope` for every imported
+                    // component. `emit_expr` already resolves statics, locals and captures.
+                    emit_expr(&Expr::Ident {
+                        name: Arc::clone(tag),
+                        span: *tag_span,
+                    })?
                 } else {
                     format!("Value::String({:?}.into())", tag.as_ref())
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tishlang/tish-lint",
-  "version": "3.9.2",
+  "version": "3.10.3",
   "description": "Tish code linter",
   "license": "PIF",
   "repository": {
@@ -14,7 +14,9 @@
     "tish-lint": "./bin/tish-lint"
   },
   "scripts": {
-    "postinstall": "node scripts/install-bin.js"
+    "postinstall": "node scripts/install-bin.js",
+    "prepack": "node scripts/prepack.js",
+    "postpack": "node scripts/postpack.js"
   },
   "files": [
     "bin",