flow-parser 0.319.0 → 0.321.0

package/oxidized/oxidized-src/estree/TransformRecordSyntax.js

@@ -1,283 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.transformProgram = transformProgram;
-
-var _flowEstree = require("flow-estree");
-
-var _SimpleTransform = require("../transform/SimpleTransform");
-
-var _astNodeMutationHelpers = require("../transform/astNodeMutationHelpers");
-
-var _Builders = require("../utils/Builders");
-
-var _isReservedWord = _interopRequireDefault(require("../utils/isReservedWord"));
-
-var _GenID = _interopRequireDefault(require("../utils/GenID"));
-
-function _interopRequireDefault(obj) {
-  return obj && obj.__esModule ? obj : {
-    default: obj
-  };
-}
-
-function nameOfKey(key) {
-  switch (key.type) {
-    case 'Identifier':
-      return key.name;
-
-    case 'Literal':
-      if ((0, _flowEstree.isBigIntLiteral)(key)) {
-        return key.bigint;
-      }
-
-      return String(key.value);
-  }
-}
-
-function mapRecordDeclaration(genID, node) {
-  const ownProperties = [];
-  const staticProperties = [];
-  const methods = [];
-  const staticMethods = [];
-
-  for (const element of node.body.elements) {
-    switch (element.type) {
-      case 'RecordDeclarationProperty':
-        ownProperties.push(element);
-        break;
-
-      case 'RecordDeclarationStaticProperty':
-        staticProperties.push(element);
-        break;
-
-      case 'MethodDefinition':
-        if (element.static) {
-          staticMethods.push(element);
-        } else {
-          methods.push(element);
-        }
-
-        break;
-    }
-  }
-
-  const reservedPropNames = new Map();
-  const constructorParam = {
-    type: 'ObjectPattern',
-    properties: ownProperties.map(prop => {
-      const {
-        key,
-        defaultValue
-      } = prop;
-      const keyName = nameOfKey(key);
-
-      const getValue = bindingIdent => defaultValue != null ? {
-        type: 'AssignmentPattern',
-        left: bindingIdent,
-        right: (0, _astNodeMutationHelpers.deepCloneNode)(defaultValue),
-        ...(0, _Builders.etc)()
-      } : bindingIdent;
-
-      switch (key.type) {
-        case 'Identifier':
-          {
-            const needsNewBinding = (0, _isReservedWord.default)(keyName);
-            const bindingName = needsNewBinding ? genID.id() : keyName;
-            const bindingIdent = (0, _Builders.ident)(bindingName);
-
-            if (needsNewBinding) {
-              reservedPropNames.set(keyName, bindingName);
-            }
-
-            if (needsNewBinding) {
-              return {
-                type: 'Property',
-                kind: 'init',
-                key: (0, _astNodeMutationHelpers.shallowCloneNode)(key),
-                value: getValue(bindingIdent),
-                shorthand: false,
-                method: false,
-                computed: false,
-                ...(0, _Builders.etc)(),
-                parent: _Builders.EMPTY_PARENT
-              };
-            } else {
-              return {
-                type: 'Property',
-                kind: 'init',
-                key: (0, _astNodeMutationHelpers.shallowCloneNode)(key),
-                value: getValue(bindingIdent),
-                shorthand: true,
-                method: false,
-                computed: false,
-                ...(0, _Builders.etc)(),
-                parent: _Builders.EMPTY_PARENT
-              };
-            }
-          }
-
-        case 'Literal':
-          {
-            const bindingName = genID.id();
-            const bindingIdent = (0, _Builders.ident)(bindingName);
-            reservedPropNames.set(keyName, bindingName);
-            return {
-              type: 'Property',
-              kind: 'init',
-              key: (0, _astNodeMutationHelpers.shallowCloneNode)(key),
-              value: getValue(bindingIdent),
-              shorthand: false,
-              method: false,
-              computed: false,
-              ...(0, _Builders.etc)(),
-              parent: _Builders.EMPTY_PARENT
-            };
-          }
-      }
-    }),
-    typeAnnotation: null,
-    ...(0, _Builders.etc)()
-  };
-  const constructor = {
-    type: 'MethodDefinition',
-    key: (0, _Builders.ident)('constructor'),
-    kind: 'constructor',
-    computed: false,
-    static: false,
-    decorators: [],
-    value: {
-      type: 'FunctionExpression',
-      id: null,
-      params: [constructorParam],
-      body: {
-        type: 'BlockStatement',
-        body: ownProperties.map(({
-          key
-        }) => {
-          var _reservedPropNames$ge;
-
-          const keyName = nameOfKey(key);
-          const bindingIdent = (0, _Builders.ident)((_reservedPropNames$ge = reservedPropNames.get(keyName)) != null ? _reservedPropNames$ge : keyName);
-          const object = {
-            type: 'ThisExpression',
-            ...(0, _Builders.etc)()
-          };
-          const memberExpression = key.type === 'Identifier' ? {
-            type: 'MemberExpression',
-            object,
-            property: (0, _astNodeMutationHelpers.shallowCloneNode)(key),
-            computed: false,
-            optional: false,
-            ...(0, _Builders.etc)()
-          } : {
-            type: 'MemberExpression',
-            object,
-            property: (0, _astNodeMutationHelpers.shallowCloneNode)(key),
-            computed: true,
-            optional: false,
-            ...(0, _Builders.etc)()
-          };
-          return {
-            type: 'ExpressionStatement',
-            expression: {
-              type: 'AssignmentExpression',
-              operator: '=',
-              left: memberExpression,
-              right: bindingIdent,
-              ...(0, _Builders.etc)()
-            },
-            directive: null,
-            ...(0, _Builders.etc)()
-          };
-        }),
-        ...(0, _Builders.etc)()
-      },
-      generator: false,
-      async: false,
-      predicate: null,
-      returnType: null,
-      typeParameters: null,
-      ...(0, _Builders.etc)()
-    },
-    ...(0, _Builders.etc)(),
-    parent: _Builders.EMPTY_PARENT
-  };
-  const classStaticProperties = staticProperties.map(prop => ({
-    type: 'PropertyDefinition',
-    key: (0, _astNodeMutationHelpers.shallowCloneNode)(prop.key),
-    value: (0, _astNodeMutationHelpers.deepCloneNode)(prop.value),
-    static: true,
-    decorators: [],
-    typeAnnotation: null,
-    variance: null,
-    computed: false,
-    declare: false,
-    optional: false,
-    ...(0, _Builders.etc)(),
-    parent: _Builders.EMPTY_PARENT
-  }));
-  const classBodyElements = [constructor, ...methods, ...classStaticProperties, ...staticMethods];
-  return {
-    type: 'ClassDeclaration',
-    id: (0, _astNodeMutationHelpers.shallowCloneNode)(node.id),
-    body: {
-      type: 'ClassBody',
-      body: classBodyElements,
-      ...(0, _Builders.etc)(),
-      parent: _Builders.EMPTY_PARENT
-    },
-    superClass: null,
-    typeParameters: null,
-    superTypeArguments: null,
-    implements: [],
-    decorators: [],
-    ...(0, _Builders.etc)()
-  };
-}
-
-function mapRecordExpression(node) {
-  const obj = {
-    type: 'ObjectExpression',
-    properties: node.properties.properties,
-    ...(0, _Builders.etc)()
-  };
-  return {
-    type: 'NewExpression',
-    callee: node.recordConstructor,
-    arguments: [obj],
-    typeArguments: null,
-    ...(0, _Builders.etc)()
-  };
-}
-
-function transformProgram(program, _options) {
-  const genID = new _GenID.default('r');
-  return _SimpleTransform.SimpleTransform.transformProgram(program, {
-    transform(node) {
-      switch (node.type) {
-        case 'RecordDeclaration':
-          {
-            return mapRecordDeclaration(genID, node);
-          }
-
-        case 'RecordExpression':
-          {
-            return mapRecordExpression(node);
-          }
-
-        case 'Identifier':
-          {
-            genID.addUsage(node.name);
-            return node;
-          }
-
-        default:
-          return node;
-      }
-    }
-
-  });
-}

