@tishlang/tish 1.7.0 → 1.9.0

package/crates/tish_compile/src/types.rs

@@ -4,7 +4,7 @@
 
 use std::collections::HashMap;
 use std::sync::Arc;
-use tishlang_ast::{BinOp, TypeAnnotation};
+use tishlang_ast::{BinOp, FunParam, TypeAnnotation, TypedParam};
 
 /// Concrete Rust type representation for code generation.
 #[derive(Debug, Clone, PartialEq)]
@@ -23,8 +23,19 @@ pub enum RustType {
     Vec(Box<RustType>),
     /// Option<T> for nullable types (T | null)
     Option(Box<RustType>),
-    /// Rc<RefCell<HashMap<Arc<str>, T>>> for typed objects
+    /// Inline object shape — used during inference / annotation lowering
+    /// before a `Named` alias has been registered. Once a corresponding
+    /// `type Foo = { ... }` declaration is found in the program, occurrences
+    /// of this shape can be canonicalised into `RustType::Named("Foo")`.
     Object(Vec<(Arc<str>, RustType)>),
+    /// User-defined named type (a struct emitted by the compiler).
+    /// The field list is duplicated here so the codegen can emit struct
+    /// literals, member access, and Value-conversion glue without going
+    /// back to a global registry on every call site.
+    Named {
+        name: Arc<str>,
+        fields: Vec<(Arc<str>, RustType)>,
+    },
     /// Fn trait for typed functions
     Function {
         params: Vec<RustType>,
@@ -33,8 +44,21 @@ pub enum RustType {
 }
 
 impl RustType {
-    /// Convert a TypeAnnotation to a RustType.
+    /// Convert a TypeAnnotation to a RustType (no alias resolution).
+    /// Use [`Self::from_annotation_with_aliases`] when a registry is
+    /// available so user-defined `type X = { ... }` aliases land as
+    /// `RustType::Named` and can drive struct emission.
     pub fn from_annotation(ann: &TypeAnnotation) -> Self {
+        Self::from_annotation_with_aliases(ann, &HashMap::new())
+    }
+
+    /// Like [`from_annotation`], but consults `aliases` so a `Simple(name)`
+    /// reference to a user-declared `type X = { ... }` resolves to a
+    /// `RustType::Named { name, fields }` carrying the struct shape.
+    pub fn from_annotation_with_aliases(
+        ann: &TypeAnnotation,
+        aliases: &HashMap<String, RustType>,
+    ) -> Self {
         match ann {
             TypeAnnotation::Simple(name) => match name.as_ref() {
                 "number" => RustType::F64,
@@ -43,19 +67,38 @@ impl RustType {
                 "void" | "undefined" => RustType::Unit,
                 "null" => RustType::Unit,
                 "any" => RustType::Value,
-                _ => RustType::Value, // Unknown types fall back to Value
+                other => {
+                    // User-declared `type X = { ... }`: lift the inline
+                    // object shape into a `Named` so the codegen can emit
+                    // a Rust struct and direct field access for it.
+                    if let Some(t) = aliases.get(other) {
+                        if let RustType::Object(fields) = t {
+                            return RustType::Named {
+                                name: Arc::from(other),
+                                fields: fields.clone(),
+                            };
+                        }
+                        return t.clone();
+                    }
+                    RustType::Value
+                }
             },
-            TypeAnnotation::Array(elem) => RustType::Vec(Box::new(Self::from_annotation(elem))),
+            TypeAnnotation::Array(elem) => RustType::Vec(Box::new(
+                Self::from_annotation_with_aliases(elem, aliases),
+            )),
             TypeAnnotation::Object(fields) => {
                 let typed_fields: Vec<_> = fields
                     .iter()
-                    .map(|(k, v)| (k.clone(), Self::from_annotation(v)))
+                    .map(|(k, v)| (k.clone(), Self::from_annotation_with_aliases(v, aliases)))
                     .collect();
                 RustType::Object(typed_fields)
             }
             TypeAnnotation::Function { params, returns } => {
-                let typed_params: Vec<_> = params.iter().map(Self::from_annotation).collect();
-                let typed_returns = Box::new(Self::from_annotation(returns));
+                let typed_params: Vec<_> = params
+                    .iter()
+                    .map(|p| Self::from_annotation_with_aliases(p, aliases))
+                    .collect();
+                let typed_returns = Box::new(Self::from_annotation_with_aliases(returns, aliases));
                 RustType::Function {
                     params: typed_params,
                     returns: typed_returns,
@@ -72,7 +115,9 @@ impl RustType {
                             |t| !matches!(t, TypeAnnotation::Simple(s) if s.as_ref() == "null"),
                         );
                         if let Some(inner) = non_null {
-                            return RustType::Option(Box::new(Self::from_annotation(inner)));
+                            return RustType::Option(Box::new(
+                                Self::from_annotation_with_aliases(inner, aliases),
+                            ));
                         }
                     }
                 }
@@ -130,9 +175,11 @@ impl RustType {
             RustType::Vec(inner) => format!("Vec<{}>", inner.to_rust_type_str()),
             RustType::Option(inner) => format!("Option<{}>", inner.to_rust_type_str()),
             RustType::Object(_) => {
-                // For now, typed objects still use Value
+                // Anonymous inline shapes don't have a Rust struct; fall
+                // back to the dynamic Value path.
                 "Value".to_string()
             }
+            RustType::Named { name, .. } => named_struct_ident(name),
             RustType::Function { params, returns } => {
                 let params_str: Vec<_> = params.iter().map(|p| p.to_rust_type_str()).collect();
                 format!(
@@ -155,6 +202,23 @@ impl RustType {
             RustType::Vec(_) => "Vec::new()".to_string(),
             RustType::Option(_) => "None".to_string(),
             RustType::Object(_) => "Value::Null".to_string(),
+            RustType::Named { fields, .. } => {
+                // Build a literal struct with each field at its own default,
+                // so unannotated decls of a typed struct still compile.
+                let init = fields
+                    .iter()
+                    .map(|(k, t)| format!("{}: {}", field_ident(k), t.default_value()))
+                    .collect::<Vec<_>>()
+                    .join(", ");
+                format!(
+                    "{} {{ {} }}",
+                    named_struct_ident(match self {
+                        RustType::Named { name, .. } => name,
+                        _ => unreachable!(),
+                    }),
+                    init
+                )
+            }
             RustType::Function { .. } => "Value::Null".to_string(),
         }
     }
@@ -190,6 +254,22 @@ impl RustType {
                     value_expr, inner_conversion
                 )
             }
+            RustType::Named { name, fields } => {
+                // Each field is fetched out of the Value::Object via
+                // `get_prop` and converted to its native type. Falls back
+                // to the field's `default_value()` if the field is absent
+                // (rare — usually these come from JSON or PG).
+                let field_assigns = fields
+                    .iter()
+                    .map(|(k, ty)| {
+                        let fetch =
+                            format!("tishlang_runtime::get_prop(&{}, {:?})", value_expr, k.as_ref());
+                        format!("{}: {}", field_ident(k), ty.from_value_expr(&fetch))
+                    })
+                    .collect::<Vec<_>>()
+                    .join(", ");
+                format!("{} {{ {} }}", named_struct_ident(name), field_assigns)
+            }
             _ => value_expr.to_string(), // Fallback
         }
     }
@@ -210,7 +290,7 @@ impl RustType {
                     _ => (".iter().cloned()", inner.to_value_expr("v")),
                 };
                 format!(
-                    "Value::Array(Rc::new(RefCell::new({}{}.map(|v| {}).collect())))",
+                    "Value::Array(VmRef::new({}{}.map(|v| {}).collect()))",
                     native_expr, iter_suffix, val_expr
                 )
             }
@@ -221,11 +301,57 @@ impl RustType {
                     native_expr, inner_to_value
                 )
             }
+            RustType::Named { fields, .. } => {
+                // Walk fields, build an ObjectMap, wrap in Value::Object.
+                // The boundary is paid only when crossing into untyped
+                // Tish (JSON.stringify, calling a Value::Function, etc.);
+                // direct Rust-to-Rust paths between two Named values stay
+                // as plain struct moves.
+                let inserts = fields
+                    .iter()
+                    .map(|(k, ty)| {
+                        let access = format!("{}.{}", native_expr, field_ident(k));
+                        let v_expr = ty.to_value_expr(&access);
+                        format!(
+                            "_om.insert(::std::sync::Arc::from({:?}), {});",
+                            k.as_ref(),
+                            v_expr
+                        )
+                    })
+                    .collect::<Vec<_>>()
+                    .join(" ");
+                format!(
+                    "{{ let mut _om = ObjectMap::default(); {} Value::Object(VmRef::new(_om)) }}",
+                    inserts
+                )
+            }
             _ => native_expr.to_string(), // Fallback
         }
     }
 }
 
