flow-parser 0.318.0 → 0.320.0

package/oxidized/oxidized-src/utils/Builders.js

@@ -0,0 +1,181 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EMPTY_PARENT = void 0;
+exports.callExpression = callExpression;
+exports.conjunction = conjunction;
+exports.createDefaultPosition = createDefaultPosition;
+exports.disjunction = disjunction;
+exports.etc = etc;
+exports.ident = ident;
+exports.iife = iife;
+exports.nullLiteral = nullLiteral;
+exports.numberLiteral = numberLiteral;
+exports.stringLiteral = stringLiteral;
+exports.throwStatement = throwStatement;
+exports.typeofExpression = typeofExpression;
+exports.variableDeclaration = variableDeclaration;
+const EMPTY_PARENT = null;
+exports.EMPTY_PARENT = EMPTY_PARENT;
+
+function createDefaultPosition() {
+  return {
+    line: 1,
+    column: 0
+  };
+}
+
+function etc({
+  loc,
+  range,
+  parent
+} = {}) {
+  return {
+    loc: {
+      start: (loc == null ? void 0 : loc.start) != null ? loc.start : createDefaultPosition(),
+      end: (loc == null ? void 0 : loc.end) != null ? loc.end : createDefaultPosition()
+    },
+    range: range != null ? range : [0, 0],
+    parent: parent != null ? parent : EMPTY_PARENT
+  };
+}
+
+function ident(name, info) {
+  return {
+    type: 'Identifier',
+    name,
+    optional: false,
+    typeAnnotation: null,
+    ...etc(info)
+  };
+}
+
+function stringLiteral(value, info) {
+  return {
+    type: 'Literal',
+    value,
+    raw: `"${value}"`,
+    literalType: 'string',
+    ...etc(info)
+  };
+}
+
+function numberLiteral(value, info) {
+  return {
+    type: 'Literal',
+    value,
+    raw: String(value),
+    literalType: 'numeric',
+    ...etc(info)
+  };
+}
+
+function nullLiteral(info) {
+  return {
+    type: 'Literal',
+    value: null,
+    raw: 'null',
+    literalType: 'null',
+    ...etc(info)
+  };
+}
+
+function conjunction(tests) {
+  if (tests.length === 0) {
+    throw new Error('Must have at least one test.');
+  }
+
+  return tests.reduce((acc, test) => ({
+    type: 'LogicalExpression',
+    left: acc,
+    right: test,
+    operator: '&&',
+    ...etc()
+  }));
+}
+
+function disjunction(tests) {
+  if (tests.length === 0) {
+    throw new Error('Must have at least one test.');
+  }
+
+  return tests.reduce((acc, test) => ({
+    type: 'LogicalExpression',
+    left: acc,
+    right: test,
+    operator: '||',
+    ...etc()
+  }));
+}
+
+function variableDeclaration(kind, id, init, info) {
+  return {
+    type: 'VariableDeclaration',
+    kind,
+    declarations: [{
+      type: 'VariableDeclarator',
+      init,
+      id,
+      ...etc(),
+      parent: EMPTY_PARENT
+    }],
+    ...etc(info)
+  };
+}
+
+function callExpression(callee, args, info) {
+  return {
+    type: 'CallExpression',
+    callee,
+    arguments: args,
+    typeArguments: null,
+    optional: false,
+    ...etc(info)
+  };
+}
+
+function throwStatement(arg, info) {
+  return {
+    type: 'ThrowStatement',
+    argument: callExpression(ident('Error'), [arg]),
+    ...etc(info)
+  };
+}
+
+function iife(statements, params = [], args = []) {
+  const callee = {
+    type: 'ArrowFunctionExpression',
+    params,
+    expression: false,
+    async: false,
+    predicate: null,
+    returnType: null,
+    typeParameters: null,
+    id: null,
+    body: {
+      type: 'BlockStatement',
+      body: statements,
+      ...etc()
+    },
+    ...etc()
+  };
+  return callExpression(callee, args);
+}
+
+function typeofExpression(arg, kind) {
+  return {
+    type: 'BinaryExpression',
+    left: {
+      type: 'UnaryExpression',
+      operator: 'typeof',
+      argument: arg,
+      prefix: true,
+      ...etc()
+    },
+    right: stringLiteral(kind),
+    operator: '===',
+    ...etc()
+  };
+}

package/oxidized/oxidized-src/utils/GenID.js