package/oxidized/oxidized-src/generated/ESTreeVisitorKeys.js

@@ -1,234 +0,0 @@
-'use strict';
-
-module.exports = {
-  AbstractMethodDefinition: ['key', 'value'],
-  AbstractPropertyDefinition: ['key', 'value', 'variance'],
-  AnyTypeAnnotation: [],
-  ArrayExpression: ['elements'],
-  ArrayPattern: ['elements', 'typeAnnotation'],
-  ArrayTypeAnnotation: ['elementType'],
-  ArrowFunctionExpression: ['params', 'body', 'typeParameters', 'returnType', 'predicate'],
-  AsConstExpression: ['expression'],
-  AsExpression: ['expression', 'typeAnnotation'],
-  AssignmentExpression: ['left', 'right'],
-  AssignmentPattern: ['left', 'right'],
-  AwaitExpression: ['argument'],
-  BigIntLiteralTypeAnnotation: [],
-  BigIntTypeAnnotation: [],
-  BinaryExpression: ['left', 'right'],
-  BlockStatement: ['body'],
-  BooleanLiteralTypeAnnotation: [],
-  BooleanTypeAnnotation: [],
-  BreakStatement: ['label'],
-  CallExpression: ['callee', 'typeArguments', 'arguments'],
-  CatchClause: ['param', 'body'],
-  ChainExpression: ['expression'],
-  ClassBody: ['body'],
-  ClassDeclaration: ['id', 'typeParameters', 'superClass', 'superTypeArguments', 'implements', 'decorators', 'body'],
-  ClassExpression: ['id', 'typeParameters', 'superClass', 'superTypeArguments', 'implements', 'decorators', 'body'],
-  ClassImplements: ['id', 'typeParameters'],
-  ComponentDeclaration: ['id', 'params', 'body', 'typeParameters', 'rendersType'],
-  ComponentParameter: ['name', 'local'],
-  ComponentTypeAnnotation: ['params', 'rest', 'typeParameters', 'rendersType'],
-  ComponentTypeParameter: ['name', 'typeAnnotation'],
-  ConditionalExpression: ['test', 'consequent', 'alternate'],
-  ConditionalTypeAnnotation: ['checkType', 'extendsType', 'trueType', 'falseType'],
-  ConstructorTypeAnnotation: ['params', 'returnType', 'rest', 'typeParameters'],
-  ContinueStatement: ['label'],
-  DebuggerStatement: [],
-  DeclareClass: ['id', 'typeParameters', 'extends', 'implements', 'mixins', 'body'],
-  DeclareClassExtendsCall: ['callee', 'argument'],
-  DeclareComponent: ['id', 'params', 'rest', 'typeParameters', 'rendersType'],
-  DeclareEnum: ['id', 'body'],
-  DeclareExportAllDeclaration: ['source'],
-  DeclareExportDeclaration: ['declaration', 'specifiers', 'source'],
-  DeclareFunction: ['id', 'predicate'],
-  DeclareHook: ['id'],
-  DeclareInterface: ['id', 'typeParameters', 'extends', 'body'],
-  DeclareMethodDefinition: ['key', 'value'],
-  DeclareModule: ['id', 'body'],
-  DeclareModuleExports: ['typeAnnotation'],
-  DeclareNamespace: ['id', 'body'],
-  DeclareOpaqueType: ['id', 'typeParameters', 'impltype', 'lowerBound', 'upperBound', 'supertype'],
-  DeclareTypeAlias: ['id', 'typeParameters', 'right'],
-  DeclareVariable: ['id'],
-  DeclaredPredicate: ['value'],
-  Decorator: ['expression'],
-  DoWhileStatement: ['body', 'test'],
-  EmptyStatement: [],
-  EmptyTypeAnnotation: [],
-  EnumBigIntBody: ['members'],
-  EnumBigIntMember: ['id', 'init'],
-  EnumBody: ['members'],
-  EnumBooleanBody: ['members'],
-  EnumBooleanMember: ['id', 'init'],
-  EnumDeclaration: ['id', 'body'],
-  EnumDefaultedMember: ['id'],
-  EnumNumberBody: ['members'],
-  EnumNumberMember: ['id', 'init'],
-  EnumStringBody: ['members'],
-  EnumStringMember: ['id', 'init'],
-  EnumSymbolBody: ['members'],
-  ExistsTypeAnnotation: [],
-  ExportAllDeclaration: ['exported', 'source'],
-  ExportAssignment: ['expression'],
-  ExportDefaultDeclaration: ['declaration'],
-  ExportNamedDeclaration: ['declaration', 'specifiers', 'source'],
-  ExportNamespaceSpecifier: ['exported'],
-  ExportSpecifier: ['exported', 'local'],
-  ExpressionStatement: ['expression'],
-  ExternalModuleReference: ['expression'],
-  ForInStatement: ['left', 'right', 'body'],
-  ForOfStatement: ['left', 'right', 'body'],
-  ForStatement: ['init', 'test', 'update', 'body'],
-  FunctionDeclaration: ['id', 'params', 'body', 'typeParameters', 'returnType', 'predicate'],
-  FunctionExpression: ['id', 'params', 'body', 'typeParameters', 'returnType', 'predicate'],
-  FunctionTypeAnnotation: ['params', 'this', 'returnType', 'rest', 'typeParameters'],
-  FunctionTypeParam: ['name', 'typeAnnotation'],
-  GenericTypeAnnotation: ['id', 'typeParameters'],
-  HookDeclaration: ['id', 'params', 'body', 'typeParameters', 'returnType'],
-  HookTypeAnnotation: ['params', 'returnType', 'rest', 'typeParameters'],
-  Identifier: ['typeAnnotation'],
-  IfStatement: ['test', 'consequent', 'alternate'],
-  ImportAttribute: ['key', 'value'],
-  ImportDeclaration: ['specifiers', 'source', 'attributes'],
-  ImportDefaultSpecifier: ['local'],
-  ImportEqualsDeclaration: ['id', 'moduleReference'],
-  ImportExpression: ['source', 'options'],
-  ImportNamespaceSpecifier: ['local'],
-  ImportSpecifier: ['imported', 'local'],
-  ImportType: ['argument'],
-  IndexedAccessType: ['objectType', 'indexType'],
-  InferTypeAnnotation: ['typeParameter'],
-  InferredPredicate: [],
-  InterfaceDeclaration: ['id', 'typeParameters', 'extends', 'body'],
-  InterfaceExtends: ['id', 'typeParameters'],
-  InterfaceTypeAnnotation: ['extends', 'body'],
-  InterpreterDirective: [],
-  IntersectionTypeAnnotation: ['types'],
-  JSXAttribute: ['name', 'value'],
-  JSXClosingElement: ['name'],
-  JSXClosingFragment: [],
-  JSXElement: ['openingElement', 'children', 'closingElement'],
-  JSXEmptyExpression: [],
-  JSXExpressionContainer: ['expression'],
-  JSXFragment: ['openingFragment', 'children', 'closingFragment'],
-  JSXIdentifier: [],
-  JSXMemberExpression: ['object', 'property'],
-  JSXNamespacedName: ['namespace', 'name'],
-  JSXOpeningElement: ['name', 'attributes', 'typeArguments'],
-  JSXOpeningFragment: [],
-  JSXSpreadAttribute: ['argument'],
-  JSXSpreadChild: ['expression'],
-  JSXText: [],
-  KeyofTypeAnnotation: ['argument'],
-  LabeledStatement: ['label', 'body'],
-  LogicalExpression: ['left', 'right'],
-  MatchArrayPattern: ['elements', 'rest'],
-  MatchAsPattern: ['pattern', 'target'],
-  MatchBindingPattern: ['id'],
-  MatchExpression: ['argument', 'cases'],
-  MatchExpressionCase: ['pattern', 'body', 'guard'],
-  MatchIdentifierPattern: ['id'],
-  MatchInstanceObjectPattern: ['properties', 'rest'],
-  MatchInstancePattern: ['targetConstructor', 'properties'],
-  MatchLiteralPattern: ['literal'],
-  MatchMemberPattern: ['base', 'property'],
-  MatchObjectPattern: ['properties', 'rest'],
-  MatchObjectPatternProperty: ['key', 'pattern'],
-  MatchOrPattern: ['patterns'],
-  MatchRestPattern: ['argument'],
-  MatchStatement: ['argument', 'cases'],
-  MatchStatementCase: ['pattern', 'body', 'guard'],
-  MatchUnaryPattern: ['argument'],
-  MatchWildcardPattern: [],
-  MemberExpression: ['object', 'property'],
-  MetaProperty: ['meta', 'property'],
-  MethodDefinition: ['key', 'value', 'decorators'],
-  MixedTypeAnnotation: [],
-  NamespaceExportDeclaration: ['id'],
-  NeverTypeAnnotation: [],
-  NewExpression: ['callee', 'typeArguments', 'arguments'],
-  NonNullExpression: ['argument'],
-  NullLiteralTypeAnnotation: [],
-  NullableTypeAnnotation: ['typeAnnotation'],
-  NumberLiteralTypeAnnotation: [],
-  NumberTypeAnnotation: [],
-  ObjectExpression: ['properties'],
-  ObjectPattern: ['properties', 'typeAnnotation'],
-  ObjectTypeAnnotation: ['properties', 'indexers', 'callProperties', 'internalSlots'],
-  ObjectTypeCallProperty: ['value'],
-  ObjectTypeIndexer: ['id', 'key', 'value', 'variance'],
-  ObjectTypeInternalSlot: ['id', 'value'],
-  ObjectTypeMappedTypeProperty: ['keyTparam', 'propType', 'sourceType', 'variance'],
-  ObjectTypePrivateField: ['key'],
-  ObjectTypeProperty: ['key', 'value', 'variance'],
-  ObjectTypeSpreadProperty: ['argument'],
-  OpaqueType: ['id', 'typeParameters', 'impltype', 'lowerBound', 'upperBound', 'supertype'],
-  OptionalIndexedAccessType: ['objectType', 'indexType'],
-  ParameterProperty: ['key', 'value', 'typeAnnotation', 'variance', 'decorators'],
-  PrivateIdentifier: [],
-  Program: ['body'],
-  Property: ['key', 'value'],
-  PropertyDefinition: ['key', 'value', 'decorators', 'variance', 'typeAnnotation'],
-  QualifiedTypeIdentifier: ['qualification', 'id'],
-  QualifiedTypeofIdentifier: ['qualification', 'id'],
-  RecordDeclaration: ['id', 'typeParameters', 'implements', 'body'],
-  RecordDeclarationBody: ['elements'],
-  RecordDeclarationImplements: ['id', 'typeArguments'],
-  RecordDeclarationProperty: ['key', 'typeAnnotation', 'defaultValue'],
-  RecordDeclarationStaticProperty: ['key', 'typeAnnotation', 'value'],
-  RecordExpression: ['recordConstructor', 'typeArguments', 'properties'],
-  RecordExpressionProperties: ['properties'],
-  RendersMaybeType: ['argument'],
-  RendersStarType: ['argument'],
-  RendersType: ['argument'],
-  RestElement: ['argument'],
-  ReturnStatement: ['argument'],
-  SatisfiesExpression: ['expression', 'typeAnnotation'],
-  SequenceExpression: ['expressions'],
-  SpreadElement: ['argument'],
-  StaticBlock: ['body'],
-  StringLiteralTypeAnnotation: [],
-  StringTypeAnnotation: [],
-  Super: [],
-  SwitchCase: ['test', 'consequent'],
-  SwitchStatement: ['discriminant', 'cases'],
-  SymbolTypeAnnotation: [],
-  TaggedTemplateExpression: ['tag', 'quasi'],
-  TemplateElement: [],
-  TemplateLiteral: ['quasis', 'expressions'],
-  TemplateLiteralTypeAnnotation: ['quasis', 'types'],
-  ThisExpression: [],
-  ThisTypeAnnotation: [],
-  ThrowStatement: ['argument'],
-  TryStatement: ['block', 'handler', 'finalizer'],
-  TupleTypeAnnotation: ['elementTypes'],
-  TupleTypeElement: ['elementType'],
-  TupleTypeLabeledElement: ['label', 'elementType', 'variance'],
-  TupleTypeSpreadElement: ['label', 'typeAnnotation'],
-  TypeAlias: ['id', 'typeParameters', 'right'],
-  TypeAnnotation: ['typeAnnotation'],
-  TypeCastExpression: ['expression', 'typeAnnotation'],
-  TypeOperator: ['typeAnnotation'],
-  TypeParameter: ['bound', 'variance', 'default'],
-  TypeParameterDeclaration: ['params'],
-  TypeParameterInstantiation: ['params'],
-  TypePredicate: ['parameterName', 'typeAnnotation'],
-  TypeofTypeAnnotation: ['argument', 'typeArguments'],
-  UnaryExpression: ['argument'],
-  UndefinedTypeAnnotation: [],
-  UnionTypeAnnotation: ['types'],
-  UnknownTypeAnnotation: [],
-  UpdateExpression: ['argument'],
-  VariableDeclaration: ['declarations'],
-  VariableDeclarator: ['id', 'init'],
-  Variance: [],
-  VoidTypeAnnotation: [],
-  WhileStatement: ['test', 'body'],
-  WithStatement: ['object', 'body'],
-  YieldExpression: ['argument'],
-  OptionalMemberExpression: ['object', 'property'],
-  OptionalCallExpression: ['callee', 'typeArguments', 'arguments'],
-  Literal: []
-};