+/// Map a Tish type-alias name to the Rust struct identifier we emit.
+/// Prefixed so user names can never collide with runtime types like `Value`.
+pub fn named_struct_ident(tish_name: &str) -> String {
+    format!("TishStruct_{}", tish_name)
+}
+
+/// Map a Tish field name (`randomNumber`) to a valid Rust identifier
+/// (kept identical here — non-snake-case is allowed via
+/// `#[allow(non_snake_case)]` on the struct, so JS-style camelCase keys
+/// stay readable in the generated source).
+pub fn field_ident(tish_name: &str) -> String {
+    // Reserve Rust keywords that would otherwise conflict.
+    match tish_name {
+        "type" | "ref" | "fn" | "match" | "move" | "mod" | "self" | "Self" | "super" | "use"
+        | "where" | "loop" | "yield" | "async" | "await" | "dyn" | "impl" | "trait" | "in"
+        | "as" | "box" | "crate" | "const" | "extern" | "let" | "mut" | "pub" | "static"
+        | "unsafe" | "abstract" | "become" | "do" | "final" | "macro" | "override" | "priv"
+        | "typeof" | "unsized" | "virtual" => format!("r#{}", tish_name),
+        _ => tish_name.to_string(),
+    }
+}
+
 /// Type context for tracking variable types during code generation.
 #[derive(Debug, Clone, Default)]
 pub struct TypeContext {
@@ -250,6 +376,23 @@ impl TypeContext {
         self.scopes.pop();
     }
 
+    /// Push a scope for a function or arrow body and record formals as [`RustType::Value`].
+    ///
+    /// Native codegen always binds parameters from `args.get(i)` as `Value`; this prevents
+    /// outer locals (e.g. a loop counter inferred as [`RustType::F64`]) from shadowing the
+    /// wrong type for the same identifier.
+    pub fn push_fun_param_scope(&mut self, params: &[FunParam], rest_param: Option<&TypedParam>) {
+        self.push_scope();
+        for p in params {
+            for name in p.bound_names() {
+                self.define(name.as_ref(), RustType::Value);
+            }
+        }
+        if let Some(rp) = rest_param {
+            self.define(rp.name.as_ref(), RustType::Value);
+        }
+    }
+
     /// Define a variable in the current scope.
     pub fn define(&mut self, name: &str, ty: RustType) {
         if let Some(scope) = self.scopes.last_mut() {
@@ -334,4 +477,25 @@ mod tests {
         ctx.pop_scope();
         assert_eq!(ctx.get_type("y"), RustType::Value); // y no longer visible
     }
+
+    #[test]
+    fn push_fun_param_scope_shadows_outer() {
+        use tishlang_ast::{FunParam, Span, TypedParam};
+
+        let mut ctx = TypeContext::new();
+        ctx.define("n", RustType::F64);
+        let params = vec![FunParam::Simple(TypedParam {
+            name: "n".into(),
+            name_span: Span {
+                start: (0, 0),
+                end: (0, 0),
+            },
+            type_ann: None,
+            default: None,
+        })];
+        ctx.push_fun_param_scope(&params, None);
+        assert_eq!(ctx.get_type("n"), RustType::Value);
+        ctx.pop_scope();
+        assert_eq!(ctx.get_type("n"), RustType::F64);
+    }
 }

package/crates/tish_compile_js/Cargo.toml

@@ -10,6 +10,7 @@ repository = { workspace = true }
 default = []
 
 [dependencies]
+sourcemap = "9.3"
 tishlang_ast = { path = "../tish_ast", version = ">=0.1" }
 tishlang_compile = { path = "../tish_compile", version = ">=0.1" }
 tishlang_opt = { path = "../tish_opt", version = ">=0.1" }

package/crates/tish_compile_js/src/codegen.rs

@@ -1,5 +1,8 @@
 //! Code generation: AST -> JavaScript source.
 
+use std::path::{Path, PathBuf};
+
+use sourcemap::SourceMapBuilder;
 use tishlang_ast::{
     ArrayElement, ArrowBody, BinOp, CallArg, CompoundOp, DestructElement, DestructPattern, Expr,
     FunParam, Literal, LogicalAssignOp, MemberProp, ObjectProp, Program, Statement, UnaryOp,
@@ -45,6 +48,10 @@ impl Codegen {
         self.output.push('\n');
     }
 
+    fn output_line(&self) -> u32 {
+        self.output.as_bytes().iter().filter(|&&b| b == b'\n').count() as u32
+    }
+
     fn escape_ident(s: &str) -> String {
         let s = s.to_string();
         if s == "await" || s == "default" {
@@ -54,10 +61,46 @@ impl Codegen {
         }
     }
 
-    fn emit_program(&mut self, program: &Program) -> Result<(), CompileError> {
+    fn emit_program(
+        &mut self,
+        program: &Program,
+        map_sources: Option<(&[PathBuf], &Path)>,
+        map_builder: Option<&mut SourceMapBuilder>,
+    ) -> Result<(), CompileError> {
         self.write("// Generated by tishlang_compile_js\n");
-        for stmt in &program.statements {
-            self.emit_statement(stmt)?;
+        match (map_sources, map_builder) {
+            (Some((srcs, root)), Some(sm)) => {
+                for (i, stmt) in program.statements.iter().enumerate() {
+                    if i < srcs.len() {
+                        let dst_line = self.output_line();
+                        let sp = stmt.span();
+                        let src_line = sp.start.0.saturating_sub(1) as u32;
+                        let src_col = sp.start.1.saturating_sub(1) as u32;
+                        let abs = srcs[i].as_path();
+                        let root_canon = root.canonicalize().unwrap_or_else(|_| root.to_path_buf());
+                        let abs_canon = abs.canonicalize().unwrap_or_else(|_| abs.to_path_buf());
+                        let rel = abs_canon
+                            .strip_prefix(&root_canon)
+                            .unwrap_or(abs_canon.as_path());
+                        let rel_str = rel.to_string_lossy();
+                        sm.add(
+                            dst_line,
+                            0,
+                            src_line,
+                            src_col,
+                            Some(rel_str.as_ref()),
+                            None,
+                            false,
+                        );
+                    }
+                    self.emit_statement(stmt)?;
+                }
+            }
+            _ => {
+                for stmt in &program.statements {
+                    self.emit_statement(stmt)?;
+                }
+            }
         }
         Ok(())
     }
@@ -301,6 +344,9 @@ impl Codegen {
             Statement::Import { .. } | Statement::Export { .. } => {
                 // Resolved away by merge_modules
             }
+            Statement::TypeAlias { .. }
+            | Statement::DeclareVar { .. }
+            | Statement::DeclareFun { .. } => {}
         }
         Ok(())
     }
@@ -347,9 +393,9 @@ impl Codegen {
                 let parts: Vec<String> = elements
                     .iter()
                     .map(|el| match el {
-                        Some(DestructElement::Ident(n)) => Ok(Self::escape_ident(n.as_ref())),
+                        Some(DestructElement::Ident(n, _)) => Ok(Self::escape_ident(n.as_ref())),
                         Some(DestructElement::Pattern(p)) => self.emit_destruct_pattern(p),
-                        Some(DestructElement::Rest(n)) => {
+                        Some(DestructElement::Rest(n, _)) => {
                             Ok(format!("...{}", Self::escape_ident(n.as_ref())))
                         }
                         None => Ok("".to_string()),
@@ -363,7 +409,7 @@ impl Codegen {
                     .map(|p| {
                         let k = p.key.as_ref();
                         match &p.value {
-                            DestructElement::Ident(n) => {
+                            DestructElement::Ident(n, _) => {
                                 if k == n.as_ref() {
                                     Ok(k.to_string())
                                 } else {
@@ -373,7 +419,7 @@ impl Codegen {
                             DestructElement::Pattern(pat) => {
                                 Ok(format!("{}: {}", k, self.emit_destruct_pattern(pat)?))
                             }
-                            DestructElement::Rest(n) => {
+                            DestructElement::Rest(n, _) => {
                                 Ok(format!("...{}", Self::escape_ident(n.as_ref())))
                             }
                         }
@@ -460,14 +506,14 @@ impl Codegen {
             } => {
                 let obj = self.emit_expr(object)?;
                 let expr = match prop {
-                    MemberProp::Name(p) => {
-                        if p.parse::<u32>().is_ok()
-                            || !p.chars().all(|c| c.is_alphanumeric() || c == '_')
+                    MemberProp::Name { name, .. } => {
+                        if name.parse::<u32>().is_ok()
+                            || !name.chars().all(|c| c.is_alphanumeric() || c == '_')
                         {
-                            format!("{}[{:?}]", obj, p.as_ref())
+                            format!("{}[{:?}]", obj, name.as_ref())
                         } else {
                             let sep = if *optional { "?." } else { "." };
-                            format!("{}{}{}", obj, sep, p.as_ref())
+                            format!("{}{}{}", obj, sep, name.as_ref())
                         }
                     }
                     MemberProp::Expr(e) => {
@@ -683,30 +729,45 @@ pub fn compile_with_jsx(program: &Program, optimize: bool) -> Result<String, Com
         program.clone()
     };
     let mut g = Codegen::new();
-    g.emit_program(&program)?;
+    g.emit_program(&program, None, None)?;
     Ok(g.output)
 }
 
-/// Compile a project from entry path, resolving and merging modules.
-/// Uses shared resolve from tishlang_compile (same pipeline as native/WASM).
-pub fn compile_project_with_jsx(
-    entry_path: &std::path::Path,
-    project_root: Option<&std::path::Path>,
+/// JavaScript plus optional v3 source map JSON (for publishing Tish libraries consumed from JS/TS).
+#[derive(Debug, Clone)]
+pub struct JsBundle {
+    pub js: String,
+    pub source_map_json: Option<String>,
+}
+
+/// Same as [`compile_project_with_jsx`] plus a v3 source map pointing at merged statements’ original `.tish` files.
+/// **Does not run AST optimization** (required so statement ↔ file alignment stays valid).
+pub fn compile_project_with_jsx_and_source_map(
+    entry_path: &Path,
+    project_root: Option<&Path>,
+    output_js_file_name: &str,
+) -> Result<JsBundle, CompileError> {
+    compile_project_js_inner(entry_path, project_root, false, true, output_js_file_name)
+}
+
+fn compile_project_js_inner(
+    entry_path: &Path,
+    project_root: Option<&Path>,
     optimize: bool,
-) -> Result<String, CompileError> {
+    emit_source_map: bool,
+    output_js_file_name: &str,
+) -> Result<JsBundle, CompileError> {
     use tishlang_ast::Statement;
     let modules = tishlang_compile::resolve_project(entry_path, project_root)
         .map_err(|e| CompileError { message: e })?;
     tishlang_compile::detect_cycles(&modules).map_err(|e| CompileError { message: e })?;
-    let program = {
-        let prog =
-            tishlang_compile::merge_modules(modules).map_err(|e| CompileError { message: e })?;
-        if optimize {
-            tishlang_opt::optimize(&prog)
-        } else {
-            prog
-        }
+    let merged = tishlang_compile::merge_modules(modules).map_err(|e| CompileError { message: e })?;
+    let program = if optimize {
+        tishlang_opt::optimize(&merged.program)
+    } else {
+        merged.program.clone()
     };
+    let stmt_sources = merged.statement_sources;
     let default_export = program.statements.iter().find_map(|s| {
         if let Statement::VarDecl { name, .. } = s {
             let n = name.as_ref();
@@ -719,9 +780,71 @@ pub fn compile_project_with_jsx(
             None
         }
     });
-    let mut js = compile_with_jsx(&program, optimize)?;
+    if emit_source_map && optimize {
+        return Err(CompileError {
+            message: "internal: source map requested with optimize".into(),
+        });
+    }
+    let root = project_root
+        .map(Path::to_path_buf)
+        .or_else(|| entry_path.parent().map(Path::to_path_buf))
+        .unwrap_or_else(|| PathBuf::from("."));
+    let mut gen = Codegen::new();
+    let mut map_builder = if emit_source_map {
+        let mut b = SourceMapBuilder::new(Some(output_js_file_name));
+        b.set_source_root(Some(""));
+        Some(b)
+    } else {
+        None
+    };
+    if let Some(ref mut b) = map_builder {
+        gen.emit_program(
+            &program,
+            Some((stmt_sources.as_slice(), root.as_path())),
+            Some(b),
+        )?;
+    } else {
+        gen.emit_program(&program, None, None)?;
+    }
+    let mut js = gen.output;
     if let Some(name) = default_export {
         js.push_str(&format!("\nexport default {};\n", name));
     }
-    Ok(js)
+    let map_json = if let Some(b) = map_builder {
+        let sm = b.into_sourcemap();
+        let mut v = Vec::new();
+        sm.to_writer(&mut v).map_err(|e| CompileError {
+            message: e.to_string(),
+        })?;
+        Some(String::from_utf8(v).map_err(|e| CompileError {
+            message: e.to_string(),
+        })?)
+    } else {
+        None
+    };
+    Ok(JsBundle {
+        js,
+        source_map_json: map_json,
+    })
+}
+
+/// Compile a project from entry path, resolving and merging modules.
+/// Uses shared resolve from tishlang_compile (same pipeline as native/WASM).
+pub fn compile_project_with_jsx(
+    entry_path: &std::path::Path,
+    project_root: Option<&std::path::Path>,
+    optimize: bool,
+) -> Result<String, CompileError> {
+    let stem = entry_path
+        .file_name()
+        .and_then(|s| s.to_str())
+        .unwrap_or("out.js");
+    let out_name = if stem.ends_with(".tish") {
+        format!("{}.js", stem.trim_end_matches(".tish"))
+    } else {
+        format!("{stem}.js")
+    };
+    Ok(
+        compile_project_js_inner(entry_path, project_root, optimize, false, &out_name)?.js,
+    )
 }

package/crates/tish_compile_js/src/lib.rs

@@ -7,7 +7,9 @@ mod error;
 #[cfg(test)]
 mod tests_jsx;
 
-pub use codegen::{compile_project_with_jsx, compile_with_jsx};
+pub use codegen::{
+    compile_project_with_jsx, compile_project_with_jsx_and_source_map, compile_with_jsx, JsBundle,
+};
 pub use error::CompileError;
 
 /// JSX lowers to `h` / `Fragment`; merge the `lattish` runtime for hooks and DOM.