@tishlang/tish 1.9.1 → 1.10.0

package/crates/tish_compile_js/src/codegen.rs

@@ -34,6 +34,29 @@ impl Codegen {
         }
     }
 
+    /// ECMAScript does not allow `if (c) const x = 1` / `while (c) let y = 2` without a block.
+    fn stmt_needs_braces_in_js_control_head(stmt: &Statement) -> bool {
+        matches!(
+            stmt,
+            Statement::VarDecl { .. } | Statement::VarDeclDestructure { .. }
+        )
+    }
+
+    fn emit_js_control_body(&mut self, body: &Statement) -> Result<(), CompileError> {
+        if Self::stmt_needs_braces_in_js_control_head(body) {
+            self.writeln("{");
+            self.indent += 1;
+            self.emit_statement(body)?;
+            self.indent -= 1;
+            self.writeln("}");
+        } else {
+            self.indent += 1;
+            self.emit_statement(body)?;
+            self.indent -= 1;
+        }
+        Ok(())
+    }
+
     fn indent_str(&self) -> String {
         "  ".repeat(self.indent)
     }
@@ -49,7 +72,11 @@ impl Codegen {
     }
 
     fn output_line(&self) -> u32 {
-        self.output.as_bytes().iter().filter(|&&b| b == b'\n').count() as u32
+        self.output
+            .as_bytes()
+            .iter()
+            .filter(|&&b| b == b'\n')
+            .count() as u32
     }
 
     fn escape_ident(s: &str) -> String {
@@ -155,22 +182,16 @@ impl Codegen {
             } => {
                 let c = self.emit_expr(cond)?;
                 self.writeln(&format!("if ({})", c));
-                self.indent += 1;
-                self.emit_statement(then_branch)?;
-                self.indent -= 1;
+                self.emit_js_control_body(then_branch)?;
                 if let Some(eb) = else_branch {
                     self.writeln("else");
-                    self.indent += 1;
-                    self.emit_statement(eb)?;
-                    self.indent -= 1;
+                    self.emit_js_control_body(eb)?;
                 }
             }
             Statement::While { cond, body, .. } => {
                 let c = self.emit_expr(cond)?;
                 self.writeln(&format!("while ({})", c));
-                self.indent += 1;
-                self.emit_statement(body)?;
-                self.indent -= 1;
+                self.emit_js_control_body(body)?;
             }
             Statement::For {
                 init,
@@ -179,7 +200,10 @@ impl Codegen {
                 body,
                 ..
             } => {
-                self.write("for (");
+                // Keep the whole `for (...)` on one line with normal statement indentation (do not
+                // mix bare `write("for (")` with `writeln(")")`, which indents `)` on a new line).
+                let mut header = self.indent_str();
+                header.push_str("for (");
                 if let Some(i) = init {
                     match i.as_ref() {
                         Statement::VarDecl {
@@ -192,32 +216,32 @@ impl Codegen {
                             let escaped = Self::escape_ident(name.as_ref());
                             if let Some(e) = opt_init {
                                 let ex = self.emit_expr(e)?;
-                                self.write(&format!("{} {} = {}", decl, escaped, ex));
+                                header.push_str(&format!("{} {} = {}", decl, escaped, ex));
                             } else {
-                                self.write(&format!("{} {}", decl, escaped));
+                                header.push_str(&format!("{} {}", decl, escaped));
                             }
                         }
                         Statement::ExprStmt { expr, .. } => {
                             let ex = self.emit_expr(expr)?;
-                            self.write(&ex);
+                            header.push_str(&ex);
                         }
                         _ => return Err(CompileError::new("Unsupported for init")),
                     }
                 }
-                self.write("; ");
+                header.push_str("; ");
                 if let Some(c) = cond {
                     let ce = self.emit_expr(c)?;
-                    self.write(&ce);
+                    header.push_str(&ce);
                 }
-                self.write("; ");
+                header.push_str("; ");
                 if let Some(u) = update {
                     let ue = self.emit_expr(u)?;
-                    self.write(&ue);
+                    header.push_str(&ue);
                 }
-                self.writeln(")");
-                self.indent += 1;
-                self.emit_statement(body)?;
-                self.indent -= 1;
+                header.push(')');
+                header.push('\n');
+                self.output.push_str(&header);
+                self.emit_js_control_body(body)?;
             }
             Statement::ForOf {
                 name,
@@ -228,9 +252,7 @@ impl Codegen {
                 let escaped = Self::escape_ident(name.as_ref());
                 let it = self.emit_expr(iterable)?;
                 self.writeln(&format!("for (const {} of {})", escaped, it));
-                self.indent += 1;
-                self.emit_statement(body)?;
-                self.indent -= 1;
+                self.emit_js_control_body(body)?;
             }
             Statement::Return { value, .. } => {
                 if let Some(v) = value {
@@ -761,7 +783,8 @@ fn compile_project_js_inner(
     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 merged = tishlang_compile::merge_modules(modules).map_err(|e| CompileError { message: e })?;
+    let merged =
+        tishlang_compile::merge_modules(modules).map_err(|e| CompileError { message: e })?;
     let program = if optimize {
         tishlang_opt::optimize(&merged.program)
     } else {
@@ -844,7 +867,5 @@ pub fn compile_project_with_jsx(
     } else {
         format!("{stem}.js")
     };
-    Ok(
-        compile_project_js_inner(entry_path, project_root, optimize, false, &out_name)?.js,
-    )
+    Ok(compile_project_js_inner(entry_path, project_root, optimize, false, &out_name)?.js)
 }

package/crates/tish_compile_js/src/tests_jsx.rs

@@ -303,4 +303,48 @@ fn factory() {
             &js[..800.min(js.len())]
         );
     }
+
+    #[test]
+    fn fn_body_two_lets_not_split_by_closing_brace() {
+        let src = "fn h() {\n  let a = 1\n  let b = 2\n}\n";
+        let program = parse(src).expect("parse");
+        let js = compile_with_jsx(&program, false).expect("compile");
+        let i = js.find("let a = 1").expect("let a");
+        let j = js.find("let b = 2").expect("let b");
+        assert!(
+            !js[i..j].contains('}'),
+            "first let must not end in an inner block before second let (regression #43): {:?}",
+            &js[i..j]
+        );
+    }
+
+    #[test]
+    fn control_flow_wraps_lexical_decl_body_in_block_for_valid_js() {
+        let src = r#"fn f() {
+  if (true)
+    const x = 1
+  while (false)
+    let y = 2
+  for (;;)
+    const z = 3
+  for (const v of [])
+    let w = 4
+}"#;
+        let program = parse(src).expect("parse");
+        let js = compile_with_jsx(&program, false).expect("compile");
+        for (label, key, decl) in [
+            ("if", "if (true)", "const x = 1"),
+            ("while", "while (false)", "let y = 2"),
+            ("for", "for (; ; )", "const z = 3"),
+            ("for-of", "for (const v of [])", "let w = 4"),
+        ] {
+            let i = js.find(key).expect(label);
+            let j = js.find(decl).expect(label);
+            assert!(
+                i < j && js[i..j].contains('{'),
+                "{label}: expected '{{' between {key:?} and {decl:?}, got {:?}",
+                &js[i..j]
+            );
+        }
+    }
 }

package/crates/tish_core/src/console_style.rs

@@ -84,6 +84,7 @@ fn format_value_styled_inner(value: &Value, colors: bool, quote_strings: bool) -
         Value::Object(obj) => {
             let inner: Vec<String> = obj
                 .borrow()
+                .strings
                 .iter()
                 .map(|(k, v)| {
                     format!(
@@ -96,6 +97,14 @@ fn format_value_styled_inner(value: &Value, colors: bool, quote_strings: bool) -
             let sep = format!("{PUNCT}, {RESET}");
             format!("{PUNCT}{{{RESET} {} {PUNCT}}}{RESET}", inner.join(&sep))
         }
+        Value::Symbol(s) => {
+            let body = s
+                .description
+                .as_ref()
+                .map(|d| d.as_ref())
+                .unwrap_or("");
+            format!("{SPECIAL}Symbol({body}){RESET}")
+        }
         Value::Function(_) => format!("{SPECIAL}[Function]{RESET}"),
         Value::Promise(_) => format!("{SPECIAL}[object Promise]{RESET}"),
         Value::Opaque(o) => format!("{SPECIAL}[object {}]{RESET}", o.type_name()),

package/crates/tish_core/src/json.rs

@@ -70,8 +70,8 @@ pub fn json_stringify_into(buf: &mut String, value: &Value) {
             let borrowed = obj.borrow();
             // Sort keys for deterministic output. Pre-allocate to avoid
             // a fresh `Vec` realloc inside `keys().collect()`.
-            let mut keys: Vec<&Arc<str>> = Vec::with_capacity(borrowed.len());
-            keys.extend(borrowed.keys());
+            let mut keys: Vec<&Arc<str>> = Vec::with_capacity(borrowed.strings.len());
+            keys.extend(borrowed.strings.keys());
             keys.sort_unstable_by(|a, b| a.as_ref().cmp(b.as_ref()));
             buf.push('{');
             for (i, key) in keys.into_iter().enumerate() {
@@ -81,11 +81,13 @@ pub fn json_stringify_into(buf: &mut String, value: &Value) {
                 buf.push('"');
                 escape_json_string_into(buf, key);
                 buf.push_str("\":");
-                json_stringify_into(buf, borrowed.get(key).unwrap());
+                json_stringify_into(buf, borrowed.strings.get(key).unwrap());
             }
             buf.push('}');
         }
-        Value::Function(_) | Value::Promise(_) | Value::Opaque(_) => buf.push_str("null"),
+        Value::Function(_) | Value::Promise(_) | Value::Opaque(_) | Value::Symbol(_) => {
+            buf.push_str("null");
+        }
         #[cfg(feature = "regex")]
         Value::RegExp(_) => buf.push_str("null"),
     }
@@ -312,7 +314,10 @@ fn parse_object(input: &str) -> Result<(Value, &str), String> {
 
     input = input.trim_start();
     if let Some(rest) = input.strip_prefix('}') {
-        return Ok((Value::Object(VmRef::new(map)), rest));
+        return Ok((
+            Value::Object(VmRef::new(crate::ObjectData::from_strings(map))),
+            rest,
+        ));
     }
 
     loop {
@@ -339,7 +344,12 @@ fn parse_object(input: &str) -> Result<(Value, &str), String> {
 
         match input.chars().next() {
             Some(',') => input = &input[1..],
-            Some('}') => return Ok((Value::Object(VmRef::new(map)), &input[1..])),
+            Some('}') => {
+                return Ok((
+                    Value::Object(VmRef::new(crate::ObjectData::from_strings(map))),
+                    &input[1..],
+                ));
+            }
             _ => return Err("Expected ',' or '}' in object".to_string()),
         }
     }
@@ -369,7 +379,7 @@ mod tests {
 
         match (&value, &reparsed) {
             (Value::Object(a), Value::Object(b)) => {
-                assert_eq!(a.borrow().len(), b.borrow().len());
+                assert_eq!(a.borrow().len_entries(), b.borrow().len_entries());
             }
             _ => panic!("Expected objects"),
         }

package/crates/tish_core/src/macros.rs

@@ -24,13 +24,13 @@
 macro_rules! tish_module {
     ($($name:expr => $fn:expr),* $(,)?) => {{
         use std::sync::Arc;
-        use $crate::{ObjectMap, Value, VmRef};
+        use $crate::{ObjectMap, Value};
         let mut map = ObjectMap::default();
         $(
             // `Value::native` picks the right Rc / Arc wrapper depending on
             // whether the `send-values` feature is enabled upstream.
             map.insert(Arc::from($name), Value::native($fn));
         )*
-        Value::Object(VmRef::new(map))
+        Value::object(map)
     }};
 }

package/crates/tish_core/src/value.rs

@@ -1,5 +1,6 @@
 //! Unified Value type for Tish runtime values.
 
+use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::Arc;
 
 use ahash::AHashMap;
@@ -10,6 +11,47 @@ use crate::vmref::VmRef;
 /// Uses a faster hasher than `std::collections::HashMap` for string-heavy workloads.
 pub type ObjectMap = AHashMap<Arc<str>, Value>;
 
+static NEXT_SYMBOL_ID: AtomicU64 = AtomicU64::new(1);
+
+fn next_symbol_id() -> u64 {
+    NEXT_SYMBOL_ID.fetch_add(1, Ordering::Relaxed)
+}
+
+/// Allocate a unique symbol id (for `Symbol()` and first-time `Symbol.for` entries).
+#[inline]
+pub fn alloc_symbol_id() -> u64 {
+    next_symbol_id()
+}
+
+/// Primitive Symbol (ECMAScript-style): identity is `Arc` pointer equality.
+#[derive(Debug)]
+pub struct TishSymbol {
+    pub id: u64,
+    pub description: Option<Arc<str>>,
+    /// Set when created via `Symbol.for(key)` (global registry).
+    pub registry_key: Option<Arc<str>>,
+}
+
+impl TishSymbol {
+    /// Unique symbol (`Symbol("desc")`).
+    pub fn new_unique(description: Option<Arc<str>>) -> Arc<Self> {
+        Arc::new(Self {
+            id: next_symbol_id(),
+            description,
+            registry_key: None,
+        })
+    }
+
+    /// Registry symbol (`Symbol.for`): stable `id` for this registry key.
+    pub fn new_registry(id: u64, registry_key: Arc<str>, description: Option<Arc<str>>) -> Arc<Self> {
+        Arc::new(Self {
+            id,
+            description,
+            registry_key: Some(registry_key),
+        })
+    }
+}
+
 #[cfg(feature = "regex")]
 use fancy_regex::Regex;
 
@@ -222,7 +264,9 @@ pub enum Value {
     Bool(bool),
     Null,
     Array(VmRef<Vec<Value>>),
-    Object(VmRef<ObjectMap>),
+    Object(VmRef<ObjectData>),
+    /// ECMAScript-style primitive symbol (identity by `Arc`).
+    Symbol(Arc<TishSymbol>),
     Function(NativeFn),
     #[cfg(feature = "regex")]
     RegExp(VmRef<TishRegExp>),
@@ -232,6 +276,134 @@ pub enum Value {
     Opaque(Arc<dyn TishOpaque>),
 }
 
+/// Ordinary object: string-keyed properties plus optional symbol-keyed side map.
+#[derive(Clone, Debug, Default)]
+pub struct ObjectData {
+    pub strings: ObjectMap,
+    pub symbols: Option<AHashMap<u64, Value>>,
+}
+
+impl ObjectData {
+    #[inline]
+    pub fn from_strings(strings: ObjectMap) -> Self {
+        Self {
+            strings,
+            symbols: None,
+        }
+    }
+
+    #[inline]
+    pub fn len_entries(&self) -> usize {
+        self.strings.len() + self.symbols.as_ref().map(|s| s.len()).unwrap_or(0)
+    }
+}
+
+/// Read a property from an object value.
+pub fn object_get(obj: &Value, key: &Value) -> Option<Value> {
+    let Value::Object(od) = obj else {
+        return None;
+    };
+    let b = od.borrow();
+    match key {
+        Value::Symbol(s) => b.symbols.as_ref()?.get(&s.id).cloned(),
+        Value::Number(n) => {
+            let k: Arc<str> = n.to_string().into();
+            b.strings.get(&k).cloned()
+        }
+        Value::String(k) => b.strings.get(k.as_ref()).cloned(),
+        _ => None,
+    }
+}
+
+/// Set a property on an object.
+pub fn object_set(obj: &Value, key: &Value, val: Value) -> Result<(), String> {
+    let Value::Object(od) = obj else {
+        return Err(format!("Cannot set property on {}", obj.type_name()));
+    };
+    let mut b = od.borrow_mut();
+    match key {
+        Value::Symbol(s) => {
+            if b.symbols.is_none() {
+                b.symbols = Some(AHashMap::default());
+            }
+            b.symbols.as_mut().unwrap().insert(s.id, val);
+            Ok(())
+        }
+        Value::Number(n) => {
+            b.strings.insert(n.to_string().into(), val);
+            Ok(())
+        }
+        Value::String(k) => {
+            b.strings.insert(Arc::clone(k), val);
+            Ok(())
+        }
+        _ => Err(format!(
+            "Object key must be string, number, or symbol, got {}",
+            key.type_name()
+        )),
+    }
+}
+
+/// `key in obj` for objects.
+pub fn object_has(obj: &Value, key: &Value) -> bool {
+    let Value::Object(od) = obj else {
+        return false;
+    };
+    let b = od.borrow();
+    match key {
+        Value::Symbol(s) => b.symbols.as_ref().is_some_and(|m| m.contains_key(&s.id)),
+        Value::Number(n) => {
+            let k: Arc<str> = n.to_string().into();
+            b.strings.contains_key(&k)
+        }
+        Value::String(k) => b.strings.contains_key(k.as_ref()),
+        _ => false,
+    }
+}
+
+/// Invoke a callable [`Value`]: [`Value::Function`], or an object exposing `__call` (e.g. `Symbol`).
+pub fn value_call(callee: &Value, args: &[Value]) -> Value {
+    match callee {
+        Value::Function(f) => f(args),
+        Value::Object(o) => {
+            let inner = o.borrow().strings.get("__call").cloned();
+            if let Some(inner) = inner {
+                return value_call(&inner, args);
+            }
+            panic!(
+                "Not a function: tried to call {:?} as a function (e.g. method on Null when read failed)",
+                callee
+            );
+        }
+        _ => panic!(
+            "Not a function: tried to call {:?} as a function (e.g. method on Null when read failed)",
+            callee
+        ),
+    }
+}
+
+/// Merge two object payloads (spread / VM MergeObject).
+pub fn merge_object_data(left: &VmRef<ObjectData>, right: &VmRef<ObjectData>) -> ObjectData {
+    let l = left.borrow();
+    let r = right.borrow();
+    let mut strings = ObjectMap::with_capacity(l.strings.len() + r.strings.len());
+    strings.extend(l.strings.iter().map(|(k, v)| (Arc::clone(k), v.clone())));
+    strings.extend(r.strings.iter().map(|(k, v)| (Arc::clone(k), v.clone())));
+    let mut symbols: Option<AHashMap<u64, Value>> = None;
+    if let Some(ls) = &l.symbols {
+        symbols = Some(ls.clone());
+    }
+    if let Some(rs) = &r.symbols {
+        match &mut symbols {
+            Some(m) => {
+                m.extend(rs.iter().map(|(k, v)| (*k, v.clone())));
+            }
+            None => symbols = Some(rs.clone()),
+        }
+    }
+    ObjectData { strings, symbols }
+}
+
 impl std::fmt::Debug for Value {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
@@ -241,6 +413,7 @@ impl std::fmt::Debug for Value {
             Value::Null => write!(f, "Null"),
             Value::Array(arr) => write!(f, "Array({:?})", arr.borrow()),
             Value::Object(obj) => write!(f, "Object({:?})", obj.borrow()),
+            Value::Symbol(s) => write!(f, "Symbol({})", s.id),
             Value::Function(_) => write!(f, "Function"),
             #[cfg(feature = "regex")]
             Value::RegExp(re) => write!(
@@ -281,11 +454,19 @@ impl Value {
             Value::Object(obj) => {
                 let inner: Vec<String> = obj
                     .borrow()
+                    .strings
                     .iter()
                     .map(|(k, v)| format!("{}: {}", k.as_ref(), v.to_display_string()))
                     .collect();
                 format!("{{{}}}", inner.join(", "))
             }
+            Value::Symbol(s) => {
+                if let Some(d) = &s.description {
+                    format!("Symbol({})", d)
+                } else {
+                    "Symbol()".to_string()
+                }
+            }
             Value::Function(_) => "[Function]".to_string(),
             Value::Promise(_) => "[object Promise]".to_string(),
             Value::Opaque(o) => format!("[object {}]", o.type_name()),
@@ -331,6 +512,7 @@ impl Value {
             (Value::RegExp(a), Value::RegExp(b)) => VmRef::ptr_eq(a, b),
             (Value::Promise(a), Value::Promise(b)) => Arc::ptr_eq(a, b),
             (Value::Opaque(a), Value::Opaque(b)) => Arc::ptr_eq(a, b),
+            (Value::Symbol(a), Value::Symbol(b)) => Arc::ptr_eq(a, b),
             _ => false,
         }
     }
@@ -364,7 +546,7 @@ impl Value {
 
     /// Create a new object Value from a property map.
     pub fn object(map: ObjectMap) -> Self {
-        Value::Object(VmRef::new(map))
+        Value::Object(VmRef::new(ObjectData::from_strings(map)))
     }
 
     /// Create an empty array Value.
@@ -374,7 +556,7 @@ impl Value {
 
     /// Create an empty object Value.
     pub fn empty_object() -> Self {
-        Value::Object(VmRef::new(ObjectMap::default()))
+        Value::Object(VmRef::new(ObjectData::default()))
     }
 
     /// Extract the number value, if this is a Number.
@@ -399,6 +581,7 @@ impl Value {
             Value::RegExp(_) => "object",
             Value::Promise(_) => "object",
             Value::Opaque(o) => o.type_name(),
+            Value::Symbol(_) => "symbol",
         }
     }
 
@@ -406,7 +589,12 @@ impl Value {
     pub fn completion_keys(&self) -> Vec<String> {
         match self {
             Value::Object(m) => {
-                let mut keys: Vec<String> = m.borrow().keys().map(|k| k.to_string()).collect();
+                let mut keys: Vec<String> = m
+                    .borrow()
+                    .strings
+                    .keys()
+                    .map(|k| k.to_string())
+                    .collect();
                 keys.sort();
                 keys
             }

package/crates/tish_cranelift_runtime/Cargo.toml

@@ -11,6 +11,10 @@ default = []
 fs = ["tishlang_vm/fs"]
 process = ["tishlang_vm/process"]
 http = ["tishlang_vm/http"]
+promise = ["tishlang_vm/promise"]
+timers = ["tishlang_vm/timers"]
+ws = ["tishlang_vm/ws"]
+regex = ["tishlang_vm/regex"]
 
 [lib]
 crate-type = ["staticlib", "rlib"]