Extracts, guards, and queries

Author: SleeplessByte

CHANGELOG.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## 0.2.0
+
+- Add Traverser (with support for `break/stop` and `skip/shallow`)
+- Add guards:
+  - `isAssignmentPattern`
+  - `isBinaryExpression`
+  - `isCallExpression`
+  - `isIdentifier`
+  - `isLiteral`
+  - `isLogicalExpression`
+  - `isMemberExpression`
+  - `isReturnBlockStatement`
+  - `isTemplateLiteral`
+  - `isUnaryExpression`
+  - `isVariableDeclarationOfKind`
+- Add queries:
+  - `findAll`
+  - `findFirstOfType`
+  - `findFirst`
+  - `findLiteral`
+  - `findMemberCall`
+  - `findNewExpression`
+  - `findRawLiteral`
+  - `findTopLevelConstant`
+- Add extracts:
+  - `extractExports`
+  - `extractVariables`
+
 ## 0.1.0
 
 Initial release

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exercism/static-analysis",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Exercism static analysis library for javascript and typescript",
   "repository": "https://github.com/SleeplessByte/exercism-static-analysis",
   "author": "Derk-Jan Karrenbeld <[email protected]>",
@@ -10,7 +10,7 @@
     "build": "yarn build:code && yarn build:types",
     "build:code": "yarn babel src --out-dir dist --extensions .ts",
     "build:types": "tsc --declaration --emitDeclarationOnly --outDir dist",
-    "prepublish": "yarn test",
+    "prepublish": "yarn test && yarn build",
     "lint": "yarn eslint . --ext ts,js,tsx,jsx,mjs",
     "test": "jest"
   },

src/AstParser.ts

@@ -71,9 +71,36 @@ export class ParsedSource {
   ) {}
 }
 
+const DEFAULT_PARSE_OPTIONS: ParseOptions = {
+  comment: false,
+  loc: false,
+}
+
 export class AstParser {
+  /**
+   * Holds a parser that is recommended for representing. This means that it
+   * does not hold locational information (where differences are caused by
+   * whitespace differences) or commentary.
+   */
+  public static REPRESENTER: AstParser = new AstParser({
+    comment: false,
+    loc: false,
+    range: false,
+  })
+
+  /**
+   * Holds a parser that is recommended for analysis. This means that it dóés
+   * hold locational information (in order to be able to extract tokens), but
+   * does not hold any commentary.
+   */
+  public static ANALYZER: AstParser = new AstParser({
+    comment: false,
+    loc: true,
+    range: true,
+  })
+
   constructor(
-    private readonly options?: ParseOptions,
+    private readonly options: ParseOptions = DEFAULT_PARSE_OPTIONS,
     private readonly n = 1
   ) {}
 

src/AstTraverser.ts

@@ -0,0 +1,120 @@
+import { visitorKeys } from '@typescript-eslint/visitor-keys'
+import { TSESTree } from '@typescript-eslint/typescript-estree'
+
+type Node = TSESTree.Node
+
+function isValidNode(x: unknown): x is Node {
+  return (
+    typeof x === 'object' &&
+    x !== null &&
+    Object.prototype.hasOwnProperty.call(x, 'type') &&
+    typeof (x as { type: unknown }).type === 'string'
+  )
+}
+
+function getVisitorKeysForNode(
+  allVisitorKeys: typeof visitorKeys,
+  node: Node
+): readonly (keyof Node)[] {
+  const keys = allVisitorKeys[node.type]
+  return (keys ?? []) as never
+}
+
+type TraverseOptions = {
+  [key: string]: (
+    this: AstTraverser,
+    node: Node,
+    parent: Node | undefined
+  ) => void
+} & Partial<{
+  enter: (this: AstTraverser, node: Node, parent: Node | undefined) => void
+  exit: (this: AstTraverser, node: Node, parent: Node | undefined) => void
+}>
+
+export class AstTraverser {
+  private readonly allVisitorKeys = visitorKeys
+  private readonly selectors: TraverseOptions
+  private readonly setParentPointers: boolean
+  private stopped: boolean
+  private skipped: boolean
+
+  constructor(selectors: TraverseOptions, setParentPointers = false) {
+    this.selectors = selectors
+    this.setParentPointers = setParentPointers
+    this.stopped = false
+    this.skipped = false
+  }
+
+  public break(): void {
+    this.stopped = true
+  }
+
+  public skip(): void {
+    this.skipped = true
+  }
+
+  public traverse(
+    node: unknown,
+    parent?: TSESTree.Node | undefined,
+    skipChildren = false
+  ): void {
+    if (!isValidNode(node)) {
+      return
+    }
+
+    if (parent === undefined) {
+      this.stopped = false
+    }
+
+    if (this.setParentPointers) {
+      node.parent = parent
+    }
+
+    const { enter, exit, [node.type]: onSelector } = this.selectors
+
+    this.skipped = false
+
+    if (enter) {
+      enter.call(this, node, parent)
+    }
+
+    if (onSelector) {
+      onSelector.call(this, node, parent)
+    }
+
+    if (this.stopped) {
+      return
+    }
+
+    if (!skipChildren && !this.skipped) {
+      const keys = getVisitorKeysForNode(this.allVisitorKeys, node)
+
+      for (const key of keys) {
+        const childOrChildren = node[key]
+        const children = Array.isArray(childOrChildren)
+          ? childOrChildren
+          : [childOrChildren]
+
+        for (const child of children) {
+          if (this.stopped) {
+            return
+          }
+
+          this.traverse(child, node, this.skipped)
+        }
+      }
+    }
+
+    if (this.stopped) {
+      return
+    }
+
+    if (exit) {
+      exit.call(this, node, parent)
+    }
+  }
+}
+
+export function traverse(root: Node, options: TraverseOptions): void {
+  return new AstTraverser(options).traverse(root)
+}