package/oxidized/oxidized-src/getModuleDocblock.js

@@ -1,87 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.getModuleDocblock = getModuleDocblock;
-exports.parseDocblockString = parseDocblockString;
-const DIRECTIVE_REGEX = /^\s*@([a-zA-Z0-9_-]+)( +.+)?$/;
-
-function parseDocblockString(docblock) {
-  const directiveLines = docblock.split('\n').map(line => line.trimStart().replace(/^\* ?/, '').trim()).filter(line => line.startsWith('@'));
-  const directives = Object.create(null);
-
-  for (const line of directiveLines) {
-    var _match$;
-
-    const match = DIRECTIVE_REGEX.exec(line);
-
-    if (match == null) {
-      continue;
-    }
-
-    const name = match[1];
-    const value = ((_match$ = match[2]) != null ? _match$ : '').trim();
-
-    if (directives[name]) {
-      directives[name].push(value);
-    } else {
-      directives[name] = [value];
-    }
-  }
-
-  return directives;
-}
-
-function getModuleDocblock(hermesProgram) {
-  const docblockNode = (() => {
-    if (hermesProgram.type !== 'Program') {
-      return null;
-    }
-
-    const program = hermesProgram;
-
-    if (program.comments.length === 0) {
-      return null;
-    }
-
-    const firstComment = (() => {
-      const first = program.comments[0];
-
-      if (first.type === 'Block') {
-        return first;
-      }
-
-      if (program.comments.length === 1) {
-        return null;
-      }
-
-      const second = program.comments[1];
-
-      if (first.type === 'Line' && first.range[0] === 0 && second.type === 'Block') {
-        return second;
-      }
-
-      return null;
-    })();
-
-    if (firstComment == null) {
-      return null;
-    }
-
-    if (program.body.length > 0 && program.body[0].range[0] < firstComment.range[0]) {
-      return null;
-    }
-
-    return firstComment;
-  })();
-
-  if (docblockNode == null) {
-    return null;
-  }
-
-  return {
-    directives: parseDocblockString(docblockNode.value),
-    comment: docblockNode
-  };
-}