@@ -0,0 +1,37 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+const genPrefix = '$$gen$';
+
+class GenID {
+  constructor(uniqueTransformPrefix) {
+    this.genN = 0;
+    this.used = new Set();
+    this.prefix = void 0;
+    this.prefix = `${genPrefix}${uniqueTransformPrefix}`;
+  }
+
+  id() {
+    let name;
+
+    do {
+      name = `${this.prefix}${this.genN}`;
+      this.genN++;
+    } while (this.used.has(name));
+
+    this.used.add(name);
+    return name;
+  }
+
+  addUsage(name) {
+    if (name.startsWith(this.prefix)) {
+      this.used.add(name);
+    }
+  }
+
+}
+
+exports.default = GenID;

package/oxidized/oxidized-src/utils/createSyntaxError.js

@@ -0,0 +1,15 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSyntaxError = createSyntaxError;
+
+function createSyntaxError(node, err) {
+  const syntaxError = new SyntaxError(err);
+  syntaxError.loc = {
+    line: node.loc.start.line,
+    column: node.loc.start.column
+  };
+  return syntaxError;
+}

package/oxidized/oxidized-src/utils/isReservedWord.js

@@ -0,0 +1,53 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isReservedWord;
+
+function isReservedWord(name) {
+  switch (name) {
+    case 'await':
+    case 'break':
+    case 'case':
+    case 'catch':
+    case 'class':
+    case 'const':
+    case 'continue':
+    case 'debugger':
+    case 'default':
+    case 'delete':
+    case 'do':
+    case 'else':
+    case 'enum':
+    case 'export':
+    case 'extends':
+    case 'false':
+    case 'finally':
+    case 'for':
+    case 'function':
+    case 'if':
+    case 'import':
+    case 'in':
+    case 'instanceof':
+    case 'new':
+    case 'null':
+    case 'return':
+    case 'super':
+    case 'switch':
+    case 'this':
+    case 'throw':
+    case 'true':
+    case 'try':
+    case 'typeof':
+    case 'var':
+    case 'void':
+    case 'while':
+    case 'with':
+    case 'yield':
+      return true;
+
+    default:
+      return false;
+  }
+}

package/oxidized/oxidized-src/utils/mutateESTreeASTForPrettier.js

@@ -0,0 +1,85 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = mutate;
+
+var _SimpleTransform = require("../transform/SimpleTransform");
+
+function transformChainExpression(node, comments) {
+  if (comments != null) {
+    var _node$comments;
+
+    const joinedComments = comments.concat((_node$comments = node.comments) != null ? _node$comments : []);
+    node.comments = joinedComments;
+  }
+
+  switch (node.type) {
+    case 'CallExpression':
+      return { ...node,
+        type: 'OptionalCallExpression',
+        callee: transformChainExpression(node.callee)
+      };
+
+    case 'MemberExpression':
+      return { ...node,
+        type: 'OptionalMemberExpression',
+        object: transformChainExpression(node.object)
+      };
+  }
+
+  return node;
+}
+
+function mutate(rootNode, visitorKeys) {
+  _SimpleTransform.SimpleTransform.transform(rootNode, {
+    transform(node) {
+      if (node.parent) {
+        delete node.parent;
+      }
+
+      if (node.type === 'ChainExpression') {
+        return transformChainExpression(node.expression, node == null ? void 0 : node.comments);
+      }
+
+      if (node.type === 'ObjectTypeProperty') {
+        if (node.method === false && node.kind === 'init' && node.range[0] === 1 && node.value.range[0] === 1) {
+          node.value = { ...node.value,
+            range: [2, node.value.range[1]]
+          };
+        }
+
+        return node;
+      }
+
+      if (node.type === 'ImportSpecifier') {
+        if (node.local.name === node.imported.name) {
+          if (node.local.range == null) {
+            node.local.range = [0, 0];
+          }
+
+          node.imported.range = [...node.local.range];
+        }
+
+        return node;
+      }
+
+      if (node.type === 'ExportSpecifier') {
+        if (node.local.name === node.exported.name) {
+          if (node.local.range == null) {
+            node.local.range = [0, 0];
+          }
+
+          node.exported.range = [...node.local.range];
+        }
+
+        return node;
+      }
+
+      return node;
+    },
+
+    visitorKeys
+  });
+}

package/oxidized/transform/SimpleTransform.js

