@tishlang/tish-format 1.0.12 → 1.0.13

package/crates/tish_builtins/src/symbol.rs

@@ -0,0 +1,83 @@
+//! ECMAScript-style `Symbol`, `Symbol.for`, `Symbol.keyFor`.
+
+use std::collections::hash_map::Entry;
+use std::sync::{Arc, Mutex, OnceLock};
+
+use std::collections::HashMap;
+
+use tishlang_core::{alloc_symbol_id, ObjectMap, TishSymbol, Value};
+
+static SYMBOL_FOR_REGISTRY: OnceLock<Mutex<HashMap<Arc<str>, Arc<TishSymbol>>>> = OnceLock::new();
+
+fn symbol_registry() -> &'static Mutex<HashMap<Arc<str>, Arc<TishSymbol>>> {
+    SYMBOL_FOR_REGISTRY.get_or_init(|| Mutex::new(HashMap::new()))
+}
+
+fn symbol_for_impl(key: &str) -> Value {
+    let k: Arc<str> = key.into();
+    let mut reg = symbol_registry().lock().unwrap();
+    let sym = match reg.entry(Arc::clone(&k)) {
+        Entry::Occupied(e) => e.get().clone(),
+        Entry::Vacant(v) => {
+            let id = alloc_symbol_id();
+            let sym = TishSymbol::new_registry(id, Arc::clone(&k), None);
+            v.insert(Arc::clone(&sym));
+            sym
+        }
+    };
+    Value::Symbol(sym)
+}
+
+fn symbol_new(args: &[Value]) -> Value {
+    let desc = args.first().and_then(|v| {
+        if matches!(v, Value::Null) {
+            None
+        } else {
+            Some(v.to_display_string().into())
+        }
+    });
+    Value::Symbol(TishSymbol::new_unique(desc))
+}
+
+fn symbol_key_for_impl(args: &[Value]) -> Value {
+    match args.first() {
+        Some(Value::Symbol(s)) => s
+            .registry_key
+            .as_ref()
+            .map(|k| Value::String(Arc::clone(k)))
+            .unwrap_or(Value::Null),
+        _ => Value::Null,
+    }
+}
+
+/// Global `Symbol`: `Symbol("desc")` via `__call` / `__construct`, `Symbol.for`, `Symbol.keyFor`.
+pub fn symbol_object() -> Value {
+    let call = Value::native(symbol_new);
+    let for_fn = Value::native(|args: &[Value]| {
+        let key = args
+            .first()
+            .map(|v| v.to_display_string())
+            .unwrap_or_default();
+        symbol_for_impl(&key)
+    });
+    let key_for = Value::native(symbol_key_for_impl);
+    let mut m = ObjectMap::default();
+    m.insert(Arc::from("__call"), call.clone());
+    m.insert(Arc::from("__construct"), call);
+    m.insert(Arc::from("for"), for_fn);
+    m.insert(Arc::from("keyFor"), key_for);
+    Value::object(m)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tishlang_core::value_call;
+
+    #[test]
+    fn symbol_global_value_call() {
+        let o = symbol_object();
+        let r = value_call(&o, &[Value::String("hi".into())]);
+        assert!(matches!(r, Value::Symbol(_)));
+    }
+}

package/crates/tish_bytecode/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "tishlang_bytecode"
+version = "0.1.0"
+edition = "2021"
+description = "Bytecode compiler for Tish (AST → bytecode)"
+
+license-file = { workspace = true }
+repository = { workspace = true }
+[dependencies]
+tishlang_ast = { path = "../tish_ast", version = ">=0.1" }
+tishlang_core = { path = "../tish_core", version = ">=0.1" }
+
+[dev-dependencies]
+tishlang_compile = { path = "../tish_compile", version = ">=0.1" }
+tishlang_parser = { path = "../tish_parser", version = ">=0.1" }
+tishlang_opt = { path = "../tish_opt", version = ">=0.1" }
+tishlang_vm = { path = "../tish_vm", version = ">=0.1" }

package/crates/tish_bytecode/src/chunk.rs

@@ -0,0 +1,96 @@
+//! Bytecode chunk: instructions and constants.
+
+use std::sync::Arc;
+use tishlang_core::Value;
+
+/// A constant in the constants table.
+#[derive(Debug, Clone)]
+pub enum Constant {
+    /// Primitive literals
+    Number(f64),
+    String(Arc<str>),
+    Bool(bool),
+    Null,
+    /// Nested function code (index into parent Chunk's nested chunks)
+    Closure(usize),
+}
+
+impl Constant {
+    pub fn to_value(&self) -> Value {
+        match self {
+            Constant::Number(n) => Value::Number(*n),
+            Constant::String(s) => Value::String(Arc::clone(s)),
+            Constant::Bool(b) => Value::Bool(*b),
+            Constant::Null => Value::Null,
+            Constant::Closure(_) => {
+                // Closures are converted to Value at runtime by the VM
+                unreachable!("Closure constant should be handled by VM")
+            }
+        }
+    }
+}
+
+/// A bytecode chunk: instructions and associated data.
+#[derive(Debug, Clone)]
+pub struct Chunk {
+    /// Raw bytecode. Instructions are variable-length.
+    pub code: Vec<u8>,
+    /// Constants (literals, nested function indices)
+    pub constants: Vec<Constant>,
+    /// Variable/property names (strings). First `param_count` are parameter names.
+    pub names: Vec<Arc<str>>,
+    /// Nested chunks (for function bodies)
+    pub nested: Vec<Chunk>,
+    /// Index into names for rest param, or NO_REST_PARAM if none.
+    pub rest_param_index: u16,
+    /// Number of leading names that are parameters (for proper closure arg binding).
+    pub param_count: u16,
+}
+
+impl Chunk {
+    pub fn new() -> Self {
+        Self {
+            code: Vec::new(),
+            constants: Vec::new(),
+            names: Vec::new(),
+            nested: Vec::new(),
+            rest_param_index: super::NO_REST_PARAM,
+            param_count: 0,
+        }
+    }
+
+    pub fn write_u8(&mut self, b: u8) {
+        self.code.push(b);
+    }
+
+    pub fn write_u16(&mut self, n: u16) {
+        self.code.extend_from_slice(&n.to_be_bytes());
+    }
+
+    pub fn add_constant(&mut self, c: Constant) -> u16 {
+        let idx = self.constants.len();
+        self.constants.push(c);
+        idx as u16
+    }
+
+    pub fn add_name(&mut self, name: Arc<str>) -> u16 {
+        if let Some(idx) = self.names.iter().position(|n| n.as_ref() == name.as_ref()) {
+            return idx as u16;
+        }
+        let idx = self.names.len();
+        self.names.push(name);
+        idx as u16
+    }
+
+    pub fn add_nested(&mut self, chunk: Chunk) -> usize {
+        let idx = self.nested.len();
+        self.nested.push(chunk);
+        idx
+    }
+}
+
+impl Default for Chunk {
+    fn default() -> Self {
+        Self::new()
+    }
+}