npm - rapydscript-ng - Versions diffs - 0.7.23 → 0.8.0 - Mend

rapydscript-ng 0.7.23 → 0.8.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (114) hide show

package/CHANGELOG.md +24 -0
package/README.md +72 -26
package/bin/package.json +1 -0
package/bin/rapydscript +65 -62
package/editor-plugins/nvim/rapydscript/README.md +184 -0
package/editor-plugins/nvim/rapydscript/bin/rapydscript.so +0 -0
package/editor-plugins/nvim/rapydscript/ftdetect/rapydscript.lua +10 -0
package/editor-plugins/nvim/rapydscript/lua/rapydscript/health.lua +88 -0
package/editor-plugins/nvim/rapydscript/lua/rapydscript/init.lua +279 -0
package/local-agent.md +28 -0
package/package.json +4 -5
package/release/baselib-plain-pretty.js +448 -326
package/release/baselib-plain-ugly.js +3 -3
package/release/compiler.js +2528 -1672
package/release/signatures.json +17 -17
package/src/ast.pyj +73 -25
package/src/baselib-builtins.pyj +2 -2
package/src/baselib-containers.pyj +153 -151
package/src/baselib-internal.pyj +3 -3
package/src/baselib-str.pyj +5 -5
package/src/lib/aes.pyj +1 -1
package/src/lib/encodings.pyj +1 -1
package/src/lib/pythonize.pyj +1 -1
package/src/lib/re.pyj +2 -2
package/src/lib/traceback.pyj +165 -28
package/src/lib/uuid.pyj +1 -1
package/src/output/codegen.pyj +10 -3
package/src/output/functions.pyj +31 -40
package/src/output/literals.pyj +11 -14
package/src/output/loops.pyj +25 -87
package/src/output/modules.pyj +5 -47
package/src/output/statements.pyj +1 -1
package/src/output/stream.pyj +58 -31
package/src/parse.pyj +777 -427
package/src/tokenizer.pyj +16 -4
package/src/utils.pyj +1 -1
package/test/_treeshake_mod.pyj +30 -0
package/test/_treeshake_side_effect.pyj +9 -0
package/test/ast_serialization.pyj +392 -0
package/test/async.pyj +95 -0
package/test/baselib.pyj +1 -2
package/test/embedded_compiler.pyj +57 -0
package/test/fmt.pyj +201 -0
package/test/generic.pyj +7 -3
package/test/imports.pyj +8 -6
package/test/internationalization.pyj +38 -37
package/test/lint.pyj +120 -115
package/test/lsp.pyj +222 -0
package/test/repl.pyj +70 -65
package/test/sourcemaps.pyj +315 -0
package/test/starargs.pyj +46 -39
package/test/traceback.pyj +263 -0
package/test/treeshaking.pyj +181 -0
package/test/web_repl_export.pyj +88 -0
package/tools/ast_serialize.mjs +557 -0
package/tools/cli.mjs +510 -0
package/tools/compile.mjs +201 -0
package/tools/compiler.mjs +127 -0
package/tools/{completer.js → completer.mjs} +6 -6
package/tools/{embedded_compiler.js → embedded_compiler.mjs} +17 -13
package/tools/export.js +109 -56
package/tools/fmt.mjs +735 -0
package/tools/{gettext.js → gettext.mjs} +46 -53
package/tools/{ini.js → ini.mjs} +9 -10
package/tools/{lint.js → lint.mjs} +107 -56
package/tools/lsp.mjs +914 -0
package/tools/lsp_protocol.mjs +259 -0
package/tools/lsp_symbols.mjs +418 -0
package/tools/{msgfmt.js → msgfmt.mjs} +18 -18
package/tools/{repl.js → repl.mjs} +52 -41
package/tools/{self.js → self.mjs} +56 -46
package/tools/sourcemap.mjs +123 -0
package/tools/test.mjs +152 -0
package/tools/treeshake.mjs +400 -0
package/tools/{utils.js → utils.mjs} +26 -23
package/tools/{web_repl.js → web_repl.mjs} +15 -13
package/tools/web_repl_export.mjs +93 -0
package/tree-sitter/README.md +101 -0
package/tree-sitter/grammar.js +992 -0
package/tree-sitter/package.json +43 -0
package/tree-sitter/queries/rapydscript/highlights.scm +232 -0
package/tree-sitter/queries/rapydscript/indents.scm +64 -0
package/tree-sitter/queries/rapydscript/injections.scm +14 -0
package/tree-sitter/queries/rapydscript/locals.scm +108 -0
package/tree-sitter/src/grammar.json +4976 -0
package/tree-sitter/src/node-types.json +2901 -0
package/tree-sitter/src/parser.c +196465 -0
package/tree-sitter/src/scanner.c +294 -0
package/tree-sitter/src/tree_sitter/alloc.h +54 -0
package/tree-sitter/src/tree_sitter/array.h +330 -0
package/tree-sitter/src/tree_sitter/parser.h +286 -0
package/tree-sitter/test/corpus/chaining.txt +99 -0
package/tree-sitter/test/corpus/classes.txt +147 -0
package/tree-sitter/test/corpus/comprehensions.txt +155 -0
package/tree-sitter/test/corpus/containers.txt +242 -0
package/tree-sitter/test/corpus/control_flow.txt +361 -0
package/tree-sitter/test/corpus/decorators.txt +64 -0
package/tree-sitter/test/corpus/existential.txt +102 -0
package/tree-sitter/test/corpus/functions.txt +293 -0
package/tree-sitter/test/corpus/imports.txt +117 -0
package/tree-sitter/test/corpus/literals.txt +135 -0
package/tree-sitter/test/corpus/operators.txt +296 -0
package/tree-sitter/test/corpus/statements.txt +189 -0
package/tree-sitter/test/corpus/strings.txt +90 -0
package/tree-sitter/test/corpus/subscripts.txt +227 -0
package/tree-sitter/tree-sitter.json +36 -0
package/web-repl/env.js +35 -23
package/web-repl/main.js +8 -8
package/bin/export +0 -75
package/bin/web-repl-export +0 -102
package/tools/cli.js +0 -523
package/tools/compile.js +0 -184
package/tools/compiler.js +0 -84
package/tools/test.js +0 -110

