init

node_modules/estree-util-scope/lib/index.js

@@ -0,0 +1,196 @@
+/**
+ * @import {Node, Pattern} from 'estree'
+ * @import {Scope, Visitors} from './types.js'
+ */
+
+import {ok as assert} from 'devlop'
+
+/**
+ * Create state to track what’s defined.
+ *
+ * @returns {Visitors}
+ *   State.
+ */
+export function createVisitors() {
+  /** @type {[topLevel: Scope, ...rest: Array<Scope>]} */
+  const scopes = [{block: false, defined: []}]
+
+  return {enter, exit, scopes}
+
+  /**
+   * @param {Node} node
+   *   Node.
+   * @returns {undefined}
+   *   Nothing.
+   */
+  function enter(node) {
+    // On arrow functions, create scope, add parameters.
+    if (node.type === 'ArrowFunctionExpression') {
+      scopes.push({block: false, defined: []})
+
+      for (const parameter of node.params) {
+        definePattern(parameter, false)
+      }
+    }
+    // On block statements, create scope.
+    // Not sure why `periscopic` only does `Block`/`For`/`ForIn`/`ForOf`.
+    // I added `DoWhile`/`While` here just to be sure.
+    else if (
+      node.type === 'BlockStatement' ||
+      node.type === 'DoWhileStatement' ||
+      node.type === 'ForInStatement' ||
+      node.type === 'ForOfStatement' ||
+      node.type === 'ForStatement' ||
+      node.type === 'WhileStatement'
+    ) {
+      scopes.push({block: true, defined: []})
+    }
+
+    // On catch clauses, create scope, add param.
+    else if (node.type === 'CatchClause') {
+      scopes.push({block: true, defined: []})
+      if (node.param) definePattern(node.param, true)
+    }
+
+    // Add identifier of class declaration.
+    else if (node.type === 'ClassDeclaration') {
+      defineIdentifier(node.id.name, false)
+    }
+
+    // On function declarations, add name, create scope, add parameters.
+    else if (node.type === 'FunctionDeclaration') {
+      defineIdentifier(node.id.name, false)
+      scopes.push({block: false, defined: []})
+
+      for (const parameter of node.params) {
+        definePattern(parameter, false)
+      }
+    }
+
+    // On function expressions, add name, create scope, add parameters.
+    else if (node.type === 'FunctionExpression') {
+      if (node.id) defineIdentifier(node.id.name, false)
+      scopes.push({block: false, defined: []})
+
+      for (const parameter of node.params) {
+        definePattern(parameter, false)
+      }
+    }
+
+    // Add specifiers of import declarations.
+    else if (node.type === 'ImportDeclaration') {
+      for (const specifier of node.specifiers) {
+        defineIdentifier(specifier.local.name, false)
+      }
+    }
+
+    // Add patterns of variable declarations.
+    else if (node.type === 'VariableDeclaration') {
+      for (const declaration of node.declarations) {
+        definePattern(declaration.id, node.kind !== 'var')
+      }
+    }
+  }
+
+  /**
+   * @param {Node} node
+   *   Node.
+   * @returns {undefined}
+   *   Nothing.
+   */
+  function exit(node) {
+    if (
+      node.type === 'ArrowFunctionExpression' ||
+      node.type === 'FunctionDeclaration' ||
+      node.type === 'FunctionExpression'
+    ) {
+      const scope = scopes.pop()
+      assert(scope, 'expected scope')
+      assert(!scope.block, 'expected non-block')
+    } else if (
+      node.type === 'BlockStatement' ||
+      node.type === 'CatchClause' ||
+      node.type === 'DoWhileStatement' ||
+      node.type === 'ForInStatement' ||
+      node.type === 'ForOfStatement' ||
+      node.type === 'ForStatement' ||
+      node.type === 'WhileStatement'
+    ) {
+      const scope = scopes.pop()
+      assert(scope, 'expected scope')
+      assert(scope.block, 'expected block')
+    }
+  }
+
+  /**
+   * Define an identifier in a scope.
+   *
+   * @param {string} id
+   * @param {boolean} block
+   * @returns {undefined}
+   */
+  function defineIdentifier(id, block) {
+    let index = scopes.length
+    /** @type {Scope | undefined} */
+    let scope
+
+    while (index--) {
+      scope = scopes[index]
+
+      if (block || !scope.block) {
+        break
+      }
+    }
+
+    assert(scope)
+    scope.defined.push(id)
+  }
+
+  /**
+   * Define a pattern in a scope.
+   *
+   * @param {Pattern} pattern
+   * @param {boolean} block
+   */
+  function definePattern(pattern, block) {
+    // `[, x]`
+    if (pattern.type === 'ArrayPattern') {
+      for (const element of pattern.elements) {
+        if (element) {
+          definePattern(element, block)
+        }
+      }
+    }
+
+    // `{x=y}`
+    else if (pattern.type === 'AssignmentPattern') {
+      definePattern(pattern.left, block)
+    }
+
+    // `x`
+    else if (pattern.type === 'Identifier') {
+      defineIdentifier(pattern.name, block)
+    }
+
+    // `{x}`
+    else if (pattern.type === 'ObjectPattern') {
+      for (const property of pattern.properties) {
+        // `{key}`, `{key = value}`, `{key: value}`
+        if (property.type === 'Property') {
+          definePattern(property.value, block)
+        }
+        // `{...x}`
+        else {
+          assert(property.type === 'RestElement')
+          definePattern(property, block)
+        }
+      }
+    }
+
+    // `...x`
+    else {
+      assert(pattern.type === 'RestElement')
+      definePattern(pattern.argument, block)
+    }
+  }
+}