@tishlang/tish 1.0.7 → 1.0.11

package/Cargo.toml

@@ -0,0 +1,43 @@
+[workspace]
+members = [
+    "crates/tish_build_utils",
+    "crates/tish_cranelift",
+    "crates/tish_cranelift_runtime",
+    "crates/tish_wasm_runtime",
+    "crates/tish_core",
+    "crates/tish_builtins",
+    "crates/tish_lexer",
+    "crates/tish_ast",
+    "crates/tish_parser",
+    "crates/tish_opt",
+    "crates/tish_eval",
+    "crates/tish_runtime",
+    "crates/tish_compile",
+    "crates/tish_jsx_web",
+    "crates/tish_compile_js",
+    "crates/tish_bytecode",
+    "crates/tish_compiler_wasm",
+    "crates/tish_vm",
+    "crates/tish_llvm",
+    "crates/tish_native",
+    "crates/tish_wasm",
+    "crates/tish",
+    "crates/js_to_tish",
+    "crates/tish_fmt",
+    "crates/tish_lint",
+    "crates/tish_lsp",
+]
+resolver = "2"
+
+[workspace.package]
+license-file = "LICENSE"
+repository = "https://github.com/tishlang/tish"
+
+[profile.release]
+lto = "thin"
+codegen-units = 1
+opt-level = 3
+
+[profile.bench]
+inherits = "release"
+debug = true

package/LICENSE

@@ -0,0 +1,13 @@
+Pay It Forward License (PIF)
+
+Copyright (c) 2025 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/README.md

@@ -0,0 +1,66 @@
+# @tishlang/tish
+
+[Tish](https://github.com/tishlang/tish) is a minimal TypeScript/JavaScript–compatible language: run with an interpreter, use a REPL, or compile to native binaries.
+
+This npm package ships the **Tish CLI** for Node.js **22+**. It includes platform-specific native binaries; the `tish` command picks the right one for your OS and CPU.
+
+## Install
+
+```bash
+npm install @tishlang/tish
+```
+
+Or run without installing:
+
+```bash
+npx @tishlang/tish --help
+```
+
+## Quick start
+
+Run a `.tish` file (shorthand: first argument is treated as a file → `run`):
+
+```bash
+npx @tishlang/tish hello.tish
+npx @tishlang/tish run src/main.tish
+```
+
+Compile to a native executable:
+
+```bash
+npx @tishlang/tish compile app.tish -o app
+./app
+```
+
+Native compilation uses the Rust backend by default (requires [Rust](https://rustup.rs) and `cargo` on your PATH). The package includes the Tish workspace source (`Cargo.toml`, `crates/`, `justfile`) so `tish compile` can run `cargo build` for your program. For pure Tish without native imports, use `--native-backend cranelift` (no Rust toolchain needed).
+
+Start the REPL:
+
+```bash
+npx @tishlang/tish repl
+```
+
+## Supported platforms
+
+Prebuilt binaries are included for:
+
+- `darwin-arm64`, `darwin-x64`
+- `linux-x64`, `linux-arm64`
+- `win32-x64`
+
+If your platform is missing, [build from source](https://github.com/tishlang/tish).
+
+## Documentation
+
+- Repository: <https://github.com/tishlang/tish>
+- User docs: <https://github.com/tishlang/tish-docs>
+
+## Scaffold a project
+
+```bash
+npx @tishlang/create-tish-app my-app
+```
+
+## License
+
+See the [Tish repository LICENSE](https://github.com/tishlang/tish/blob/main/LICENSE) (Pay It Forward).

package/crates/js_to_tish/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "js_to_tish"
+version = "0.1.0"
+edition = "2021"
+description = "Vanilla JavaScript to Tish AST converter"
+
+[dependencies]
+oxc = { version = "0.121", features = ["semantic"] }
+tish_ast = { path = "../tish_ast" }

package/crates/js_to_tish/README.md

@@ -0,0 +1,18 @@
+# js_to_tish
+
+Vanilla JavaScript to Tish AST converter. Parses JavaScript with OXC, runs semantic analysis, normalizes to Tish's model, and emits `tish_ast::Program`.
+
+## Usage
+
+```rust
+use js_to_tish;
+use tish_compile_js;
+
+let program = js_to_tish::convert(js_source)?;
+let js = tish_compile_js::compile(&program)?;  // output as JavaScript
+```
+
+## Output options
+
+- **JavaScript**: `tish_compile_js::compile(&program)` → `String`
+- **Bytecode (run)**: `tish_bytecode::compile(&program)` → `Chunk`, then `tish_vm::run(&chunk)`

package/crates/js_to_tish/src/error.rs

@@ -0,0 +1,61 @@
+//! Conversion error types.
+
+use std::fmt;
+
+/// Error returned when JS cannot be converted to Tish.
+#[derive(Debug)]
+pub struct ConvertError {
+    pub kind: ConvertErrorKind,
+}
+
+impl ConvertError {
+    pub fn new(kind: ConvertErrorKind) -> Self {
+        Self { kind }
+    }
+}
+
+impl fmt::Display for ConvertError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.kind)
+    }
+}
+
+impl std::error::Error for ConvertError {}
+
+/// Categorizes conversion failures.
+#[derive(Debug)]
+pub enum ConvertErrorKind {
+    /// Parse error from OXC.
+    Parse(String),
+    /// Semantic analysis error from OXC.
+    Semantic(String),
+    /// Unsupported construct (class, this, for-in, etc.).
+    Unsupported {
+        what: String,
+        hint: Option<String>,
+    },
+    /// JS feature that cannot be expressed in Tish.
+    Incompatible {
+        what: String,
+        reason: String,
+    },
+}
+
+impl fmt::Display for ConvertErrorKind {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            ConvertErrorKind::Parse(s) => write!(f, "parse error: {s}"),
+            ConvertErrorKind::Semantic(s) => write!(f, "semantic error: {s}"),
+            ConvertErrorKind::Unsupported { what, hint } => {
+                write!(f, "unsupported: {what}")?;
+                if let Some(h) = hint {
+                    write!(f, " ({h})")?;
+                }
+                Ok(())
+            }
+            ConvertErrorKind::Incompatible { what, reason } => {
+                write!(f, "incompatible: {what} — {reason}")
+            }
+        }
+    }
+}