package/tools/lsp_protocol.mjs ADDED Viewed

@@ -0,0 +1,259 @@
+/* vim:fileencoding=utf-8
+ *
+ * lsp_protocol.mjs -- Minimal Language Server Protocol transport for RapydScript.
+ *
+ * Copyright (C) 2026 Kovid Goyal <kovid at kovidgoyal.net>
+ *
+ * Distributed under terms of the BSD license.
+ *
+ * This implements just enough of the LSP wire protocol (JSON-RPC 2.0 with
+ * Content-Length framing over a byte stream) to drive an editor. We deliberately
+ * do not depend on the vscode-languageserver npm package: the surface we need is
+ * small and the project prefers to avoid external dependencies.
+ */
+"use strict";
+// ---------------------------------------------------------------------------
+// JSON-RPC error codes (subset used here)
+// ---------------------------------------------------------------------------
+export var ErrorCodes = {
+    ParseError: -32700,
+    InvalidRequest: -32600,
+    MethodNotFound: -32601,
+    InvalidParams: -32602,
+    InternalError: -32603,
+    RequestCancelled: -32800,
+};
+// A handler may throw this to produce a specific JSON-RPC error response.
+export function ResponseError(code, message, data) {
+    var e = new Error(message);
+    e.code = code;
+    e.data = data;
+    e.is_response_error = true;
+    return e;
+}
+// ---------------------------------------------------------------------------
+// Message framing: parse a byte stream of `Content-Length: N\r\n\r\n<body>`
+// ---------------------------------------------------------------------------
+function MessageReader(stream, on_message, on_error) {
+    var buffer = Buffer.alloc(0);
+    var content_length = -1;
+    function try_parse() {
+        // Loop so that multiple messages contained in one chunk are all handled.
+        while (true) {
+            if (content_length < 0) {
+                var idx = buffer.indexOf('\r\n\r\n');
+                if (idx < 0) return;
+                var header = buffer.slice(0, idx).toString('ascii');
+                content_length = -1;
+                header.split('\r\n').forEach(function (line) {
+                    var sep = line.indexOf(':');
+                    if (sep < 0) return;
+                    var name = line.slice(0, sep).trim().toLowerCase();
+                    var value = line.slice(sep + 1).trim();
+                    if (name === 'content-length') content_length = parseInt(value, 10);
+                });
+                buffer = buffer.slice(idx + 4);
+                if (isNaN(content_length) || content_length < 0) {
+                    content_length = -1;
+                    if (on_error) on_error(new Error('Invalid or missing Content-Length header'));
+                    return;
+                }
+            }
+            if (buffer.length < content_length) return;  // wait for more bytes
+            var body = buffer.slice(0, content_length).toString('utf-8');
+            buffer = buffer.slice(content_length);
+            content_length = -1;
+            var msg;
+            try { msg = JSON.parse(body); }
+            catch (e) { if (on_error) on_error(e); continue; }
+            on_message(msg);
+        }
+    }
+    stream.on('data', function (chunk) {
+        buffer = Buffer.concat([buffer, chunk]);
+        try { try_parse(); }
+        catch (e) { if (on_error) on_error(e); }
+    });
+    return {};
+}
+function write_message(stream, msg) {
+    var body = JSON.stringify(msg);
+    var payload = Buffer.from(body, 'utf-8');
+    stream.write('Content-Length: ' + payload.length + '\r\n\r\n');
+    stream.write(payload);
+}
+// ---------------------------------------------------------------------------
+// Connection: dispatch requests / notifications to registered handlers
+// ---------------------------------------------------------------------------
+export function create_connection(input, output, log) {
+    var request_handlers = Object.create(null);
+    var notification_handlers = Object.create(null);
+    var cancelled = Object.create(null);  // request id -> true
+    var pending_requests = Object.create(null);  // id -> {resolve, reject}
+    var next_request_id = 1;
+    function send(msg) { write_message(output, msg); }
+    function send_error(id, code, message, data) {
+        send({ jsonrpc: '2.0', id: id, error: { code: code, message: message, data: data } });
+    }
+    function handle_response(msg) {
+        var pending = pending_requests[msg.id];
+        if (!pending) return;
+        delete pending_requests[msg.id];
+        if (msg.error) {
+            var err = new Error(msg.error.message || 'Request failed');
+            err.code = msg.error.code;
+            pending.reject(err);
+        } else {
+            pending.resolve(msg.result);
+        }
+    }
+    async function handle_request(msg) {
+        var handler = request_handlers[msg.method];
+        if (!handler) {
+            // Unknown request: respond with MethodNotFound (required by spec).
+            send_error(msg.id, ErrorCodes.MethodNotFound, 'Unhandled method: ' + msg.method);
+            return;
+        }
+        try {
+            if (cancelled[msg.id]) {
+                delete cancelled[msg.id];
+                send_error(msg.id, ErrorCodes.RequestCancelled, 'Request cancelled');
+                return;
+            }
+            var result = await handler(msg.params, msg.id);
+            if (cancelled[msg.id]) { delete cancelled[msg.id]; send_error(msg.id, ErrorCodes.RequestCancelled, 'Request cancelled'); return; }
+            send({ jsonrpc: '2.0', id: msg.id, result: (result === undefined) ? null : result });
+        } catch (e) {
+            if (e && e.is_response_error) send_error(msg.id, e.code, e.message, e.data);
+            else {
+                if (log) log('Error handling ' + msg.method + ': ' + (e && e.stack ? e.stack : e));
+                send_error(msg.id, ErrorCodes.InternalError, (e && e.message) ? e.message : String(e));
+            }
+        }
+    }
+    async function handle_notification(msg) {
+        if (msg.method === '$/cancelRequest' && msg.params && msg.params.id !== undefined) {
+            cancelled[msg.params.id] = true;
+            return;
+        }
+        var handler = notification_handlers[msg.method];
+        if (!handler) return;  // Unknown notifications are silently ignored per spec.
+        try { await handler(msg.params); }
+        catch (e) { if (log) log('Error handling notification ' + msg.method + ': ' + (e && e.stack ? e.stack : e)); }
+    }
+    function on_message(msg) {
+        if (!msg || msg.jsonrpc !== '2.0') return;
+        if (msg.method !== undefined && msg.id !== undefined) handle_request(msg);
+        else if (msg.method !== undefined) handle_notification(msg);
+        else if (msg.id !== undefined) handle_response(msg);
+    }
+    MessageReader(input, on_message, function (e) { if (log) log('Message parse error: ' + e); });
+    return {
+        on_request: function (method, handler) { request_handlers[method] = handler; },
+        on_notification: function (method, handler) { notification_handlers[method] = handler; },
+        send_notification: function (method, params) { send({ jsonrpc: '2.0', method: method, params: params }); },
+        send_request: function (method, params) {
+            return new Promise(function (resolve, reject) {
+                var id = next_request_id++;
+                pending_requests[id] = { resolve: resolve, reject: reject };
+                send({ jsonrpc: '2.0', id: id, method: method, params: params });
+            });
+        },
+        dispose: function () { request_handlers = Object.create(null); notification_handlers = Object.create(null); },
+    };
+}
+// ---------------------------------------------------------------------------
+// TextDocument: in-memory buffer with UTF-16 position <-> offset conversion.
+// LSP positions are 0-based (line, character) where character counts UTF-16
+// code units. JavaScript strings are already UTF-16, so a plain index into the
+// string is the correct offset.
+// ---------------------------------------------------------------------------
+export function TextDocument(uri, language_id, version, text) {
+    this.uri = uri;
+    this.language_id = language_id;
+    this.version = version;
+    this._set_text(text);
+}
+TextDocument.prototype._set_text = function (text) {
+    this.text = text;
+    // Precompute the offset at which each line starts so position<->offset
+    // conversion is O(log n) / O(1) instead of rescanning the whole buffer.
+    var starts = [0];
+    for (var i = 0; i < text.length; i++) {
+        var c = text.charCodeAt(i);
+        if (c === 10 /*\n*/) starts.push(i + 1);
+        else if (c === 13 /*\r*/) {
+            if (text.charCodeAt(i + 1) === 10) { i++; }
+            starts.push(i + 1);
+        }
+    }
+    this._line_starts = starts;
+};
+TextDocument.prototype.update = function (text, version) {
+    if (version !== undefined && version !== null) this.version = version;
+    this._set_text(text);
+};
+TextDocument.prototype.line_count = function () { return this._line_starts.length; };
+// {line, character} -> integer offset into the buffer.
+TextDocument.prototype.offset_at = function (position) {
+    var starts = this._line_starts;
+    if (position.line >= starts.length) return this.text.length;
+    if (position.line < 0) return 0;
+    var line_start = starts[position.line];
+    var line_end = (position.line + 1 < starts.length) ? starts[position.line + 1] : this.text.length;
+    var offset = line_start + Math.max(0, position.character);
+    return Math.min(offset, line_end);
+};
+// integer offset -> {line, character}
+TextDocument.prototype.position_at = function (offset) {
+    offset = Math.max(0, Math.min(offset, this.text.length));
+    var starts = this._line_starts;
+    // binary search for the last line start <= offset
+    var low = 0, high = starts.length - 1, line = 0;
+    while (low <= high) {
+        var mid = (low + high) >> 1;
+        if (starts[mid] <= offset) { line = mid; low = mid + 1; }
+        else high = mid - 1;
+    }
+    return { line: line, character: offset - starts[line] };
+};
+// Convenience: 1-based (line, col0) parser coordinates -> LSP 0-based position.
+TextDocument.prototype.lsp_position = function (parser_line, parser_col) {
+    return { line: Math.max(0, (parser_line || 1) - 1), character: Math.max(0, parser_col || 0) };
+};
+// A document store keyed by uri.
+export function DocumentStore() { this.docs = Object.create(null); }
+DocumentStore.prototype.open = function (uri, language_id, version, text) {
+    var d = new TextDocument(uri, language_id, version, text);
+    this.docs[uri] = d;
+    return d;
+};
+DocumentStore.prototype.get = function (uri) { return this.docs[uri]; };
+DocumentStore.prototype.close = function (uri) { delete this.docs[uri]; };
+DocumentStore.prototype.all = function () {
+    var self = this;
+    return Object.keys(this.docs).map(function (k) { return self.docs[k]; });
+};

