yuku-analyzer 0.5.32 → 0.5.36

package/README.md

@@ -62,6 +62,7 @@ And node-level queries that work directly on AST nodes:
 module.symbolOf(node)    // the symbol a node declares or references
 module.referenceOf(node) // the reference recorded for an identifier
 module.scopeOf(node)     // the innermost scope containing the node
+module.parentOf(node)    // the node that structurally contains it, or null
 module.resolve("name")   // scope-chain lookup, like the engine does at runtime
 ```
 

package/decode.js

@@ -1331,6 +1331,35 @@ function decode(buffer, source) {
       }
     })(progIdx);
   }
+  let _parentArr;
+  function _parents() {
+    if (_parentArr !== undefined) return _parentArr;
+    const p = new Int32Array(nodeCount).fill(-1);
+    (function visit(i, parent) {
+      const o = _nodesOff + i * 48;
+      const tag = _u8[o];
+      if (TAG_TYPES[tag] !== null) { p[i] = parent; parent = i; }
+      const ops = SCAN_CHILDREN[tag];
+      const b = o >> 2;
+      for (let q = 0; q < ops.length; q += 2) {
+        const slot = ops[q + 1];
+        if (ops[q] === 0) {
+          const c = _u32[b + slot];
+          if (c !== NULL) visit(c, parent);
+        } else {
+          const s = _u32[b + slot];
+          const len = ops[q] === 1
+            ? _u32[b + slot + 1]
+            : _u8[o + 4] | (_u8[o + 5] << 8);
+          for (let j = 0; j < len; j++) {
+            const c = _u32[_extraBase + s + j];
+            if (c !== NULL) visit(c, parent);
+          }
+        }
+      }
+    })(progIdx, -1);
+    return (_parentArr = p);
+  }
   let _semView;
   function _semantic() {
     if (_semView !== undefined) return _semView;
@@ -1349,7 +1378,8 @@ function decode(buffer, source) {
     let o = ((dp + 3) & ~3) >> 2;
     const scopeCount = _u32[o], symbolCount = _u32[o + 1],
           referenceCount = _u32[o + 2], declNodeCount = _u32[o + 3],
-          importCount = _u32[o + 4], exportCount = _u32[o + 5];
+          importCount = _u32[o + 4], exportCount = _u32[o + 5],
+          nodeScopeCount = _u32[o + 6];
     o += 8;
     const scopes = _u32.subarray(o, o + scopeCount * 4);
     o += scopeCount * 4;
@@ -1363,6 +1393,8 @@ function decode(buffer, source) {
     o += importCount * 8;
     const exports = _u32.subarray(o, o + exportCount * 10);
     o += exportCount * 10;
+    const nodeScopes = _u32.subarray(o, o + nodeScopeCount);
+    o += nodeScopeCount;
     const _id = (v) => v === NULL ? null : v;
     return (_semView = {
       scope: {
@@ -1421,6 +1453,7 @@ function decode(buffer, source) {
         symbolId: (i) => _id(exports[i * 10 + 3]),
         node: (i) => node(exports[i * 10 + 8]),
       },
+      nodeScope: (i) => nodeScopes[i],
     });
   }
   let _program, _lineStarts, _diagnostics, _comments;
@@ -1455,6 +1488,7 @@ function decode(buffer, source) {
     scan,
     nodeOf: node,
     indexOf: (n) => _nodeIndexes.get(n),
+    parentIndex: (i) => _parents()[i],
     startOf, endOf, str,
     get semantic() { return _semantic(); },
   };

package/engine.js

@@ -91,15 +91,11 @@ function createDispatch(visitors) {
  * in place. Returns the root.
  */
 export function walk(root, visitors, state) {
-  _walk(root, visitors, state, null, new WalkContext());
+  _walk(root, visitors, state, new WalkContext());
   return root;
 }
 
-// internal entry point. yuku-analyzer layers scope replay via `hooks`
-// (enter returns a token passed to exit, which runs after the node is
-// handled, removal included) and a WalkContext subclass. exits are
-// skipped once stopped.
-export function _walk(root, visitors, state, hooks, ctx) {
+export function _walk(root, visitors, state, ctx) {
   const d = createDispatch(visitors);
   ctx.state = state;
   const ancestors = ctx._ancestors;
@@ -133,7 +129,6 @@ export function _walk(root, visitors, state, hooks, ctx) {
 
   (function visit(node, key, list, frame) {
     let typed = d.typed(node.type);
-    const token = hooks === null ? undefined : hooks.enter(node);
     const parent = ctx.parent;
 
     position(node, key, list, frame);
@@ -147,7 +142,6 @@ export function _walk(root, visitors, state, hooks, ctx) {
     }
     if (ctx._removed) {
       applyRemove(parent, key, list, frame);
-      if (hooks !== null) hooks.exit(token);
       return true;
     }
     if (ctx._replacement !== null) {
@@ -192,7 +186,6 @@ export function _walk(root, visitors, state, hooks, ctx) {
     if (ctx._removed) applyRemove(parent, key, list, frame);
     else if (ctx._replacement !== null) applyReplace(parent, key, list, frame);
 
-    if (hooks !== null) hooks.exit(token);
     return true;
   })(root, null, null, null);
 }

package/index.d.ts

@@ -17,7 +17,7 @@ import type {
   SourceLocation,
   SourceType,
   WalkContext as BaseWalkContext,
-} from "@yuku/types";
+} from "@yuku-toolchain/types";
 
 /** A diagnostic produced by {@link Analyzer.link}. */
 interface LinkDiagnostic {
@@ -412,6 +412,12 @@ interface Module {
   referenceOf(node: Node): Reference | null;
   /** The innermost scope whose extent contains `node`. */
   scopeOf(node: Node): Scope;
+  /**
+   * The node that structurally contains `node`. Null at the program
+   * root and for a node not part of this module's AST. Lets you walk
+   * upward from a node you already hold, with no ancestor stack.
+   */
+  parentOf(node: Node): Node | null;
   /**
    * Walks the scope chain from `from` (default: the root scope) to
    * find the nearest binding of `name`.

package/module.js

@@ -1,7 +1,5 @@
 // One analyzed file, the AST plus the scope/symbol/reference/import/
 // export object graph, built lazily over the decoded analyzer buffer.
-// All wire reads go through the generated `semantic` accessors from
-// decode.js. Nothing in this file knows the buffer layout.
 
 import binding from "./binding.js";
 import { decode, SymbolFlags } from "./decode.js";
@@ -268,8 +266,6 @@ export class Module {
   #symbolReferences = null;
   #declToSymbol = null;
   #nodeToReference = null;
-  #functionScopes = null;
-  #scopeMap = null;
   #exportMap = null;
   #starExports = null;
   #importBySymbol = null;
@@ -355,22 +351,18 @@ export class Module {
 
   scopeOf(node) {
     const index = this.#r.indexOf(node);
+    // a node inserted after analysis has no recorded scope
     if (index === undefined) return this.rootScope;
-    const start = this.#r.startOf(index);
-    const end = this.#r.endOf(index);
-    const { scope } = this.#sem;
-    let best = this.scopes[0];
-    let bestDepth = 0;
-    for (let i = 1; i < scope.count; i++) {
-      if (scope.start(i) > start || scope.end(i) < end) continue;
-      let depth = 0;
-      for (let p = i; p !== null; p = scope.parentId(p)) depth++;
-      if (depth > bestDepth) {
-        best = this.scopes[i];
-        bestDepth = depth;
-      }
-    }
-    return best;
+    return this.scopes[this.#sem.nodeScope(index)];
+  }
+
+  // the node that structurally contains `node`, or null at the program
+  // root or for a node not part of this module's AST.
+  parentOf(node) {
+    const index = this.#r.indexOf(node);
+    if (index === undefined) return null;
+    const parent = this.#r.parentIndex(index);
+    return parent < 0 ? null : this.#r.nodeOf(parent);
   }
 
   resolve(name, from = this.rootScope) {
@@ -403,9 +395,9 @@ export class Module {
   // the free variables of a function: every binding referenced inside
   // `fn` (nested functions included, value positions only) that is
   // declared outside its scope subtree, deduplicated by symbol with
-  // `isWritten` OR-ed across the references. only bindings count:
+  // `isWritten` OR-ed across the references. only bindings count.
   // `this`, `arguments`, and unresolved/global names carry no symbol
-  // and never appear; module-scope and import bindings count like any
+  // and never appear. module-scope and import bindings count like any
   // other outer binding. computed method keys evaluate in the enclosing
   // scope, outside the function node's span, so they are not captures.
   capturesOf(fn) {
@@ -413,13 +405,13 @@ export class Module {
     if (index === undefined) {
       throw new TypeError("capturesOf: node does not belong to this module's AST");
     }
-    const fnScopeId = this.#functionScopeOf(index);
-    if (fnScopeId === undefined) {
+    const { scope, symbol, reference } = this.#sem;
+    const fnScopeId = this.#sem.nodeScope(index);
+    if (scope.kind(fnScopeId) !== "function" || scope.nodeIndex(fnScopeId) !== index) {
       throw new TypeError("capturesOf: node does not create a function scope");
     }
     const start = this.#r.startOf(index);
     const end = this.#r.endOf(index);
-    const { scope, symbol, reference } = this.#sem;
     const captures = new Map();
     for (let i = 0; i < reference.count; i++) {
       const symbolId = reference.symbolId(i);
@@ -511,22 +503,6 @@ export class Module {
     return this.#symbolReferences[symbolId];
   }
 
-  // scope-creating node object -> innermost Scope (keep-last covers
-  // shared nodes, global/module on program, expression_name/function).
-  _scopeMap() {
-    if (this.#scopeMap === null) {
-      const byNode = new WeakMap();
-      const types = new Set();
-      for (const scope of this.scopes) {
-        const node = this.#sem.scope.node(scope.id);
-        byNode.set(node, scope);
-        types.add(node.type);
-      }
-      this.#scopeMap = { byNode, types };
-    }
-    return this.#scopeMap;
-  }
-
   // the spec's export-entry partition (ParseModule, 16.2.1.7.1): a
   // name-keyed map of the local + indirect entries and the star-entry
   // list (`export *` only). name-less records (`export *`, TS
@@ -591,21 +567,6 @@ export class Module {
     }
     return this.#nodeToReference;
   }
-
-  // node index -> the function scope it creates. named function
-  // expressions share the node with their expression_name scope. the
-  // function scope has the higher id, so keep-last wins.
-  #functionScopeOf(nodeIndex) {
-    if (this.#functionScopes === null) {
-      const map = new Map();
-      const { scope } = this.#sem;
-      for (let i = 0; i < scope.count; i++) {
-        if (scope.kind(i) === "function") map.set(scope.nodeIndex(i), i);
-      }
-      this.#functionScopes = map;
-    }
-    return this.#functionScopes.get(nodeIndex);
-  }
 }
 
 export { SymbolFlags };

package/package.json

@@ -1,27 +1,15 @@
 {
   "name": "yuku-analyzer",
-  "version": "0.5.32",
+  "version": "0.5.36",
   "description": "High-performance JavaScript/TypeScript semantic analyzer: per-file scopes, symbols, references, and cross-file module linking",
-  "keywords": [
-    "analyzer",
-    "ast",
-    "bindings",
-    "compiler",
-    "cross-file",
-    "javascript",
-    "linker",
-    "module-graph",
-    "references",
-    "scope",
-    "semantic",
-    "symbols",
-    "typescript"
-  ],
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "https://github.com/yuku-toolchain/yuku"
   },
+  "type": "module",
+  "main": "index.js",
+  "types": "index.d.ts",
   "files": [
     "index.js",
     "index.d.ts",
@@ -32,23 +20,35 @@
     "binding.js",
     "decode.js"
   ],
-  "type": "module",
-  "main": "index.js",
-  "types": "index.d.ts",
-  "dependencies": {
-    "@yuku/types": "workspace:*"
-  },
   "optionalDependencies": {
-    "@yuku-analyzer/binding-darwin-arm64": "0.5.32",
-    "@yuku-analyzer/binding-darwin-x64": "0.5.32",
-    "@yuku-analyzer/binding-freebsd-x64": "0.5.32",
-    "@yuku-analyzer/binding-linux-arm-gnu": "0.5.32",
-    "@yuku-analyzer/binding-linux-arm-musl": "0.5.32",
-    "@yuku-analyzer/binding-linux-arm64-gnu": "0.5.32",
-    "@yuku-analyzer/binding-linux-arm64-musl": "0.5.32",
-    "@yuku-analyzer/binding-linux-x64-gnu": "0.5.32",
-    "@yuku-analyzer/binding-linux-x64-musl": "0.5.32",
-    "@yuku-analyzer/binding-win32-arm64": "0.5.32",
-    "@yuku-analyzer/binding-win32-x64": "0.5.32"
+    "@yuku-analyzer/binding-linux-x64-gnu": "0.5.36",
+    "@yuku-analyzer/binding-linux-arm64-gnu": "0.5.36",
+    "@yuku-analyzer/binding-linux-arm-gnu": "0.5.36",
+    "@yuku-analyzer/binding-linux-x64-musl": "0.5.36",
+    "@yuku-analyzer/binding-linux-arm64-musl": "0.5.36",
+    "@yuku-analyzer/binding-linux-arm-musl": "0.5.36",
+    "@yuku-analyzer/binding-darwin-x64": "0.5.36",
+    "@yuku-analyzer/binding-darwin-arm64": "0.5.36",
+    "@yuku-analyzer/binding-win32-x64": "0.5.36",
+    "@yuku-analyzer/binding-win32-arm64": "0.5.36",
+    "@yuku-analyzer/binding-freebsd-x64": "0.5.36"
+  },
+  "keywords": [
+    "analyzer",
+    "ast",
+    "bindings",
+    "compiler",
+    "cross-file",
+    "javascript",
+    "linker",
+    "module-graph",
+    "references",
+    "scope",
+    "semantic",
+    "symbols",
+    "typescript"
+  ],
+  "dependencies": {
+    "@yuku-toolchain/types": "0.5.32"
   }
 }

package/walk.js

@@ -2,17 +2,15 @@ import { WalkContext, _walk } from "./engine.js";
 
 class SemanticWalkContext extends WalkContext {
   #module;
-  #scopes;
-  constructor(module, scopes) {
+  constructor(module) {
     super();
     this.#module = module;
-    this.#scopes = scopes;
   }
   get module() {
     return this.#module;
   }
   get scope() {
-    return this.#scopes[this.#scopes.length - 1];
+    return this.#module.scopeOf(this._node);
   }
   get symbol() {
     return this.#module.symbolOf(this._node);
@@ -23,21 +21,5 @@ class SemanticWalkContext extends WalkContext {
 }
 
 export function walkModule(module, visitors, root) {
-  const { byNode, types } = module._scopeMap();
-  const start = root ?? module.ast;
-  const scopes = [module.scopeOf(start)];
-  const hooks = {
-    // the scope was created for the original node. a replacement keeps
-    // the same lexical position, so push/pop stays balanced on it
-    enter(node) {
-      const scope = types.has(node.type) ? byNode.get(node) : undefined;
-      if (scope === undefined) return false;
-      scopes.push(scope);
-      return true;
-    },
-    exit(pushed) {
-      if (pushed) scopes.pop();
-    },
-  };
-  _walk(start, visitors, undefined, hooks, new SemanticWalkContext(module, scopes));
+  _walk(root ?? module.ast, visitors, undefined, new SemanticWalkContext(module));
 }