package/crates/js_to_tish/src/lib.rs

@@ -0,0 +1,11 @@
+//! Vanilla JavaScript to Tish AST converter.
+//!
+//! Parses JavaScript with OXC, runs semantic analysis for scope/hoisting,
+//! normalizes to Tish's simpler model, and emits Tish AST.
+
+mod error;
+mod span_util;
+mod transform;
+
+pub use error::{ConvertError, ConvertErrorKind};
+pub use transform::convert;

package/crates/js_to_tish/src/span_util.rs

@@ -0,0 +1,35 @@
+//! Span conversion from OXC offsets to Tish (line, col).
+
+use oxc::span::GetSpan;
+use tish_ast::Span;
+
+/// Convert OXC span (byte start/end) to Tish Span (line, col).
+/// Uses source text to compute line/column from offsets.
+pub fn oxc_span_to_tish<T: GetSpan>(source: &str, oxc_span: &T) -> Span {
+    let s = oxc_span.span();
+    let start = offset_to_line_col(source, s.start);
+    let end = offset_to_line_col(source, s.end);
+    Span { start, end }
+}
+
+/// Compute (line, col) for byte offset. Lines and columns are 0-based.
+fn offset_to_line_col(source: &str, offset: u32) -> (usize, usize) {
+    let offset = offset as usize;
+    if offset >= source.len() {
+        let lines = source.lines().count();
+        let last_line_len = source.lines().last().map(str::len).unwrap_or(0);
+        return (lines.saturating_sub(1), last_line_len);
+    }
+    let prefix = &source[..offset];
+    let line = prefix.lines().count().saturating_sub(1);
+    let col = prefix.lines().last().map(str::len).unwrap_or(0);
+    (line, col)
+}
+
+/// Stub span when source is not available (e.g. synthetic nodes).
+pub fn stub_span() -> Span {
+    Span {
+        start: (0, 0),
+        end: (0, 0),
+    }
+}