@@ -0,0 +1,95 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SimpleTransform = void 0;
+
+var _SimpleTraverser = require("../traverse/SimpleTraverser");
+
+var _astNodeMutationHelpers = require("./astNodeMutationHelpers");
+
+function setParentPointer(node, parent) {
+  if (parent != null) {
+    if (Array.isArray(node)) {
+      for (const item of node) {
+        item.parent = parent;
+      }
+    } else {
+      node.parent = parent;
+    }
+  }
+}
+
+class SimpleTransform {
+  transform(rootNode, options) {
+    let resultRootNode = rootNode;
+
+    _SimpleTraverser.SimpleTraverser.traverse(rootNode, {
+      enter: (node, parent) => {
+        setParentPointer(node, parent);
+        const resultNode = options.transform(node);
+
+        if (resultNode !== node) {
+          let traversedResultNode = null;
+
+          if (resultNode != null) {
+            setParentPointer(resultNode, parent);
+
+            if (Array.isArray(resultNode)) {
+              traversedResultNode = resultNode.map(item => this.transform(item, options)).filter(item => item != null);
+            } else {
+              traversedResultNode = this.transform(resultNode, options);
+            }
+          }
+
+          if (parent == null) {
+            if (node !== rootNode) {
+              throw new Error('SimpleTransform infra error: Parent not set on non root node, this should not be possible');
+            }
+
+            if (Array.isArray(traversedResultNode)) {
+              throw new Error('SimpleTransform: invalid array result for root node');
+            } else {
+              resultRootNode = traversedResultNode;
+            }
+          } else if (traversedResultNode == null) {
+            (0, _astNodeMutationHelpers.removeNodeOnParent)(node, parent, options.visitorKeys);
+          } else {
+            (0, _astNodeMutationHelpers.replaceNodeOnParent)(node, parent, traversedResultNode, options.visitorKeys);
+            setParentPointer(traversedResultNode, parent);
+          }
+
+          throw _SimpleTraverser.SimpleTraverser.Skip;
+        }
+      },
+
+      leave(_node) {},
+
+      visitorKeys: options.visitorKeys
+    });
+
+    return resultRootNode;
+  }
+
+  static transform(node, options) {
+    return new SimpleTransform().transform(node, options);
+  }
+
+  static transformProgram(program, options) {
+    const result = SimpleTransform.transform(program, options);
+
+    if ((result == null ? void 0 : result.type) === 'Program') {
+      return result;
+    }
+
+    throw new Error('SimpleTransform.transformProgram: Expected program node.');
+  }
+
+  static nodeWith(node, overrideProps, visitorKeys) {
+    return (0, _astNodeMutationHelpers.nodeWith)(node, overrideProps, visitorKeys);
+  }
+
+}
+
+exports.SimpleTransform = SimpleTransform;

package/oxidized/transform/SimpleTransform.js.flow

