@tishlang/tish 1.7.0 → 1.8.0

package/crates/tish_eval/src/value_convert.rs

@@ -4,7 +4,9 @@ use std::cell::RefCell;
 use std::rc::Rc;
 use std::sync::Arc;
 
-use tishlang_core::{ObjectMap, Value as CoreValue};
+use tishlang_core::{ObjectMap, Value as CoreValue, VmRef};
+#[cfg(feature = "regex")]
+use tishlang_core::TishRegExp;
 
 use crate::value::{PropMap, Value};
 
@@ -20,14 +22,14 @@ pub fn eval_to_core(v: &Value) -> Result<CoreValue, String> {
             for item in arr.borrow().iter() {
                 out.push(eval_to_core(item)?);
             }
-            Ok(CoreValue::Array(Rc::new(RefCell::new(out))))
+            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)?);
             }
-            Ok(CoreValue::Object(Rc::new(RefCell::new(out))))
+            Ok(CoreValue::Object(VmRef::new(out)))
         }
         Value::Opaque(o) => Ok(CoreValue::Opaque(Arc::clone(o))),
         _ => Err(format!(
@@ -63,13 +65,19 @@ pub fn core_to_eval(v: CoreValue) -> Value {
         CoreValue::Promise(p) => Value::CorePromise(Arc::clone(&p)),
         #[cfg(not(feature = "http"))]
         CoreValue::Promise(_) => Value::Null,
-        CoreValue::Function(f) => Value::CoreFn(Rc::clone(&f)),
+        // `CoreNativeFn` is feature-gated (Rc vs Arc), so use Clone::clone
+        // which works for either.
+        CoreValue::Function(f) => Value::CoreFn(f.clone()),
         // tishlang_core gets regex from http or regex features; handle RegExp when it exists
         #[cfg(any(feature = "http", feature = "regex"))]
         CoreValue::RegExp(re) => {
             #[cfg(feature = "regex")]
             {
-                Value::RegExp(re)
+                // Core uses `VmRef<TishRegExp>` (potentially `Arc<Mutex>`),
+                // interpreter uses `Rc<RefCell<TishRegExp>>`. Clone the
+                // inner state across so the two storage shapes can coexist.
+                let inner: TishRegExp = re.borrow().clone();
+                Value::RegExp(Rc::new(RefCell::new(inner)))
             }
             #[cfg(not(feature = "regex"))]
             {

package/crates/tish_fmt/src/lib.rs

@@ -279,6 +279,51 @@ impl Printer {
                 self.buf.push_str(" from ");
                 self.string_lit(from.as_ref());
             }
+            Statement::TypeAlias { name, ty, .. } => {
+                self.indent(level);
+                self.buf.push_str("type ");
+                self.buf.push_str(name);
+                self.buf.push_str(" = ");
+                self.type_ann(ty);
+            }
+            Statement::DeclareVar {
+                name,
+                type_ann,
+                const_,
+                ..
+            } => {
+                self.indent(level);
+                self.buf.push_str("declare ");
+                self.buf.push_str(if *const_ { "const " } else { "let " });
+                self.buf.push_str(name);
+                if let Some(t) = type_ann {
+                    self.buf.push_str(": ");
+                    self.type_ann(t);
+                }
+            }
+            Statement::DeclareFun {
+                async_,
+                name,
+                params,
+                rest_param,
+                return_type,
+                ..
+            } => {
+                self.indent(level);
+                self.buf.push_str("declare ");
+                if *async_ {
+                    self.buf.push_str("async ");
+                }
+                self.buf.push_str("fn ");
+                self.buf.push_str(name);
+                self.buf.push('(');
+                self.param_list(params, rest_param);
+                self.buf.push(')');
+                if let Some(rt) = return_type {
+                    self.buf.push_str(": ");
+                    self.type_ann(rt);
+                }
+            }
             Statement::Export { declaration, .. } => {
                 self.indent(level);
                 self.buf.push_str("export ");
@@ -361,12 +406,12 @@ impl Printer {
     fn import_specs(&mut self, specs: &[ImportSpecifier]) {
         if specs.len() == 1 {
             match &specs[0] {
-                ImportSpecifier::Default(n) => self.buf.push_str(n.as_ref()),
-                ImportSpecifier::Namespace(n) => {
+                ImportSpecifier::Default { name, .. } => self.buf.push_str(name.as_ref()),
+                ImportSpecifier::Namespace { name, .. } => {
                     self.buf.push_str("* as ");
-                    self.buf.push_str(n.as_ref());
+                    self.buf.push_str(name.as_ref());
                 }
-                ImportSpecifier::Named { name, alias } => {
+                ImportSpecifier::Named { name, alias, .. } => {
                     self.buf.push_str("{ ");
                     self.buf.push_str(name.as_ref());
                     if let Some(a) = alias {
@@ -384,7 +429,7 @@ impl Printer {
                 self.buf.push_str(", ");
             }
             match sp {
-                ImportSpecifier::Named { name, alias } => {
+                ImportSpecifier::Named { name, alias, .. } => {
                     self.buf.push_str(name.as_ref());
                     if let Some(a) = alias {
                         self.buf.push_str(" as ");
@@ -453,9 +498,9 @@ impl Printer {
                         self.buf.push_str(", ");
                     }
                     match e {
-                        Some(DestructElement::Ident(n)) => self.buf.push_str(n.as_ref()),
+                        Some(DestructElement::Ident(n, _)) => self.buf.push_str(n.as_ref()),
                         Some(DestructElement::Pattern(inner)) => self.destruct_pat(inner),
-                        Some(DestructElement::Rest(n)) => {
+                        Some(DestructElement::Rest(n, _)) => {
                             self.buf.push_str("...");
                             self.buf.push_str(n.as_ref());
                         }
@@ -472,16 +517,16 @@ impl Printer {
                     }
                     self.buf.push_str(pr.key.as_ref());
                     match &pr.value {
-                        DestructElement::Ident(n) if n.as_ref() != pr.key.as_ref() => {
+                        DestructElement::Ident(n, _) if n.as_ref() != pr.key.as_ref() => {
                             self.buf.push_str(": ");
                             self.buf.push_str(n.as_ref());
                         }
-                        DestructElement::Ident(_) => {}
+                        DestructElement::Ident(_, _) => {}
                         DestructElement::Pattern(inner) => {
                             self.buf.push_str(": ");
                             self.destruct_pat(inner);
                         }
-                        DestructElement::Rest(n) => {
+                        DestructElement::Rest(n, _) => {
                             self.buf.push_str(": ...");
                             self.buf.push_str(n.as_ref());
                         }
@@ -617,7 +662,7 @@ impl Printer {
                     self.buf.push('.');
                 }
                 match prop {
-                    MemberProp::Name(n) => self.buf.push_str(n.as_ref()),
+                    MemberProp::Name { name, .. } => self.buf.push_str(name.as_ref()),
                     MemberProp::Expr(ex) => {
                         self.buf.push('[');
                         self.expr(ex);
@@ -817,35 +862,72 @@ impl Printer {
                 if children.is_empty() {
                     self.buf.push_str(" />");
                 } else {
-                    self.buf.push('>');
-                    for ch in children {
-                        match ch {
-                            JsxChild::Text(t) => self.buf.push_str(t.as_ref()),
-                            JsxChild::Expr(e) => {
-                                self.buf.push('{');
-                                self.expr(e);
-                                self.buf.push('}');
+                    let compact = children.len() == 1
+                        && matches!(
+                            &children[0],
+                            JsxChild::Text(t) if !t.as_ref().contains('\n')
+                        );
+                    if compact {
+                        self.buf.push('>');
+                        if let JsxChild::Text(t) = &children[0] {
+                            self.buf.push_str(t.as_ref());
+                        }
+                        self.buf.push_str("</");
+                        self.buf.push_str(tag.as_ref());
+                        self.buf.push('>');
+                    } else {
+                        self.buf.push('>');
+                        self.buf.push('\n');
+                        for ch in children {
+                            self.buf.push_str("  ");
+                            match ch {
+                                JsxChild::Text(t) => self.buf.push_str(t.as_ref()),
+                                JsxChild::Expr(e) => {
+                                    self.buf.push('{');
+                                    self.expr(e);
+                                    self.buf.push('}');
+                                }
                             }
+                            self.buf.push('\n');
                         }
+                        self.buf.push_str("  </");
+                        self.buf.push_str(tag.as_ref());
+                        self.buf.push('>');
                     }
-                    self.buf.push_str("</");
-                    self.buf.push_str(tag.as_ref());
-                    self.buf.push('>');
                 }
             }
             Expr::JsxFragment { children, .. } => {
                 self.buf.push_str("<>");
-                for ch in children {
-                    match ch {
-                        JsxChild::Text(t) => self.buf.push_str(t.as_ref()),
-                        JsxChild::Expr(e) => {
-                            self.buf.push('{');
-                            self.expr(e);
-                            self.buf.push('}');
+                if children.is_empty() {
+                    self.buf.push_str("</>");
+                } else {
+                    let compact = children.len() == 1
+                        && matches!(
+                            &children[0],
+                            JsxChild::Text(t) if !t.as_ref().contains('\n')
+                        );
+                    if compact {
+                        if let JsxChild::Text(t) = &children[0] {
+                            self.buf.push_str(t.as_ref());
+                        }
+                        self.buf.push_str("</>");
+                    } else {
+                        self.buf.push('\n');
+                        for ch in children {
+                            self.buf.push_str("  ");
+                            match ch {
+                                JsxChild::Text(t) => self.buf.push_str(t.as_ref()),
+                                JsxChild::Expr(e) => {
+                                    self.buf.push('{');
+                                    self.expr(e);
+                                    self.buf.push('}');
+                                }
+                            }
+                            self.buf.push('\n');
                         }
+                        self.buf.push_str("</>");
                     }
                 }
-                self.buf.push_str("</>");
             }
             Expr::NativeModuleLoad {
                 spec, export_name, ..
@@ -936,4 +1018,12 @@ mod tests {
         let out = format_source(src).unwrap();
         let _ = tishlang_parser::parse(&out).unwrap();
     }
+
+    #[test]
+    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:?}");
+        let _ = tishlang_parser::parse(&out).unwrap();
+    }
 }

package/crates/tish_lexer/src/lib.rs

@@ -544,6 +544,13 @@ impl<'a> Lexer<'a> {
                 if self.peek() == Some('/') {
                     self.advance();
                     self.skip_line_comment();
+                    // `skip_line_comment` consumes the newline via `advance()`, which sets
+                    // `at_line_start` before we would normally run `skip_whitespace()`. Without
+                    // stripping the next line's leading spaces here, `read_indent_level` would see
+                    // physical indentation and emit a spurious `Indent` (breaks e.g. object
+                    // literals with trailing `//` comments). Newlines handled in `skip_whitespace`
+                    // eat those spaces before the indent pass; match that behavior.
+                    self.skip_whitespace();
                     return self.next_token();
                 } else if self.peek() == Some('*') {
                     self.advance();
@@ -636,11 +643,8 @@ impl<'a> Lexer<'a> {
                 return Ok(Some(Token {
                     kind,
                     span: Span { start, end },
-                    literal: if matches!(kind, TokenKind::Ident) {
-                        Some(ident.into())
-                    } else {
-                        None
-                    },
+                    // Spelling is useful for keywords too (e.g. object keys, type names like `type`).
+                    literal: Some(ident.into()),
                 }));
             }
             '\n' => {
@@ -693,4 +697,15 @@ mod tests {
         let string_tok = tokens.iter().find(|t| t.kind == TokenKind::String).unwrap();
         assert_eq!(string_tok.literal.as_deref(), Some("H"));
     }
+
+    #[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();
+        assert!(
+            !tokens.iter().any(|t| t.kind == TokenKind::Indent),
+            "unexpected Indent after line comment: {:?}",
+            tokens.iter().map(|t| format!("{:?}", t.kind)).collect::<Vec<_>>()
+        );
+    }
 }

package/crates/tish_lexer/src/token.rs

@@ -57,6 +57,8 @@ pub enum TokenKind {
     New,
     Import,
     Export,
+    Type,
+    Declare,
 
     // Punctuation
     LParen,
@@ -153,6 +155,8 @@ impl TokenKind {
             "new" => TokenKind::New,
             "import" => TokenKind::Import,
             "export" => TokenKind::Export,
+            "type" => TokenKind::Type,
+            "declare" => TokenKind::Declare,
             _ => TokenKind::Ident,
         }
     }

package/crates/tish_llvm/src/lib.rs

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

package/crates/tish_lsp/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tishlang_lsp"
-version = "0.1.0"
+version = "0.1.1"
 edition = "2021"
 description = "Language Server Protocol implementation for Tish"
 license-file = { workspace = true }
@@ -12,9 +12,12 @@ path = "src/main.rs"
 
 [dependencies]
 tishlang_ast = { path = "../tish_ast", version = ">=0.1" }
+tishlang_cargo_bindgen = { path = "../tishlang_cargo_bindgen", version = ">=0.1" }
+tishlang_compile = { path = "../tish_compile", version = ">=0.1" }
 tishlang_parser = { path = "../tish_parser", version = ">=0.1" }
 tishlang_fmt = { path = "../tish_fmt", version = ">=0.1" }
 tishlang_lint = { path = "../tish_lint", version = ">=0.1" }
+tishlang_resolve = { path = "../tish_resolve", version = ">=0.1" }
 tower-lsp = "0.20"
 tokio = { version = "1", features = ["rt-multi-thread", "macros", "io-std"] }
 serde_json = "1"

package/crates/tish_lsp/README.md

@@ -14,7 +14,7 @@ Binary: `target/release/tish-lsp` (stdio LSP).
 
 - Parse diagnostics + lint warnings (via `tish_lint` **library** — use **`tish-lint`** CLI separately in CI)
 - Document symbols, completion, formatting (via `tish_fmt` **library** — use **`tish-fmt`** CLI separately in CI)
-- Go to definition (same file + relative imports)
+- Go to definition (same file, relative `./` / `../`, bare `node_modules` packages like Node, and native `tish:` / `@scope/pkg` / `cargo:` → Rust `pub fn` via `syn` + `cargo metadata` where configured)
 - Workspace symbol search (`**/*.tish`)
 
 ## Client configuration

package/crates/tish_lsp/src/builtin_goto.rs

@@ -0,0 +1,261 @@
+//! Built-in and JSX-intrinsic "go to definition" for the Tish LSP.
+//!
+//! Global / namespace member anchors are loaded from `stdlib/builtins.d.tish` in the `tish`
+//! repository via `// @tish-source <symbol> <rel-path> <1-based-line>` pragmas. The type
+//! surface in that file is the canonical declaration for ambient builtins.
+//!
+//! HTML / SVG intrinsic tag names are still listed here (sorted) for fast lookup; each maps
+//! to the same vnode factory as in the pragma table for `div`.
+//!
+//! Definitions resolve to `file://` URIs only when `TISHLANG_SOURCE_ROOT` is set or the client
+//! passes `tishlangSourceRoot` in LSP `initializationOptions` (VS Code: `tish.tishlangSourceRoot`).
+
+use std::collections::HashMap;
+use std::path::Path;
+use std::sync::OnceLock;
+
+use regex::Regex;
+use tower_lsp::lsp_types::{Location, Position, Range, Url};
+
+/// Stable path relative to the `tish` repository root (where the workspace `Cargo.toml` lives).
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct BuiltinDef {
+    pub rel_path: String,
+    /// 0-based LSP line in the target file.
+    pub line: u32,
+    /// 0-based UTF-16 code unit offset on that line (ASCII-only targets use byte column).
+    pub character: u32,
+}
+
+fn is_ident_char(c: char) -> bool {
+    c.is_alphanumeric() || c == '_'
+}
+
+/// 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",
+];
+
+static SOURCE_MAP: OnceLock<HashMap<String, BuiltinDef>> = OnceLock::new();
+
+/// Parse `// @tish-source <symbol> <rel-path> <1-based-line>` lines (same format as `stdlib/builtins.d.tish`).
+pub fn parse_tish_source_pragmas(src: &str) -> HashMap<String, BuiltinDef> {
+    let re = Regex::new(r"(?m)^\s*//\s*@tish-source\s+(\S+)\s+(\S+)\s+(\d+)\s*$")
+        .expect("builtin pragma regex");
+    let mut m = HashMap::new();
+    for cap in re.captures_iter(src) {
+        let sym = cap[1].to_string();
+        let rel = cap[2].to_string();
+        let line_1: u32 = cap[3].parse().unwrap_or(1);
+        m.insert(
+            sym,
+            BuiltinDef {
+                rel_path: rel,
+                line: line_1.saturating_sub(1),
+                character: 0,
+            },
+        );
+    }
+    m
+}
+
+fn source_map() -> &'static HashMap<String, BuiltinDef> {
+    SOURCE_MAP.get_or_init(|| {
+        let src = include_str!(concat!(
+            env!("CARGO_MANIFEST_DIR"),
+            "/../../stdlib/builtins.d.tish"
+        ));
+        parse_tish_source_pragmas(src)
+    })
+}
+
+/// If `col` lies on the name of a JSX opening (or closing) tag on this line, returns the span of that name in **character indices** (same convention as [`tower_lsp::lsp_types::Position::character`] for ASCII lines).
+fn jsx_tag_name_char_span(line: &str, col: usize) -> Option<(usize, usize)> {
+    let chars: Vec<char> = line.chars().collect();
+    if chars.is_empty() {
+        return None;
+    }
+    let col = col.min(chars.len().saturating_sub(1));
+    let mut j = col;
+    while j > 0 {
+        j -= 1;
+        if chars[j] == '>' {
+            return None;
+        }
+        if chars[j] == '<' {
+            let mut k = j + 1;
+            while k < chars.len() && chars[k].is_whitespace() {
+                k += 1;
+            }
+            if k < chars.len() && chars[k] == '/' {
+                k += 1;
+                while k < chars.len() && chars[k].is_whitespace() {
+                    k += 1;
+                }
+            }
+            let name_start = k;
+            while k < chars.len() {
+                let c = chars[k];
+                if c.is_whitespace() || c == '>' || c == '/' || c == '{' {
+                    break;
+                }
+                if !(c.is_alphanumeric() || c == '_' || c == '-') {
+                    break;
+                }
+                k += 1;
+            }
+            let name_end = k;
+            if name_start < name_end && col >= name_start && col < name_end {
+                return Some((name_start, name_end));
+            }
+            return None;
+        }
+    }
+    None
+}
+
+fn tag_name_at_span(line: &str, start: usize, end: usize) -> String {
+    line.chars()
+        .enumerate()
+        .filter(|(i, _)| *i >= start && *i < end)
+        .map(|(_, c)| c)
+        .collect()
+}
+
+/// `base.member` when the cursor is on `member` (same line, character-index column as `word_at_position`).
+fn split_property_access(line: &str, col: usize) -> Option<(String, String)> {
+    let chars: Vec<char> = line.chars().collect();
+    if chars.is_empty() {
+        return None;
+    }
+    let col = col.min(chars.len().saturating_sub(1));
+    if !is_ident_char(chars[col]) {
+        return None;
+    }
+    let mut end = col;
+    while end + 1 < chars.len() && is_ident_char(chars[end + 1]) {
+        end += 1;
+    }
+    let mut start = col;
+    while start > 0 && is_ident_char(chars[start - 1]) {
+        start -= 1;
+    }
+    if start == 0 {
+        return None;
+    }
+    if chars[start - 1] != '.' {
+        return None;
+    }
+    let member: String = chars[start..=end].iter().collect();
+    let mut k = start - 2;
+    while k > 0 && is_ident_char(chars[k - 1]) {
+        k -= 1;
+    }
+    let base: String = chars[k..start - 1].iter().collect();
+    if base.is_empty() {
+        return None;
+    }
+    Some((base, member))
+}
+
+fn lookup_dotted(base: &str, member: &str) -> Option<BuiltinDef> {
+    let key = format!("{base}.{member}");
+    source_map().get(&key).cloned()
+}
+
+fn lookup_global(word: &str) -> Option<BuiltinDef> {
+    source_map().get(word).cloned()
+}
+
+/// Built-in or JSX-intrinsic definition for the identifier at `position`, if any.
+pub fn definition_for_builtin(
+    text: &str,
+    line: u32,
+    character: u32,
+    word: &str,
+) -> Option<BuiltinDef> {
+    let line_str = text.lines().nth(line as usize)?;
+    let col = character as usize;
+
+    if let Some((ns, ne)) = jsx_tag_name_char_span(line_str, col) {
+        let tag = tag_name_at_span(line_str, ns, ne);
+        if tag == word {
+            if word == "Fragment" {
+                return lookup_global("Fragment");
+            }
+            if HTML_INTRINSIC_TAGS.binary_search(&word).is_ok() {
+                // Intrinsic tags share the same `ui_h` entry point as `div`.
+                return lookup_global("div");
+            }
+        }
+    }
+
+    if let Some((base, member)) = split_property_access(line_str, col) {
+        if let Some(d) = lookup_dotted(base.as_str(), member.as_str()) {
+            return Some(d);
+        }
+    }
+
+    lookup_global(word)
+}
+
+pub fn to_file_location(root: &Path, def: &BuiltinDef) -> Option<Location> {
+    let path = root.join(&def.rel_path);
+    if !path.is_file() {
+        return None;
+    }
+    let uri = Url::from_file_path(&path).ok()?;
+    let p = Position {
+        line: def.line,
+        character: def.character,
+    };
+    Some(Location {
+        uri,
+        range: Range { start: p, end: p },
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn pragma_map_loads_console_log() {
+        let d = lookup_global("console").expect("console");
+        assert!(d.rel_path.contains("eval.rs"));
+        let m = lookup_dotted("console", "log").expect("console.log");
+        assert!(m.rel_path.contains("natives.rs"));
+    }
+
+    #[test]
+    fn jsx_div_maps_to_ui_h() {
+        let text = "let x = <div />";
+        let line = 0u32;
+        let defn = definition_for_builtin(text, line, 9, "div").expect("div builtin");
+        assert!(defn.rel_path.contains("runtime"));
+        assert_eq!(defn.line, 40);
+    }
+
+    #[test]
+    fn set_timeout_global() {
+        let defn =
+            definition_for_builtin("setTimeout(0, fn() {})\n", 0, 0, "setTimeout").expect("timer");
+        assert_eq!(defn.rel_path, "crates/tish_eval/src/timers.rs");
+    }
+
+    #[test]
+    fn console_log_qualified() {
+        let text = "console.log(1)";
+        let defn = definition_for_builtin(text, 0, 10, "log").expect("console.log");
+        assert_eq!(defn.rel_path, "crates/tish_eval/src/natives.rs");
+    }
+}