@tishlang/tish 1.9.2 → 1.10.0

package/crates/tish_eval/src/value.rs

@@ -12,9 +12,83 @@ use std::sync::Arc;
 use ahash::AHashMap;
 use tishlang_ast::{FunParam, Statement};
 use tishlang_core::NativeFn as CoreNativeFn;
+use tishlang_core::TishSymbol;
 
-/// Property map for interpreter `Value::Object` (uses `eval::Value`, not `tishlang_core::Value`).
+/// Property map for interpreter object string keys (uses `eval::Value`, not `tishlang_core::Value`).
 pub type PropMap = AHashMap<Arc<str>, Value>;
+
+/// Interpreter object: string keys plus optional symbol-keyed properties.
+#[derive(Clone, Debug, Default)]
+pub struct EvalObjectData {
+    pub strings: PropMap,
+    pub symbols: Option<AHashMap<u64, Value>>,
+}
+
+impl EvalObjectData {
+    pub fn from_strings(strings: PropMap) -> Self {
+        Self {
+            strings,
+            symbols: None,
+        }
+    }
+}
+
+pub fn eval_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,
+    }
+}
+
+pub fn eval_object_set(obj: &Value, key: &Value, val: Value) -> Result<(), String> {
+    let Value::Object(od) = obj else {
+        return Err("Cannot set property on non-object".to_string());
+    };
+    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("Object key must be string, number, or symbol".to_string()),
+    }
+}
+
+pub fn eval_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,
+    }
+}
 use tishlang_core::TishOpaque;
 #[cfg(feature = "http")]
 use tishlang_core::TishPromise;
@@ -34,7 +108,8 @@ pub enum Value {
     Bool(bool),
     Null,
     Array(Rc<RefCell<Vec<Value>>>),
-    Object(Rc<RefCell<PropMap>>),
+    Object(Rc<RefCell<EvalObjectData>>),
+    Symbol(Arc<TishSymbol>),
     /// User-defined function with AST body
     Function {
         formals: Arc<[FunParam]>,
@@ -109,6 +184,7 @@ impl std::fmt::Debug for Value {
             Value::CoreFn(_) => write!(f, "CoreFn"),
             Value::Opaque(o) => write!(f, "{}(opaque)", o.type_name()),
             Value::OpaqueMethod(_, _) => write!(f, "[Function]"),
+            Value::Symbol(s) => write!(f, "Symbol({})", s.id),
         }
     }
 }