@@ -0,0 +1,168 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict
+ * @format
+ */
+
+'use strict';
+
+import type {VisitorKeysType} from '../traverse/getVisitorKeys';
+import type {ESNode, Program} from 'flow-estree';
+
+import {SimpleTraverser} from '../traverse/SimpleTraverser';
+import {
+  nodeWith,
+  removeNodeOnParent,
+  replaceNodeOnParent,
+} from './astNodeMutationHelpers';
+
+/**
+ * Transform callback
+ * @param node The node we are visiting
+ * @returns
+ *   - return input node, signals no changes were made will continue to the next node.
+ *   - return new node, the old node will be replaced in the AST. The new node and its
+ *     children are then traversed.
+ *   - return null, signals the node should be deleted from the AST.
+ */
+export type TransformCallback = (
+  node: ESNode,
+) => ESNode | ReadonlyArray<ESNode> | null;
+
+export type TransformOptions = Readonly<{
+  /** The callback function which is called on entering each node. */
+  transform: TransformCallback,
+
+  /** The set of visitor keys to use for traversal. Defaults to the Flow ESTree visitor keys */
+  visitorKeys?: ?VisitorKeysType,
+}>;
+
+function setParentPointer(
+  node: ESNode | ReadonlyArray<ESNode>,
+  parent: ?ESNode,
+): void {
+  if (parent != null) {
+    if (Array.isArray(node)) {
+      for (const item of node) {
+        // $FlowExpectedError[cannot-write]
+        item.parent = parent;
+      }
+    } else {
+      // $FlowExpectedError[cannot-write]
+      node.parent = parent;
+    }
+  }
+}
+
+/**
+ * A simple class to recursively tranform AST trees.
+ */
+export class SimpleTransform {
+  /**
+   * Transform the given AST tree.
+   * @param rootNode The root node to traverse.
+   * @param options The option object.
+   * @return The modified rootNode or a new node if the rootNode was transformed directly.
+   */
+  transform(rootNode: ESNode, options: TransformOptions): ESNode | null {
+    let resultRootNode: ESNode | null = rootNode;
+    SimpleTraverser.traverse(rootNode, {
+      enter: (node: ESNode, parent: ?ESNode) => {
+        // Ensure the parent pointers are correctly set before entering the node.
+        setParentPointer(node, parent);
+
+        const resultNode: ESNode | ReadonlyArray<ESNode> | null =
+          options.transform(node);
+        if (resultNode !== node) {
+          let traversedResultNode: ESNode | ReadonlyArray<ESNode> | null = null;
+
+          if (resultNode != null) {
+            // Ensure the new node has the correct parent pointers before recursing again.
+            setParentPointer(resultNode, parent);
+
+            if (Array.isArray(resultNode)) {
+              traversedResultNode = resultNode
+                .map(item => this.transform(item, options))
+                .filter(item => item != null);
+            } else {
+              traversedResultNode = this.transform(resultNode, options);
+            }
+          }
+
+          if (parent == null) {
+            if (node !== rootNode) {
+              throw new Error(
+                'SimpleTransform infra error: Parent not set on non root node, this should not be possible',
+              );
+            }
+            if (Array.isArray(traversedResultNode)) {
+              throw new Error(
+                'SimpleTransform: invalid array result for root node',
+              );
+            } else {
+              resultRootNode = traversedResultNode;
+            }
+          } else if (traversedResultNode == null) {
+            removeNodeOnParent(node, parent, options.visitorKeys);
+          } else {
+            replaceNodeOnParent(
+              node,
+              parent,
+              traversedResultNode,
+              options.visitorKeys,
+            );
+            setParentPointer(traversedResultNode, parent);
+          }
+
+          throw SimpleTraverser.Skip;
+        }
+      },
+      leave(_node: ESNode) {},
+      visitorKeys: options.visitorKeys,
+    });
+    return resultRootNode;
+  }
+
+  /**
+   * Transform the given AST tree.
+   * @param node The root node to traverse.
+   * @param options The option object.
+   */
+  static transform(node: ESNode, options: TransformOptions): ESNode | null {
+    return new SimpleTransform().transform(node, options);
+  }
+
+  static transformProgram(
+    program: Program,
+    options: TransformOptions,
+  ): Program {
+    const result = SimpleTransform.transform(program, options);
+    if (result?.type === 'Program') {
+      return result;
+    }
+    throw new Error('SimpleTransform.transformProgram: Expected program node.');
+  }
+
+  /**
+   * Return a new AST node with the given properties overrided if needed.
+   *
+   * This function takes care to only create new nodes when needed. Referential equality of nodes
+   * is important as its used to know if a node should be re-traversed.
+   *
+   * @param node The base AST node.
+   * @param overrideProps New properties to apply to the node.
+   * @return Either the orginal node if the properties matched the existing node or a new node with
+   *         the new properties.
+   */
+  static nodeWith<T: ESNode>(
+    node: T,
+    overrideProps: Partial<T>,
+    visitorKeys?: VisitorKeysType,
+  ): T {
+    return nodeWith<T>(node, overrideProps, visitorKeys);
+  }
+}

package/oxidized/transform/astArrayMutationHelpers.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.arrayIsEqual = arrayIsEqual;
+exports.insertInArray = insertInArray;
+exports.removeFromArray = removeFromArray;
+exports.replaceInArray = replaceInArray;
+
+function assertArrayBounds(array, index) {
+  if (index < 0 || index >= array.length) {
+    throw new Error(`Invalid Mutation: Tried to mutate an elements array with an out of bounds index. Index: ${index}, Array Size: ${array.length}`);
+  }
+}
+
+function arrayIsEqual(a1, a2) {
+  if (a1 === a2) {
+    return true;
+  }
+
+  if (a1.length !== a2.length) {
+    return false;
+  }
+
+  for (let i = 0; i < a1.length; i++) {
+    if (a1[i] !== a2[i]) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+function insertInArray(array, index, elements) {
+  if (index === array.length) {
+    return array.concat(elements);
+  }
+
+  assertArrayBounds(array, index);
+  return array.slice(0, index).concat(elements).concat(array.slice(index));
+}
+
+function removeFromArray(array, index) {
+  assertArrayBounds(array, index);
+  return [...array.slice(0, index), ...array.slice(index + 1)];
+}
+
+function replaceInArray(array, index, elements) {
+  assertArrayBounds(array, index);
+  return array.slice(0, index).concat(elements).concat(array.slice(index + 1));
+}