package/tools/lsp_symbols.mjs ADDED Viewed

@@ -0,0 +1,418 @@
+/* vim:fileencoding=utf-8
+ *
+ * lsp_symbols.mjs -- Scope and symbol analysis for the RapydScript LSP.
+ *
+ * Copyright (C) 2026 Kovid Goyal <kovid at kovidgoyal.net>
+ *
+ * Distributed under terms of the BSD license.
+ *
+ * Walks a parsed AST once and records, for every binding, its definition
+ * identifier node(s) and every reference to it (resolved to the nearest
+ * enclosing scope). This single index powers go-to-definition, find-references,
+ * rename, hover and scope aware completion. The traversal mirrors the linter's
+ * scope handling (tools/lint.mjs) but, unlike the linter, it keeps the nodes so
+ * they can be queried by source position.
+ */
+"use strict";
+// Reuse the single compiler instance created synchronously by bin/rapydscript.
+const RapydScript = globalThis.create_rapydscript_compiler();
+var has_prop = Object.prototype.hasOwnProperty.call.bind(Object.prototype.hasOwnProperty);
+// Symbol kinds also map to LSP CompletionItemKind / SymbolKind in lsp.mjs.
+export var KIND = {
+    IMPORT: 'import', IMPORTED_NAME: 'imported-name', FUNCTION: 'function',
+    CLASS: 'class', METHOD: 'method', PARAMETER: 'parameter', VARIABLE: 'variable',
+    LOOPVAR: 'loopvar', EXCEPT: 'except',
+};
+// ---------------------------------------------------------------------------
+// Position helpers. Tokenizer positions (`pos`, `endpos`) are character offsets
+// into the newline-normalized source, which is exactly what we analyze.
+// ---------------------------------------------------------------------------
+export function symbol_range(node, name) {
+    // For a symbol/identifier node, the start token IS the identifier token.
+    if (!node) return null;
+    var s = node.start || node;
+    if (s && typeof s.pos === 'number') {
+        var end = (typeof s.endpos === 'number') ? s.endpos : (s.pos + (name ? name.length : 0));
+        return [s.pos, end];
+    }
+    return null;
+}
+export function node_span(node) {
+    if (!node || !node.start) return null;
+    var s = node.start;
+    var e = node.end || node.start;
+    if (typeof s.pos !== 'number') return null;
+    var end = (typeof e.endpos === 'number') ? e.endpos : (typeof e.pos === 'number' ? e.pos : s.pos);
+    return [s.pos, end];
+}
+// The identifier token of a `.property` access is the AST_Dot's end token.
+function dot_property_range(node) {
+    var e = node.end;
+    if (e && typeof e.pos === 'number' && typeof e.endpos === 'number') return [e.pos, e.endpos];
+    return null;
+}
+// ---------------------------------------------------------------------------
+// Scope / SymbolDef model
+// ---------------------------------------------------------------------------
+function SymbolDef(name, scope, kind) {
+    this.name = name;
+    this.scope = scope;
+    this.kind = kind;
+    this.def_nodes = [];   // identifier nodes that (re)define the symbol
+    this.ref_nodes = [];   // identifier nodes that reference the symbol
+    this.docstring = null; // populated for functions/classes
+}
+function Scope(node, parent, kind) {
+    this.node = node;
+    this.parent = parent;
+    this.kind = kind;            // 'toplevel' | 'function' | 'class' | 'comprehension'
+    this.is_class = kind === 'class';
+    this.is_toplevel = kind === 'toplevel';
+    this.bindings = Object.create(null);  // name -> SymbolDef
+    this.nonlocals = Object.create(null);
+    this.children = [];
+}
+Scope.prototype.define = function (name, node, kind) {
+    var def = this.bindings[name];
+    if (!def) { def = new SymbolDef(name, this, kind); this.bindings[name] = def; }
+    else if (kind && def.kind === KIND.VARIABLE) def.kind = kind;  // prefer a more specific kind
+    if (node) { node._rs_def = def; def.def_nodes.push(node); }
+    return def;
+};
+// ---------------------------------------------------------------------------
+// The analyzer walks the AST building scopes, definitions and references.
+// ---------------------------------------------------------------------------
+function Analyzer(toplevel, filename) {
+    this.filename = filename;
+    this.toplevel = toplevel;
+    this.scopes = [];
+    this.pending_refs = [];   // {name, node, scope}
+    this.member_accesses = []; // {object_name, property, range, node}
+    this.all_defs = [];
+    this.all_refs = [];       // resolved references {name, node, range, def}
+    this.imports = [];        // {key, kind, node, alias, argnames, module_node}
+}
+Analyzer.prototype.current = function () { return this.scopes[this.scopes.length - 1]; };
+Analyzer.prototype.define = function (name, node, kind) {
+    var d = this.current().define(name, node, kind);
+    if (this.all_defs.indexOf(d) < 0) this.all_defs.push(d);
+    return d;
+};
+Analyzer.prototype.reference = function (name, node) {
+    this.pending_refs.push({ name: name, node: node, scope: this.current() });
+};
+Analyzer.prototype.push_scope = function (node, kind) {
+    var s = new Scope(node, this.current() || null, kind);
+    if (this.scopes.length) this.current().children.push(s);
+    this.scopes.push(s);
+    if (node) node._rs_scope = s;
+    return s;
+};
+Analyzer.prototype.pop_scope = function () { return this.scopes.pop(); };
+// -- individual node handlers (mirrors lint.mjs) ----------------------------
+Analyzer.prototype.handle_import = function (node) {
+    if (!node.argnames) {
+        // `import M` / `import M.sub` / `import M as alias`
+        var name = (node.alias) ? node.alias.name : node.key.split('.', 1)[0];
+        var idnode = node.alias || node.module || node;
+        var d = this.define(name, idnode, KIND.IMPORT);
+        d.import_key = node.key;
+        this.imports.push({ key: node.key, kind: 'module', node: node, alias: node.alias, argnames: null, def: d });
+    } else {
+        // `from M import a, b as c` -- the argnames are visited as AST_ImportedVar.
+        this.imports.push({ key: node.key, kind: 'from', node: node, alias: node.alias, argnames: node.argnames });
+    }
+};
+Analyzer.prototype.handle_imported_var = function (node) {
+    // `node` is an AST_ImportedVar: node.name is the original exported name, and
+    // node.alias (if present) is the local name it is bound to.
+    var name = (node.alias) ? node.alias.name : node.name;
+    var idnode = node.alias || node;
+    var d = this.define(name, idnode, KIND.IMPORTED_NAME);
+    d.import_original_name = node.name;
+    d.import_alias = node.alias ? node.alias.name : null;
+    // The token spelling the *original* name is `node` itself (start token).
+    d.import_original_node = node;
+    // import_key is filled in during finalize (the ImportedVar does not carry it).
+    node._rs_imported_var_def = d;
+};
+Analyzer.prototype.handle_lambda = function (node) {
+    var name = (node.name) ? node.name.name : undefined;
+    if (!name) return;
+    if (node instanceof RapydScript.AST_Method) {
+        // Methods live in the enclosing class scope.
+        var d = this.define(name, node.name, KIND.METHOD);
+        d.docstring = docstring_of(node);
+    } else {
+        var fd = this.define(name, node.name, KIND.FUNCTION);
+        fd.docstring = docstring_of(node);
+    }
+};
+Analyzer.prototype.handle_class = function (node) {
+    if (node.name) {
+        node.name._rs_is_binding = true;
+        var d = this.define(node.name.name, node.name, KIND.CLASS);
+        d.docstring = docstring_of(node);
+    }
+};
+Analyzer.prototype.handle_assign = function (node) {
+    var self = this;
+    function destructured(flat) {
+        for (var i = 0; i < flat.length; i++) {
+            var cnode = flat[i];
+            if (cnode instanceof RapydScript.AST_SymbolRef) { cnode._rs_is_binding = true; self.define(cnode.name, cnode, KIND.VARIABLE); }
+        }
+    }
+    if (node.left instanceof RapydScript.AST_SymbolRef) {
+        if (node.operator === '=') { node.left._rs_is_binding = true; this.define(node.left.name, node.left, KIND.VARIABLE); }
+        // compound assignment (+=) references the existing binding, handled by the generic ref path
+    } else if (node.left instanceof RapydScript.AST_Array) {
+        destructured(node.left.flatten());
+    } else if (node.left instanceof RapydScript.AST_Seq && node.left.car instanceof RapydScript.AST_SymbolRef) {
+        destructured(node.left.to_array());
+    }
+};
+Analyzer.prototype.handle_vardef = function (node) {
+    if (node.name instanceof RapydScript.AST_SymbolNonlocal) {
+        this.current().nonlocals[node.name.name] = true;
+    } else {
+        this.define(node.name.name, node.name, KIND.VARIABLE);
+    }
+};
+Analyzer.prototype.handle_symbol_funarg = function (node) {
+    this.define(node.name, node, KIND.PARAMETER);
+};
+Analyzer.prototype.handle_for_in = function (node) {
+    var self = this;
+    if (node.init instanceof RapydScript.AST_SymbolRef) {
+        node.init._rs_is_binding = true;
+        this.define(node.init.name, node.init, KIND.LOOPVAR);
+    } else if (node.init instanceof RapydScript.AST_Array) {
+        for (var i = 0; i < node.init.elements.length; i++) {
+            var cnode = node.init.elements[i];
+            if (cnode instanceof RapydScript.AST_Seq) cnode = cnode.to_array();
+            if (cnode instanceof RapydScript.AST_SymbolRef) cnode = [cnode];
+            if (Array.isArray(cnode)) cnode.forEach(function (elem) {
+                if (elem instanceof RapydScript.AST_SymbolRef) { elem._rs_is_binding = true; self.define(elem.name, elem, KIND.LOOPVAR); }
+            });
+        }
+    }
+};
+Analyzer.prototype.handle_for_js = function (node) {
+    var js = node.condition.value;
+    var decl = js.split(';')[0].trim();
+    if (decl.slice(0, 4) === 'var ') decl = decl.slice(4);
+    var self = this;
+    decl.split(',').forEach(function (part) {
+        var m = /^[a-zA-Z0-9_$]+/.exec(part.replace(/^\s+/, ''));
+        if (m) self.define(m[0], node, KIND.VARIABLE);
+    });
+};
+Analyzer.prototype.handle_except = function (node) {
+    if (node.argname) this.define(node.argname.name, node.argname, KIND.EXCEPT);
+};
+Analyzer.prototype.handle_with_clause = function (node) {
+    if (node.alias) this.define(node.alias.name, node.alias, KIND.VARIABLE);
+};
+Analyzer.prototype.handle_symbol_ref = function (node) {
+    if (node._rs_is_binding) return;  // already consumed as a definition
+    this.reference(node.name, node);
+};
+Analyzer.prototype.handle_dot = function (node) {
+    // Record `object.property` where object is a simple name, for cross-file
+    // member resolution (e.g. `mod.func`).
+    if (node.expression instanceof RapydScript.AST_SymbolRef) {
+        var r = dot_property_range(node);
+        if (r) this.member_accesses.push({ object_node: node.expression, property: node.property, range: r, node: node });
+    }
+};
+// -- the visitor -------------------------------------------------------------
+Analyzer.prototype.visit = function (node, cont) {
+    var scope_count = this.scopes.length;
+    if (node instanceof RapydScript.AST_Lambda) this.handle_lambda(node);
+    else if (node instanceof RapydScript.AST_Import) this.handle_import(node);
+    else if (node instanceof RapydScript.AST_ImportedVar) this.handle_imported_var(node);
+    else if (node instanceof RapydScript.AST_Class) this.handle_class(node);
+    else if (node instanceof RapydScript.AST_BaseCall) this.handle_call(node);
+    else if (node instanceof RapydScript.AST_Assign) this.handle_assign(node);
+    else if (node instanceof RapydScript.AST_VarDef) this.handle_vardef(node);
+    else if (node instanceof RapydScript.AST_Dot) this.handle_dot(node);
+    else if (node instanceof RapydScript.AST_SymbolRef) this.handle_symbol_ref(node);
+    else if (node instanceof RapydScript.AST_Decorator) this.handle_decorator(node);
+    else if (node instanceof RapydScript.AST_SymbolFunarg) this.handle_symbol_funarg(node);
+    else if (node instanceof RapydScript.AST_ListComprehension) { this.push_scope(node, 'comprehension'); this.handle_for_in(node); }
+    else if (node instanceof RapydScript.AST_ForIn) this.handle_for_in(node);
+    else if (node instanceof RapydScript.AST_ForJS) this.handle_for_js(node);
+    else if (node instanceof RapydScript.AST_Except) this.handle_except(node);
+    else if (node instanceof RapydScript.AST_WithClause) this.handle_with_clause(node);
+    if (!(node instanceof RapydScript.AST_ListComprehension) && node instanceof RapydScript.AST_Scope) {
+        this.push_scope(node, node instanceof RapydScript.AST_Class ? 'class' : (node instanceof RapydScript.AST_Toplevel ? 'toplevel' : 'function'));
+    }
+    if (cont !== undefined) cont();
+    if (this.scopes.length > scope_count) this.pop_scope();
+};
+Analyzer.prototype.handle_call = function (node) {
+    if (node.args && node.args.kwargs) node.args.kwargs.forEach(function (kw) { if (kw[0]) kw[0]._rs_is_binding = true; });
+};
+Analyzer.prototype.handle_decorator = function (node) {
+    var e = node.expression;
+    if (e instanceof RapydScript.AST_SymbolRef && RapydScript.compile_time_decorators.indexOf(e.name) !== -1) e._rs_is_binding = true;
+};
+// Resolve a reference to the nearest enclosing scope that binds `name`.
+function resolve_in_scopes(scope, name) {
+    for (var s = scope; s; s = s.parent) {
+        if (has_prop(s.bindings, name)) return s.bindings[name];
+    }
+    return null;
+}
+Analyzer.prototype.finalize = function () {
+    var self = this;
+    this.pending_refs.forEach(function (r) {
+        if (r.node._rs_is_binding) return;
+        var def = resolve_in_scopes(r.scope, r.name);
+        var range = symbol_range(r.node, r.name);
+        var rec = { name: r.name, node: r.node, range: range, def: def || null };
+        self.all_refs.push(rec);
+        if (def) def.ref_nodes.push(r.node);
+        r.node._rs_ref = rec;
+    });
+};
+function docstring_of(node) {
+    // Functions/classes keep their docstring on node.docstring (AST_String) when present.
+    if (node && node.docstrings && node.docstrings.length) {
+        var d = node.docstrings[0];
+        return (d && typeof d.value === 'string') ? d.value : (typeof d === 'string' ? d : null);
+    }
+    if (node && node.docstring && typeof node.docstring.value === 'string') return node.docstring.value;
+    return null;
+}
+// ---------------------------------------------------------------------------
+// Public: build a SymbolIndex from an already-parsed toplevel.
+// ---------------------------------------------------------------------------
+function SymbolIndex(analyzer) {
+    this.toplevel = analyzer.toplevel;
+    this.filename = analyzer.filename;
+    this.defs = analyzer.all_defs;
+    this.refs = analyzer.all_refs;
+    this.imports = analyzer.imports;
+    this.member_accesses = analyzer.member_accesses;
+    this.import_names = analyzer.import_names || [];  // aliased `from M import ORIG as x` ORIG spans
+    this.toplevel_scope = analyzer.scopes_root;
+}
+export function build_index(toplevel, filename) {
+    var a = new Analyzer(toplevel, filename);
+    var visitor = { _visit: function (node, descend) { a.visit(node, descend); } };
+    toplevel.walk(visitor);
+    a.scopes_root = toplevel._rs_scope || null;
+    a.finalize();
+    // Link `from M import name` bindings to their module key so cross-file
+    // resolution knows the exported symbol they came from.
+    a.import_names = [];
+    a.imports.forEach(function (imp) {
+        if (imp.kind === 'from' && imp.argnames) imp.argnames.forEach(function (av) {
+            if (av._rs_imported_var_def) av._rs_imported_var_def.import_key = imp.key;
+            if (av.alias) {
+                // The original exported name has its own span, distinct from the alias.
+                var r = symbol_range(av, av.name);
+                if (r) a.import_names.push({ range: r, key: imp.key, original: av.name, def: av._rs_imported_var_def });
+            }
+        });
+    });
+    return new SymbolIndex(a);
+}
+// Which def/ref covers `offset`? Returns {kind:'def'|'ref'|'member', def, node, range}.
+export function locate(index, offset) {
+    function contains(range) { return range && offset >= range[0] && offset <= range[1]; }
+    // Prefer the innermost/most-specific: defs and refs are identifier sized so no nesting.
+    for (var i = 0; i < index.defs.length; i++) {
+        var d = index.defs[i];
+        for (var j = 0; j < d.def_nodes.length; j++) {
+            var r = symbol_range(d.def_nodes[j], d.name);
+            if (contains(r)) return { kind: 'def', def: d, node: d.def_nodes[j], range: r };
+        }
+    }
+    for (var k = 0; k < index.refs.length; k++) {
+        if (contains(index.refs[k].range)) return { kind: 'ref', def: index.refs[k].def, node: index.refs[k].node, range: index.refs[k].range, ref: index.refs[k] };
+    }
+    for (var m = 0; m < index.member_accesses.length; m++) {
+        if (contains(index.member_accesses[m].range)) return { kind: 'member', member: index.member_accesses[m], range: index.member_accesses[m].range };
+    }
+    for (var n = 0; n < index.import_names.length; n++) {
+        if (contains(index.import_names[n].range)) return { kind: 'import-name', import_name: index.import_names[n], range: index.import_names[n].range };
+    }
+    return null;
+}
+// Collect the set of visible symbol names at a given offset (for completion):
+// walk the scope tree to the deepest scope containing the offset, then gather
+// bindings from that scope outward.
+export function visible_symbols(index, offset) {
+    var root = index.toplevel_scope;
+    var out = [];
+    var seen = Object.create(null);
+    function span_contains(scope) {
+        var sp = node_span(scope.node);
+        return sp && offset >= sp[0] && offset <= sp[1];
+    }
+    function deepest(scope) {
+        for (var i = 0; i < scope.children.length; i++) {
+            if (span_contains(scope.children[i])) { var d = deepest(scope.children[i]); if (d) return d; }
+        }
+        return scope;
+    }
+    if (!root) return out;
+    var scope = deepest(root);
+    for (var s = scope; s; s = s.parent) {
+        if (s.is_class && s !== scope) continue;  // class scope not visible to nested functions
+        for (var name in s.bindings) {
+            if (seen[name]) continue;
+            seen[name] = true;
+            out.push({ name: name, def: s.bindings[name] });
+        }
+    }
+    return out;
+}
+export { RapydScript };