@@ -137,11 +213,19 @@ impl std::fmt::Display for Value {
             Value::Object(obj) => {
                 let inner: Vec<String> = obj
                     .borrow()
+                    .strings
                     .iter()
                     .map(|(k, v)| format!("{}: {}", k.as_ref(), v))
                     .collect();
                 write!(f, "{{{}}}", inner.join(", "))
             }
+            Value::Symbol(s) => {
+                if let Some(d) = &s.description {
+                    write!(f, "Symbol({})", d)
+                } else {
+                    write!(f, "Symbol()")
+                }
+            }
             Value::Function { .. } => write!(f, "[Function]"),
             Value::Native(_) => write!(f, "[NativeFunction]"),
             #[cfg(feature = "http")]
@@ -195,6 +279,7 @@ impl Value {
             (Value::Null, Value::Null) => true,
             (Value::Array(a), Value::Array(b)) => Rc::ptr_eq(a, b),
             (Value::Object(a), Value::Object(b)) => Rc::ptr_eq(a, b),
+            (Value::Symbol(a), Value::Symbol(b)) => Arc::ptr_eq(a, b),
             (Value::Opaque(a), Value::Opaque(b)) => Arc::ptr_eq(a, b),
             (Value::OpaqueMethod(a, ak), Value::OpaqueMethod(b, bk)) => {
                 Arc::ptr_eq(a, b) && ak == bk
@@ -210,7 +295,7 @@ impl Value {
 
     /// Create a new object Value from a property map.
     pub fn object(map: PropMap) -> Self {
-        Value::Object(Rc::new(RefCell::new(map)))
+        Value::Object(Rc::new(RefCell::new(EvalObjectData::from_strings(map))))
     }
 
     /// Create an empty array Value.
@@ -220,7 +305,7 @@ impl Value {
 
     /// Create an empty object Value.
     pub fn empty_object() -> Self {
-        Value::Object(Rc::new(RefCell::new(PropMap::default())))
+        Value::Object(Rc::new(RefCell::new(EvalObjectData::default())))
     }
 
     /// Extract the number value, if this is a Number.

package/crates/tish_eval/src/value_convert.rs

@@ -4,11 +4,12 @@ use std::cell::RefCell;
 use std::rc::Rc;
 use std::sync::Arc;
 
-use tishlang_core::{ObjectMap, Value as CoreValue, VmRef};
 #[cfg(feature = "regex")]
 use tishlang_core::TishRegExp;
+use ahash::AHashMap;
+use tishlang_core::{ObjectData, ObjectMap, Value as CoreValue, VmRef};
 
-use crate::value::{PropMap, Value};
+use crate::value::{EvalObjectData, PropMap, Value};
 
 /// Convert interpreter Value to core Value. Fails for interpreter-only variants.
 pub fn eval_to_core(v: &Value) -> Result<CoreValue, String> {
@@ -25,12 +26,23 @@ pub fn eval_to_core(v: &Value) -> Result<CoreValue, String> {
             Ok(CoreValue::Array(VmRef::new(out)))
         }
         Value::Object(map) => {
-            let mut out = ObjectMap::default();
-            for (k, v) in map.borrow().iter() {
-                out.insert(Arc::clone(k), eval_to_core(v)?);
+            let b = map.borrow();
+            let mut strings = ObjectMap::default();
+            for (k, v) in b.strings.iter() {
+                strings.insert(Arc::clone(k), eval_to_core(v)?);
             }
-            Ok(CoreValue::Object(VmRef::new(out)))
+            let symbols = if let Some(ss) = &b.symbols {
+                let mut sm = AHashMap::default();
+                for (id, v) in ss.iter() {
+                    sm.insert(*id, eval_to_core(v)?);
+                }
+                Some(sm)
+            } else {
+                None
+            };
+            Ok(CoreValue::Object(VmRef::new(ObjectData { strings, symbols })))
         }
+        Value::Symbol(s) => Ok(CoreValue::Symbol(Arc::clone(s))),
         Value::Opaque(o) => Ok(CoreValue::Opaque(Arc::clone(o))),
         _ => Err(format!(
             "Cannot pass {:?} to native function (unsupported type)",
@@ -54,12 +66,22 @@ pub fn core_to_eval(v: CoreValue) -> Value {
             Value::Array(Rc::new(RefCell::new(out)))
         }
         CoreValue::Object(map) => {
+            let b = map.borrow();
             let mut out = PropMap::default();
-            for (k, v) in map.borrow().iter() {
+            for (k, v) in b.strings.iter() {
                 out.insert(Arc::clone(k), core_to_eval(v.clone()));
             }
-            Value::Object(Rc::new(RefCell::new(out)))
+            let mut eod = EvalObjectData::from_strings(out);
+            if let Some(ss) = &b.symbols {
+                let mut es = AHashMap::default();
+                for (id, v) in ss.iter() {
+                    es.insert(*id, core_to_eval(v.clone()));
+                }
+                eod.symbols = Some(es);
+            }
+            Value::Object(Rc::new(RefCell::new(eod)))
         }
+        CoreValue::Symbol(s) => Value::Symbol(Arc::clone(&s)),
         CoreValue::Opaque(o) => Value::Opaque(o),
         #[cfg(feature = "http")]
         CoreValue::Promise(p) => Value::CorePromise(Arc::clone(&p)),

package/crates/tish_fmt/src/lib.rs

@@ -1023,7 +1023,10 @@ mod tests {
     fn jsx_multiline_when_mixed_children() {
         let src = "let x = <div>a{b}</div>\n";
         let out = format_source(src).unwrap();
-        assert!(out.contains('\n'), "expected line breaks in formatted JSX: {out:?}");
+        assert!(
+            out.contains('\n'),
+            "expected line breaks in formatted JSX: {out:?}"
+        );
         let _ = tishlang_parser::parse(&out).unwrap();
     }
 }

package/crates/tish_lexer/src/lib.rs

@@ -701,11 +701,16 @@ mod tests {
     #[test]
     fn line_comment_does_not_emit_spurious_indent_before_next_line() {
         let with_comment = "fn f() {\n  return {\n    a: 1, // c\n    b: 2\n  }\n}\n";
-        let tokens: Vec<_> = Lexer::new(with_comment).collect::<Result<Vec<_>, _>>().unwrap();
+        let tokens: Vec<_> = Lexer::new(with_comment)
+            .collect::<Result<Vec<_>, _>>()
+            .unwrap();
         assert!(
             !tokens.iter().any(|t| t.kind == TokenKind::Indent),
             "unexpected Indent after line comment: {:?}",
-            tokens.iter().map(|t| format!("{:?}", t.kind)).collect::<Vec<_>>()
+            tokens
+                .iter()
+                .map(|t| format!("{:?}", t.kind))
+                .collect::<Vec<_>>()
         );
     }
 }

package/crates/tish_llvm/src/lib.rs

@@ -26,8 +26,8 @@ pub fn compile_to_native(
     let program = merge_modules(modules)
         .map(|m| m.program)
         .map_err(|e| LlvmError {
-        message: e.to_string(),
-    })?;
+            message: e.to_string(),
+        })?;
     let chunk = tishlang_bytecode::compile(&program).map_err(|e| LlvmError {
         message: e.to_string(),
     })?;

package/crates/tish_lsp/src/builtin_goto.rs

@@ -33,16 +33,117 @@ fn is_ident_char(c: char) -> bool {
 
 /// HTML / SVG intrinsic tag names (lowercase) that JSX lowers to `h("tag", …)`; must stay sorted for `binary_search`.
 const HTML_INTRINSIC_TAGS: &[&str] = &[
-    "a", "abbr", "address", "area", "article", "aside", "audio", "b", "base", "bdi", "bdo",
-    "blockquote", "body", "br", "button", "canvas", "caption", "cite", "code", "col", "colgroup",
-    "data", "datalist", "dd", "del", "details", "dfn", "dialog", "div", "dl", "dt", "em", "embed",
-    "fieldset", "figcaption", "figure", "footer", "form", "h1", "h2", "h3", "h4", "h5", "h6",
-    "head", "header", "hr", "html", "i", "iframe", "img", "input", "ins", "kbd", "label", "legend",
-    "li", "link", "main", "map", "mark", "meta", "meter", "nav", "noscript", "object", "ol",
-    "optgroup", "option", "output", "p", "param", "picture", "pre", "progress", "q", "rp", "rt",
-    "ruby", "s", "samp", "script", "section", "select", "slot", "small", "source", "span", "strong",
-    "style", "sub", "summary", "sup", "svg", "table", "tbody", "td", "template", "textarea",
-    "tfoot", "th", "thead", "time", "title", "tr", "track", "u", "ul", "var", "video", "wbr",
+    "a",
+    "abbr",
+    "address",
+    "area",
+    "article",
+    "aside",
+    "audio",
+    "b",
+    "base",
+    "bdi",
+    "bdo",
+    "blockquote",
+    "body",
+    "br",
+    "button",
+    "canvas",
+    "caption",
+    "cite",
+    "code",
+    "col",
+    "colgroup",
+    "data",
+    "datalist",
+    "dd",
+    "del",
+    "details",
+    "dfn",
+    "dialog",
+    "div",
+    "dl",
+    "dt",
+    "em",
+    "embed",
+    "fieldset",
+    "figcaption",
+    "figure",
+    "footer",
+    "form",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "head",
+    "header",
+    "hr",
+    "html",
+    "i",
+    "iframe",
+    "img",
+    "input",
+    "ins",
+    "kbd",
+    "label",
+    "legend",
+    "li",
+    "link",
+    "main",
+    "map",
+    "mark",
+    "meta",
+    "meter",
+    "nav",
+    "noscript",
+    "object",
+    "ol",
+    "optgroup",
+    "option",
+    "output",
+    "p",
+    "param",
+    "picture",
+    "pre",
+    "progress",
+    "q",
+    "rp",
+    "rt",
+    "ruby",
+    "s",
+    "samp",
+    "script",
+    "section",
+    "select",
+    "slot",
+    "small",
+    "source",
+    "span",
+    "strong",
+    "style",
+    "sub",
+    "summary",
+    "sup",
+    "svg",
+    "table",
+    "tbody",
+    "td",
+    "template",
+    "textarea",
+    "tfoot",
+    "th",
+    "thead",
+    "time",
+    "title",
+    "tr",
+    "track",
+    "u",
+    "ul",
+    "var",
+    "video",
+    "wbr",
 ];
 
 static SOURCE_MAP: OnceLock<HashMap<String, BuiltinDef>> = OnceLock::new();

package/crates/tish_lsp/src/import_goto.rs

@@ -9,11 +9,11 @@ use regex::Regex;
 use tower_lsp::lsp_types::{Location, Position, Range, Url};
 
 use tishlang_ast::{ImportSpecifier, Program, Statement};
-use tishlang_resolve::member_access_chain_at_cursor;
 use tishlang_compile::{
     export_name_to_rust_ident, is_builtin_native_spec, is_cargo_native_spec, is_native_import,
     normalize_builtin_spec, read_project_tish_config, resolve_bare_spec, resolve_native_modules,
 };
+use tishlang_resolve::member_access_chain_at_cursor;
 
 /// Pick a workspace / project root for resolving `package.json` and `node_modules`.
 fn infer_project_root(file_path: &Path, roots: &[PathBuf]) -> Option<PathBuf> {
@@ -43,7 +43,10 @@ fn location_from_rust_path(path: &Path, line: u32, col: u32) -> Option<Location>
     Some(Location {
         uri,
         range: Range {
-            start: Position { line, character: col },
+            start: Position {
+                line,
+                character: col,
+            },
             end: Position {
                 line,
                 character: end_char.max(col.saturating_add(1)),
@@ -63,13 +66,10 @@ fn resolve_cargo_dep_crate_root(
             Ok(r.source_root())
         }
         serde_json::Value::Object(map) => {
-            let path_str = map
-                .get("path")
-                .and_then(|v| v.as_str())
-                .ok_or_else(|| {
-                    "cargo:… rustDependencies entry must be a version string or an object with \"path\""
-                        .to_string()
-                })?;
+            let path_str = map.get("path").and_then(|v| v.as_str()).ok_or_else(|| {
+                "cargo:… rustDependencies entry must be a version string or an object with \"path\""
+                    .to_string()
+            })?;
             let glue = Path::new(path_str);
             let glue = if glue.is_absolute() {
                 glue.to_path_buf()
@@ -79,7 +79,8 @@ fn resolve_cargo_dep_crate_root(
             let glue = glue.canonicalize().unwrap_or(glue);
             let glue_cargo = glue.join("Cargo.toml");
             if glue_cargo.is_file() {
-                match tishlang_cargo_bindgen::resolve_dependency_from_manifest(&glue_cargo, dep_key) {
+                match tishlang_cargo_bindgen::resolve_dependency_from_manifest(&glue_cargo, dep_key)
+                {
                     Ok(r) => Ok(r.source_root()),
                     Err(_) if glue.join("src").is_dir() => Ok(glue),
                     Err(e) => Err(e),
@@ -128,7 +129,8 @@ fn rust_def_for_crate_root(crate_root: &Path, tish_export: &str) -> Option<Locat
         if name.is_empty() {
             continue;
         }
-        if let Ok((path, line, col)) = tishlang_cargo_bindgen::rust_public_fn_location(crate_root, name)
+        if let Ok((path, line, col)) =
+            tishlang_cargo_bindgen::rust_public_fn_location(crate_root, name)
         {
             return location_from_rust_path(&path, line, col);
         }
@@ -218,11 +220,11 @@ fn try_rust_member_on_crate(
 }
 
 /// Optional `| …` hover line after the 1-based line in a native package’s `lsp-pragmas.d.tish`.
-fn parse_lsp_pragmas_native(src: &str) -> HashMap<String, (crate::builtin_goto::BuiltinDef, Option<String>)> {
-    let re = Regex::new(
-        r"(?m)^\s*//\s*@tish-source\s+(\S+)\s+(\S+)\s+(\d+)(?:\s*\|\s*(.*?))?\s*$",
-    )
-    .expect("native lsp pragma regex");
+fn parse_lsp_pragmas_native(
+    src: &str,
+) -> HashMap<String, (crate::builtin_goto::BuiltinDef, Option<String>)> {
+    let re = Regex::new(r"(?m)^\s*//\s*@tish-source\s+(\S+)\s+(\S+)\s+(\d+)(?:\s*\|\s*(.*?))?\s*$")
+        .expect("native lsp pragma regex");
     let mut m = HashMap::new();
     for cap in re.captures_iter(src) {
         let sym = cap[1].to_string();
@@ -256,7 +258,11 @@ fn pragma_key_for_native_member(
     }
     match imported_for_prefix {
         Some(prefix) => {
-            let tail: String = members.iter().map(|m| m.as_ref()).collect::<Vec<_>>().join(".");
+            let tail: String = members
+                .iter()
+                .map(|m| m.as_ref())
+                .collect::<Vec<_>>()
+                .join(".");
             if tail.is_empty() {
                 None
             } else {
@@ -375,14 +381,16 @@ pub fn native_member_definition(
                     .get("rustDependencies")
                     .and_then(|v| v.get(dep_key))
                     .cloned()?;
-                cargo_crate_root_cached(&project_root, &spec, dep_key, &raw, cargo_src_cache).ok()?
+                cargo_crate_root_cached(&project_root, &spec, dep_key, &raw, cargo_src_cache)
+                    .ok()?
             } else {
                 let mods = resolve_native_modules(program, &project_root).ok()?;
                 let m = mods.iter().find(|mm| mm.spec == spec)?;
                 m.crate_path.clone()
             };
 
-            if let Some(loc) = try_rust_member_on_crate(&crate_root, &members, imported_for_prefix) {
+            if let Some(loc) = try_rust_member_on_crate(&crate_root, &members, imported_for_prefix)
+            {
                 return Some(NativeMemberDefinition {
                     location: loc,
                     doc: None,
@@ -492,9 +500,14 @@ pub fn definition_for_import(
                         .get("rustDependencies")
                         .and_then(|v| v.get(dep_key))
                         .cloned()?;
-                    let crate_root =
-                        cargo_crate_root_cached(&project_root, &spec, dep_key, &raw, cargo_src_cache)
-                            .ok()?;
+                    let crate_root = cargo_crate_root_cached(
+                        &project_root,
+                        &spec,
+                        dep_key,
+                        &raw,
+                        cargo_src_cache,
+                    )
+                    .ok()?;
                     return rust_def_for_crate_root(&crate_root, imported);
                 }