@tishlang/tish 1.0.7 → 1.0.10

package/crates/tish_ast/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "tish_ast"
+version = "0.1.0"
+edition = "2021"
+description = "Tish AST types and span info"
+
+[dependencies]

package/crates/tish_ast/src/ast.rs

@@ -0,0 +1,494 @@
+//! Abstract syntax tree for Tish.
+
+use std::sync::Arc;
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct Span {
+    pub start: (usize, usize), // line, col
+    pub end: (usize, usize),
+}
+
+/// Type annotation for variables, parameters, and return types.
+#[derive(Debug, Clone, PartialEq)]
+pub enum TypeAnnotation {
+    /// Primitive types: number, string, boolean, null
+    Simple(Arc<str>),
+    /// Array type: T[]
+    Array(Box<TypeAnnotation>),
+    /// Object type: { key: Type, ... }
+    Object(Vec<(Arc<str>, TypeAnnotation)>),
+    /// Function type: (T1, T2) => R
+    Function {
+        params: Vec<TypeAnnotation>,
+        returns: Box<TypeAnnotation>,
+    },
+    /// Union type: T1 | T2
+    Union(Vec<TypeAnnotation>),
+}
+
+/// Function parameter with optional type annotation and default value.
+#[derive(Debug, Clone, PartialEq)]
+pub struct TypedParam {
+    pub name: Arc<str>,
+    pub type_ann: Option<TypeAnnotation>,
+    pub default: Option<Expr>,
+}
+
+/// Destructuring pattern for array or object destructuring
+#[derive(Debug, Clone, PartialEq)]
+pub enum DestructPattern {
+    /// Array destructuring: [a, b, c] or [a, , c]
+    Array(Vec<Option<DestructElement>>),
+    /// Object destructuring: { a, b: renamed, c }
+    Object(Vec<DestructProp>),
+}
+
+/// Element in array destructuring pattern
+#[derive(Debug, Clone, PartialEq)]
+pub enum DestructElement {
+    /// Simple binding: a
+    Ident(Arc<str>),
+    /// Nested pattern: [a, b] or { x, y }
+    Pattern(Box<DestructPattern>),
+    /// Rest element: ...rest
+    Rest(Arc<str>),
+}
+
+/// Property in object destructuring pattern
+#[derive(Debug, Clone, PartialEq)]
+pub struct DestructProp {
+    /// Original property name in source object
+    pub key: Arc<str>,
+    /// Binding name (may be same as key or renamed)
+    pub value: DestructElement,
+}
+
+/// Import specifier: named (a, b: c), namespace (* as M), or default (X)
+#[derive(Debug, Clone, PartialEq)]
+pub enum ImportSpecifier {
+    /// Named: { foo } or { foo as bar }
+    Named { name: Arc<str>, alias: Option<Arc<str>> },
+    /// Namespace: * as M
+    Namespace(Arc<str>),
+    /// Default: import X from "..."
+    Default(Arc<str>),
+}
+
+/// Export declaration: named (const/let/fn) or default
+#[derive(Debug, Clone, PartialEq)]
+pub enum ExportDeclaration {
+    /// export const x = 1 / export let x / export fn f() {}
+    Named(Box<Statement>),
+    /// export default expr
+    Default(Expr),
+}
+
+#[derive(Debug, Clone)]
+pub struct Program {
+    pub statements: Vec<Statement>,
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum Statement {
+    Block {
+        statements: Vec<Statement>,
+        span: Span,
+    },
+    VarDecl {
+        name: Arc<str>,
+        mutable: bool, // true for `let`, false for `const`
+        type_ann: Option<TypeAnnotation>,
+        init: Option<Expr>,
+        span: Span,
+    },
+    /// Variable declaration with destructuring pattern
+    VarDeclDestructure {
+        pattern: DestructPattern,
+        mutable: bool,
+        init: Expr,
+        span: Span,
+    },
+    ExprStmt {
+        expr: Expr,
+        span: Span,
+    },
+    If {
+        cond: Expr,
+        then_branch: Box<Statement>,
+        else_branch: Option<Box<Statement>>,
+        span: Span,
+    },
+    While {
+        cond: Expr,
+        body: Box<Statement>,
+        span: Span,
+    },
+    For {
+        init: Option<Box<Statement>>,
+        cond: Option<Expr>,
+        update: Option<Expr>,
+        body: Box<Statement>,
+        span: Span,
+    },
+    ForOf {
+        name: Arc<str>,
+        iterable: Expr,
+        body: Box<Statement>,
+        span: Span,
+    },
+    Return {
+        value: Option<Expr>,
+        span: Span,
+    },
+    Break {
+        span: Span,
+    },
+    Continue {
+        span: Span,
+    },
+    FunDecl {
+        async_: bool,
+        name: Arc<str>,
+        params: Vec<TypedParam>,
+        rest_param: Option<TypedParam>,
+        return_type: Option<TypeAnnotation>,
+        body: Box<Statement>,
+        span: Span,
+    },
+    Switch {
+        expr: Expr,
+        cases: Vec<(Option<Expr>, Vec<Statement>)>,
+        default_body: Option<Vec<Statement>>,
+        span: Span,
+    },
+    DoWhile {
+        body: Box<Statement>,
+        cond: Expr,
+        span: Span,
+    },
+    Throw {
+        value: Expr,
+        span: Span,
+    },
+    Try {
+        body: Box<Statement>,
+        catch_param: Option<Arc<str>>,
+        catch_body: Option<Box<Statement>>,
+        finally_body: Option<Box<Statement>>,
+        span: Span,
+    },
+    Import {
+        specifiers: Vec<ImportSpecifier>,
+        from: Arc<str>,
+        span: Span,
+    },
+    Export {
+        declaration: Box<ExportDeclaration>,
+        span: Span,
+    },
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum Expr {
+    Literal {
+        value: Literal,
+        span: Span,
+    },
+    Ident {
+        name: Arc<str>,
+        span: Span,
+    },
+    Binary {
+        left: Box<Expr>,
+        op: BinOp,
+        right: Box<Expr>,
+        span: Span,
+    },
+    Unary {
+        op: UnaryOp,
+        operand: Box<Expr>,
+        span: Span,
+    },
+    Call {
+        callee: Box<Expr>,
+        args: Vec<CallArg>,
+        span: Span,
+    },
+    Member {
+        object: Box<Expr>,
+        prop: MemberProp,
+        optional: bool,
+        span: Span,
+    },
+    Index {
+        object: Box<Expr>,
+        index: Box<Expr>,
+        optional: bool,
+        span: Span,
+    },
+    Conditional {
+        cond: Box<Expr>,
+        then_branch: Box<Expr>,
+        else_branch: Box<Expr>,
+        span: Span,
+    },
+    NullishCoalesce {
+        left: Box<Expr>,
+        right: Box<Expr>,
+        span: Span,
+    },
+    Array {
+        elements: Vec<ArrayElement>,
+        span: Span,
+    },
+    Object {
+        props: Vec<ObjectProp>,
+        span: Span,
+    },
+    Assign {
+        name: Arc<str>,
+        value: Box<Expr>,
+        span: Span,
+    },
+    TypeOf {
+        operand: Box<Expr>,
+        span: Span,
+    },
+    PostfixInc {
+        name: Arc<str>,
+        span: Span,
+    },
+    PostfixDec {
+        name: Arc<str>,
+        span: Span,
+    },
+    PrefixInc {
+        name: Arc<str>,
+        span: Span,
+    },
+    PrefixDec {
+        name: Arc<str>,
+        span: Span,
+    },
+    CompoundAssign {
+        name: Arc<str>,
+        op: CompoundOp,
+        value: Box<Expr>,
+        span: Span,
+    },
+    LogicalAssign {
+        name: Arc<str>,
+        op: LogicalAssignOp,
+        value: Box<Expr>,
+        span: Span,
+    },
+    /// Property assignment: obj.prop = value
+    MemberAssign {
+        object: Box<Expr>,
+        prop: Arc<str>,
+        value: Box<Expr>,
+        span: Span,
+    },
+    /// Index assignment: arr[index] = value
+    IndexAssign {
+        object: Box<Expr>,
+        index: Box<Expr>,
+        value: Box<Expr>,
+        span: Span,
+    },
+    /// Arrow function: (params) => body
+    ArrowFunction {
+        params: Vec<TypedParam>,
+        body: ArrowBody,
+        span: Span,
+    },
+    /// Template literal: `text ${expr} text`
+    TemplateLiteral {
+        quasis: Vec<Arc<str>>,    // Static string parts (n+1 for n expressions)
+        exprs: Vec<Expr>,          // Interpolated expressions (n)
+        span: Span,
+    },
+    /// Await expression: await operand
+    Await {
+        operand: Box<Expr>,
+        span: Span,
+    },
+    /// JSX element: <Tag props>children</Tag>
+    JsxElement {
+        tag: Arc<str>,
+        props: Vec<JsxProp>,
+        children: Vec<JsxChild>,
+        span: Span,
+    },
+    /// JSX fragment: <>children</>
+    JsxFragment {
+        children: Vec<JsxChild>,
+        span: Span,
+    },
+    /// Native module load: import { x } from 'tish:egui' → loads from tish_runtime
+    NativeModuleLoad {
+        spec: Arc<str>,
+        export_name: Arc<str>,
+        span: Span,
+    },
+}
+
+/// JSX attribute/prop
+#[derive(Debug, Clone, PartialEq)]
+pub enum JsxProp {
+    /// name="value" or name={expr} or name (boolean shorthand)
+    Attr {
+        name: Arc<str>,
+        value: JsxAttrValue,
+    },
+    /// {...expr}
+    Spread(Expr),
+}
+
+/// JSX attribute value
+#[derive(Debug, Clone, PartialEq)]
+pub enum JsxAttrValue {
+    /// "literal string"
+    String(Arc<str>),
+    /// {expr}
+    Expr(Expr),
+    /// name without value (e.g. disabled) = true
+    ImplicitTrue,
+}
+
+/// JSX child node
+#[derive(Debug, Clone, PartialEq)]
+pub enum JsxChild {
+    /// Text content
+    Text(Arc<str>),
+    /// {expr} or nested element
+    Expr(Expr),
+}
+
+impl Expr {
+    /// Return the source span for this expression.
+    pub fn span(&self) -> Span {
+        match self {
+            Expr::Literal { span, .. } => *span,
+            Expr::Ident { span, .. } => *span,
+            Expr::Binary { span, .. } => *span,
+            Expr::Unary { span, .. } => *span,
+            Expr::Call { span, .. } => *span,
+            Expr::Member { span, .. } => *span,
+            Expr::Index { span, .. } => *span,
+            Expr::Conditional { span, .. } => *span,
+            Expr::NullishCoalesce { span, .. } => *span,
+            Expr::Array { span, .. } => *span,
+            Expr::Object { span, .. } => *span,
+            Expr::Assign { span, .. } => *span,
+            Expr::TypeOf { span, .. } => *span,
+            Expr::PostfixInc { span, .. } => *span,
+            Expr::PostfixDec { span, .. } => *span,
+            Expr::PrefixInc { span, .. } => *span,
+            Expr::PrefixDec { span, .. } => *span,
+            Expr::CompoundAssign { span, .. } => *span,
+            Expr::LogicalAssign { span, .. } => *span,
+            Expr::MemberAssign { span, .. } => *span,
+            Expr::IndexAssign { span, .. } => *span,
+            Expr::ArrowFunction { span, .. } => *span,
+            Expr::TemplateLiteral { span, .. } => *span,
+            Expr::Await { span, .. } => *span,
+            Expr::JsxElement { span, .. } => *span,
+            Expr::JsxFragment { span, .. } => *span,
+            Expr::NativeModuleLoad { span, .. } => *span,
+        }
+    }
+}
+
+/// Body of an arrow function: either an expression or a block
+#[derive(Debug, Clone, PartialEq)]
+pub enum ArrowBody {
+    Expr(Box<Expr>),
+    Block(Box<Statement>),
+}
+
+/// Array element: either a regular expression or spread element
+#[derive(Debug, Clone, PartialEq)]
+pub enum ArrayElement {
+    Expr(Expr),
+    Spread(Expr),
+}
+
+/// Object property: either a regular key-value pair or spread
+#[derive(Debug, Clone, PartialEq)]
+pub enum ObjectProp {
+    KeyValue(Arc<str>, Expr),
+    Spread(Expr),
+}
+
+/// Function call argument: either a regular argument or spread
+#[derive(Debug, Clone, PartialEq)]
+pub enum CallArg {
+    Expr(Expr),
+    Spread(Expr),
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum CompoundOp {
+    Add,  // +=
+    Sub,  // -=
+    Mul,  // *=
+    Div,  // /=
+    Mod,  // %=
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum LogicalAssignOp {
+    AndAnd,  // &&=
+    OrOr,    // ||=
+    Nullish, // ??=
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum Literal {
+    Number(f64),
+    String(Arc<str>),
+    Bool(bool),
+    Null,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum BinOp {
+    Add,
+    Sub,
+    Mul,
+    Div,
+    Mod,
+    Pow,
+    Eq,
+    Ne,
+    StrictEq,
+    StrictNe,
+    Lt,
+    Le,
+    Gt,
+    Ge,
+    And,
+    Or,
+    BitAnd,
+    BitOr,
+    BitXor,
+    Shl,
+    Shr,
+    In,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum UnaryOp {
+    Not,
+    Neg,
+    Pos,
+    BitNot,
+    Void,
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum MemberProp {
+    Name(Arc<str>),
+    Expr(Box<Expr>), // for computed property
+}

package/crates/tish_ast/src/lib.rs

@@ -0,0 +1,5 @@
+//! Tish AST types and span info.
+
+mod ast;
+
+pub use ast::*;

package/crates/tish_build_utils/Cargo.toml

@@ -0,0 +1,5 @@
+[package]
+name = "tish_build_utils"
+version = "0.1.0"
+edition = "2021"
+description = "Shared build utilities for Tish (workspace discovery, path resolution)"

package/crates/tish_build_utils/src/lib.rs

@@ -0,0 +1,175 @@
+//! Shared build utilities for Tish.
+//!
+//! Provides workspace discovery, path resolution, and Cargo build orchestration
+//! used by tish_wasm, tish_cranelift, tish_native, and the tish CLI.
+
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+/// Find the Tish workspace root using multiple strategies.
+///
+/// Returns the directory containing the workspace Cargo.toml (with [workspace]).
+/// Used when building native binaries, WASM, or locating runtime crates.
+pub fn find_workspace_root() -> Result<PathBuf, String> {
+    // Strategy 1: CARGO_MANIFEST_DIR (works during cargo build/run from workspace)
+    if let Ok(manifest_dir) = std::env::var("CARGO_MANIFEST_DIR") {
+        let path = PathBuf::from(&manifest_dir);
+        // For crates/tish_*, workspace root is parent.parent()
+        if let Some(root) = path.parent().and_then(|p| p.parent()) {
+            let root_buf = root.to_path_buf();
+            if root_buf.join("Cargo.toml").exists() {
+                return Ok(root_buf);
+            }
+        }
+    }
+
+    // Strategy 2: Walk from current executable (e.g. target/debug/tish)
+    if let Ok(exe) = std::env::current_exe() {
+        if let Some(mut current) = exe.parent() {
+            for _ in 0..15 {
+                let crates_dir = current.join("crates");
+                if crates_dir.join("tish_runtime").exists() || crates_dir.join("tish_cranelift_runtime").exists() {
+                    return Ok(current.to_path_buf());
+                }
+                if let Some(p) = current.parent() {
+                    current = p;
+                } else {
+                    break;
+                }
+            }
+        }
+    }
+
+    // Strategy 3: Walk from current working directory
+    if let Ok(mut current) = std::env::current_dir() {
+        for _ in 0..15 {
+            let cargo_toml = current.join("Cargo.toml");
+            if cargo_toml.exists() {
+                if let Ok(content) = std::fs::read_to_string(&cargo_toml) {
+                    if content.contains("[workspace]") {
+                        return Ok(current);
+                    }
+                }
+                // Fallback: check for crates dir with known crates
+                let crates_dir = current.join("crates");
+                if crates_dir.join("tish_runtime").exists() {
+                    return Ok(current);
+                }
+            }
+            if !current.pop() {
+                break;
+            }
+        }
+    }
+
+    Err("Cannot find Tish workspace root. Run from workspace root or use cargo run.".to_string())
+}
+
+/// Find the path to the tish_runtime crate.
+///
+/// Returns a canonical path string suitable for Cargo.toml path dependencies.
+pub fn find_runtime_path() -> Result<String, String> {
+    let workspace = find_workspace_root()?;
+    let runtime = workspace.join("crates").join("tish_runtime");
+    if !runtime.exists() {
+        return Err("tish_runtime crate not found".to_string());
+    }
+    runtime
+        .canonicalize()
+        .map_err(|e| format!("Cannot canonicalize tish_runtime: {}", e))
+        .map(|p| p.display().to_string().replace('\\', "/"))
+}
+
+/// Find the path to a crate within the workspace by name.
+///
+/// e.g. `find_crate_path("tish_cranelift_runtime")` returns the path to crates/tish_cranelift_runtime.
+pub fn find_crate_path(crate_name: &str) -> Result<PathBuf, String> {
+    let workspace = find_workspace_root()?;
+    let crate_path = workspace.join("crates").join(crate_name);
+    if !crate_path.exists() {
+        return Err(format!("Crate {} not found", crate_name));
+    }
+    Ok(crate_path)
+}
+
+/// Create a temp build directory with src subdir.
+pub fn create_build_dir(prefix: &str, out_name: &str) -> Result<PathBuf, String> {
+    let build_dir = std::env::temp_dir().join(prefix).join(format!("{}_{}", out_name, std::process::id()));
+    fs::create_dir_all(&build_dir).map_err(|e| format!("Cannot create build dir: {}", e))?;
+    fs::create_dir_all(build_dir.join("src")).map_err(|e| format!("Cannot create src dir: {}", e))?;
+    Ok(build_dir)
+}
+
+/// Run cargo build in the given directory.
+/// If target_dir is Some, use that for --target-dir (e.g. workspace target for caching).
+pub fn run_cargo_build(build_dir: &Path, target_dir: Option<&Path>) -> Result<(), String> {
+    let target_dir = target_dir.map(|p| p.to_path_buf()).unwrap_or_else(|| build_dir.join("target"));
+    let output = Command::new("cargo")
+        .args(["build", "--release", "--target-dir"])
+        .arg(&target_dir)
+        .current_dir(build_dir)
+        .env_remove("CARGO_TARGET_DIR")
+        .env("CARGO_TERM_PROGRESS", "always")
+        .output()
+        .map_err(|e| format!("Failed to run cargo: {}", e))?;
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        let stdout = String::from_utf8_lossy(&output.stdout);
+        return Err(format!("Compilation failed.\nstdout:\n{}\nstderr:\n{}", stdout, stderr));
+    }
+    Ok(())
+}
+
+/// Find the built binary in target/release.
+pub fn find_release_binary(binary_dir: &Path, bin_name: &str) -> Result<PathBuf, String> {
+    let binary_no_ext = binary_dir.join(bin_name);
+    let binary_exe = binary_dir.join(format!("{}.exe", bin_name));
+    if binary_no_ext.exists() {
+        Ok(binary_no_ext)
+    } else if binary_exe.exists() {
+        Ok(binary_exe)
+    } else {
+        Err(format!(
+            "Binary not found at {} or {}",
+            binary_no_ext.display(),
+            binary_exe.display()
+        ))
+    }
+}
+
+/// Resolve the output path for the binary (handles extension, directory).
+pub fn resolve_output_path(output_path: &Path, bin_name: &str) -> PathBuf {
+    if output_path.extension().is_none()
+        || output_path.extension() == Some(std::ffi::OsStr::new(""))
+    {
+        let mut p = output_path.to_path_buf();
+        if cfg!(windows) {
+            p.set_extension("exe");
+        }
+        return p;
+    }
+    if output_path.to_string_lossy().ends_with('/') || output_path.is_dir() {
+        let dir = if output_path.is_dir() {
+            output_path.to_path_buf()
+        } else {
+            output_path.parent().unwrap_or(Path::new(".")).to_path_buf()
+        };
+        return dir.join(if cfg!(windows) {
+            format!("{}.exe", bin_name)
+        } else {
+            bin_name.to_string()
+        });
+    }
+    output_path.to_path_buf()
+}
+
+/// Copy the built binary to the output path.
+pub fn copy_binary_to_output(binary: &Path, output_path: &Path) -> Result<(), String> {
+    if let Some(parent) = output_path.parent() {
+        fs::create_dir_all(parent).map_err(|e| format!("Cannot create output dir: {}", e))?;
+    }
+    fs::copy(binary, output_path).map_err(|e| format!("Cannot copy to {}: {}", output_path.display(), e))?;
+    Ok(())
+}

package/crates/tish_builtins/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "tish_builtins"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+rand = "0.10.0"
+tish_core = { path = "../tish_core" }
+
+[features]
+default = []
+regex = ["tish_core/regex"]