hermes-parser 0.15.1 → 0.17.0

package/dist/estree/StripFlowTypes.js

@@ -0,0 +1,173 @@
+/**
+ * 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.
+ *
+ * 
+ * @format
+ */
+
+/**
+ * This transform strips all Flow types.
+ *
+ * It is expected that all transforms create valid ESTree AST output. If
+ * the transform requires outputting Babel specific AST nodes then it
+ * should live in `ConvertESTreeToBabel.js`
+ */
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.transformProgram = transformProgram;
+
+var _SimpleTransform = require("../transform/SimpleTransform");
+
+const nodeWith = _SimpleTransform.SimpleTransform.nodeWith;
+
+function transformProgram(program, _options) {
+  return _SimpleTransform.SimpleTransform.transformProgram(program, {
+    transform(node) {
+      switch (node.type) {
+        case 'AsExpression':
+        case 'TypeCastExpression':
+          {
+            return node.expression;
+          }
+
+        case 'CallExpression':
+        case 'NewExpression':
+          {
+            if (node.typeArguments != null) {
+              return nodeWith(node, {
+                typeArguments: null
+              });
+            }
+
+            return node;
+          }
+
+        case 'ObjectPattern':
+        case 'ArrayPattern':
+        case 'Identifier':
+          {
+            if (node.typeAnnotation != null) {
+              return nodeWith(node, {
+                typeAnnotation: null
+              });
+            }
+
+            return node;
+          }
+
+        case 'DeclareClass':
+        case 'DeclareFunction':
+        case 'DeclareInterface':
+        case 'DeclareModule':
+        case 'DeclareModuleExports':
+        case 'DeclareOpaqueType':
+        case 'DeclareTypeAlias':
+        case 'DeclareVariable':
+        case 'InterfaceDeclaration':
+        case 'OpaqueType':
+        case 'TypeAlias':
+          {
+            return null;
+          }
+
+        case 'FunctionDeclaration':
+        case 'ArrowFunctionExpression':
+        case 'FunctionExpression':
+          {
+            const newParams = [];
+
+            for (let i = 0; i < node.params.length; i++) {
+              if (i === 0 && node.params[0].type === 'Identifier' && node.params[0].name === 'this') {
+                continue;
+              }
+
+              let param = node.params[i];
+
+              if (param.type === 'AssignmentPattern') {
+                param = param.left;
+              }
+
+              if (param.optional === true) {
+                param = nodeWith(param, {
+                  optional: false
+                });
+              }
+
+              newParams.push(param);
+            }
+
+            return nodeWith(node, {
+              params: newParams,
+              returnType: null,
+              typeParameters: null,
+              predicate: null
+            });
+          }
+
+        case 'ClassDeclaration':
+        case 'ClassExpression':
+          {
+            return nodeWith(node, {
+              typeParameters: null,
+              superTypeParameters: null,
+              implements: [],
+              decorators: []
+            });
+          }
+
+        case 'PropertyDefinition':
+          {
+            return nodeWith(node, {
+              typeAnnotation: null,
+              variance: null,
+              declare: false,
+              optional: false
+            });
+          }
+
+        case 'ImportDeclaration':
+          {
+            if (node.importKind === 'type' || node.importKind === 'typeof') {
+              return null;
+            }
+
+            const nonTypeSpecifiers = node.specifiers.filter(s => s.type !== 'ImportSpecifier' || s.importKind !== 'type' && s.importKind !== 'typeof');
+
+            if (nonTypeSpecifiers.length === 0) {
+              return null;
+            }
+
+            if (nonTypeSpecifiers.length === node.specifiers.length) {
+              return node;
+            }
+
+            return nodeWith(node, {
+              specifiers: nonTypeSpecifiers
+            });
+          }
+
+        case 'ExportAllDeclaration':
+        case 'ExportNamedDeclaration':
+          {
+            if (node.exportKind === 'type') {
+              return null;
+            }
+
+            return node;
+          }
+
+        default:
+          {
+            return node;
+          }
+      }
+    }
+
+  });
+}

package/dist/estree/StripFlowTypes.js.flow

@@ -0,0 +1,156 @@
+/**
+ * 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
+ */
+
+/**
+ * This transform strips all Flow types.
+ *
+ * It is expected that all transforms create valid ESTree AST output. If
+ * the transform requires outputting Babel specific AST nodes then it
+ * should live in `ConvertESTreeToBabel.js`
+ */
+
+'use strict';
+
+import type {ParserOptions} from '../ParserOptions';
+import type {Program, ESNode} from 'hermes-estree';
+
+import {SimpleTransform} from '../transform/SimpleTransform';
+
+const nodeWith = SimpleTransform.nodeWith;
+
+export function transformProgram(
+  program: Program,
+  _options: ParserOptions,
+): Program {
+  return SimpleTransform.transformProgram(program, {
+    transform(node: ESNode) {
+      switch (node.type) {
+        case 'AsExpression':
+        case 'TypeCastExpression': {
+          return node.expression;
+        }
+
+        case 'CallExpression':
+        case 'NewExpression': {
+          if (node.typeArguments != null) {
+            return nodeWith(node, {typeArguments: null});
+          }
+          return node;
+        }
+
+        case 'ObjectPattern':
+        case 'ArrayPattern':
+        case 'Identifier': {
+          if (node.typeAnnotation != null) {
+            return nodeWith(node, {typeAnnotation: null});
+          }
+          return node;
+        }
+
+        case 'DeclareClass':
+        case 'DeclareFunction':
+        case 'DeclareInterface':
+        case 'DeclareModule':
+        case 'DeclareModuleExports':
+        case 'DeclareOpaqueType':
+        case 'DeclareTypeAlias':
+        case 'DeclareVariable':
+        case 'InterfaceDeclaration':
+        case 'OpaqueType':
+        case 'TypeAlias': {
+          return null;
+        }
+
+        case 'FunctionDeclaration':
+        case 'ArrowFunctionExpression':
+        case 'FunctionExpression': {
+          const newParams = [];
+          for (let i = 0; i < node.params.length; i++) {
+            if (
+              i === 0 &&
+              node.params[0].type === 'Identifier' &&
+              node.params[0].name === 'this'
+            ) {
+              continue;
+            }
+
+            let param = node.params[i];
+            if (param.type === 'AssignmentPattern') {
+              param = param.left;
+            }
+            if (param.optional === true) {
+              param = nodeWith(param, {optional: false});
+            }
+            newParams.push(param);
+          }
+
+          return nodeWith(node, {
+            params: newParams,
+            returnType: null,
+            typeParameters: null,
+            predicate: null,
+          });
+        }
+
+        case 'ClassDeclaration':
+        case 'ClassExpression': {
+          return nodeWith(node, {
+            typeParameters: null,
+            superTypeParameters: null,
+            implements: [],
+            decorators: [],
+          });
+        }
+
+        case 'PropertyDefinition': {
+          return nodeWith(node, {
+            typeAnnotation: null,
+            variance: null,
+            declare: false,
+            optional: false,
+          });
+        }
+
+        case 'ImportDeclaration': {
+          if (node.importKind === 'type' || node.importKind === 'typeof') {
+            return null;
+          }
+          const nonTypeSpecifiers = node.specifiers.filter(
+            s =>
+              s.type !== 'ImportSpecifier' ||
+              (s.importKind !== 'type' && s.importKind !== 'typeof'),
+          );
+          if (nonTypeSpecifiers.length === 0) {
+            return null;
+          }
+          if (nonTypeSpecifiers.length === node.specifiers.length) {
+            return node;
+          }
+
+          return nodeWith(node, {
+            specifiers: nonTypeSpecifiers,
+          });
+        }
+
+        case 'ExportAllDeclaration':
+        case 'ExportNamedDeclaration': {
+          if (node.exportKind === 'type') {
+            return null;
+          }
+          return node;
+        }
+
+        default: {
+          return node;
+        }
+      }
+    },
+  });
+}

package/dist/estree/StripFlowTypesForBabel.js

@@ -0,0 +1,186 @@
+/**
+ * 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.
+ *
+ * 
+ * @format
+ */
+
+/**
+ * This transform strips Flow types that are not supported past Babel 7.
+ *
+ * It is expected that all transforms create valid ESTree AST output. If
+ * the transform requires outputting Babel specific AST nodes then it
+ * should live in `ConvertESTreeToBabel.js`
+ */
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.transformProgram = transformProgram;
+
+var _SimpleTransform = require("../transform/SimpleTransform");
+
+var _createSyntaxError = require("../utils/createSyntaxError");
+
+const nodeWith = _SimpleTransform.SimpleTransform.nodeWith; // Rely on the mapper to fix up parent relationships.
+
+const EMPTY_PARENT = null;
+
+function createSimpleGenericTypeAnnotation(name, nodeForLoc) {
+  return {
+    type: 'GenericTypeAnnotation',
+    id: {
+      type: 'Identifier',
+      name,
+      optional: false,
+      typeAnnotation: null,
+      loc: nodeForLoc.loc,
+      range: nodeForLoc.range,
+      parent: EMPTY_PARENT
+    },
+    typeParameters: null,
+    loc: nodeForLoc.loc,
+    range: nodeForLoc.range,
+    parent: nodeForLoc.parent
+  };
+}
+
+function createAnyTypeAnnotation(node) {
+  return {
+    type: 'AnyTypeAnnotation',
+    loc: node.loc,
+    range: node.range,
+    parent: node.parent
+  };
+}
+/**
+ * Convert DeclareEnum nodes to DeclareVariable
+ */
+
+
+function mapDeclareEnum(node) {
+  return {
+    type: 'DeclareVariable',
+    kind: 'const',
+    id: nodeWith(node.id, {
+      typeAnnotation: {
+        type: 'TypeAnnotation',
+        typeAnnotation: createAnyTypeAnnotation(node.body),
+        loc: node.body.loc,
+        range: node.body.range,
+        parent: EMPTY_PARENT
+      }
+    }),
+    loc: node.loc,
+    range: node.range,
+    parent: node.parent
+  };
+}
+/**
+ * Remove `this` param from functions.
+ */
+
+
+function mapFunction(node) {
+  // Remove the first parameter if it is a this-type annotation,
+  // which is not recognized by Babel.
+  if (node.params.length !== 0 && node.params[0].name === 'this') {
+    return nodeWith(node, {
+      params: node.params.slice(1)
+    });
+  }
+
+  return node;
+}
+/**
+ * Convert to QualifiedTypeIdentifier
+ */
+
+
+function mapQualifiedTypeofIdentifier(node) {
+  return {
+    type: 'QualifiedTypeIdentifier',
+    qualification: node.qualification.type === 'QualifiedTypeofIdentifier' ? mapQualifiedTypeofIdentifier(node.qualification) : node.qualification,
+    id: node.id,
+    loc: node.loc,
+    range: node.range,
+    parent: node.parent
+  };
+}
+
+function transformProgram(program, _options) {
+  return _SimpleTransform.SimpleTransform.transformProgram(program, {
+    transform(node) {
+      switch (node.type) {
+        case 'SymbolTypeAnnotation':
+          {
+            // Convert to simple generic type annotation
+            return createSimpleGenericTypeAnnotation('symbol', node);
+          }
+
+        case 'BigIntTypeAnnotation':
+          {
+            // Convert to simple generic type annotation
+            return createSimpleGenericTypeAnnotation('bigint', node);
+          }
+
+        case 'ObjectTypeAnnotation':
+          {
+            const shouldStrip = node.properties.some(prop => prop.type === 'ObjectTypeMappedTypeProperty');
+
+            if (shouldStrip) {
+              return createAnyTypeAnnotation(node);
+            }
+
+            return node;
+          }
+
+        case 'ObjectTypeMappedTypeProperty':
+          {
+            throw (0, _createSyntaxError.createSyntaxError)(node, `Invalid AST structure, ObjectTypeMappedTypeProperty found outside of an ObjectTypeAnnotation`);
+          }
+
+        case 'IndexedAccessType':
+        case 'OptionalIndexedAccessType':
+        case 'KeyofTypeAnnotation':
+        case 'ConditionalTypeAnnotation':
+        case 'InferTypeAnnotation':
+        case 'TupleTypeLabeledElement':
+        case 'TupleTypeSpreadElement':
+        case 'ComponentTypeAnnotation':
+        case 'TypeOperator':
+        case 'TypePredicate':
+          {
+            // Babel does not support these generic types, so convert to any
+            return createAnyTypeAnnotation(node);
+          }
+
+        case 'QualifiedTypeofIdentifier':
+          {
+            return mapQualifiedTypeofIdentifier(node);
+          }
+
+        case 'DeclareEnum':
+          {
+            return mapDeclareEnum(node);
+          }
+
+        case 'FunctionDeclaration':
+        case 'FunctionExpression':
+          {
+            return mapFunction(node);
+          }
+
+        default:
+          {
+            return node;
+          }
+      }
+    }
+
+  });
+}

package/dist/estree/StripFlowTypesForBabel.js.flow

@@ -0,0 +1,189 @@
+/**
+ * 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
+ */
+
+/**
+ * This transform strips Flow types that are not supported past Babel 7.
+ *
+ * It is expected that all transforms create valid ESTree AST output. If
+ * the transform requires outputting Babel specific AST nodes then it
+ * should live in `ConvertESTreeToBabel.js`
+ */
+
+'use strict';
+
+import type {ParserOptions} from '../ParserOptions';
+import type {
+  Program,
+  ESNode,
+  DeclareEnum,
+  DeclareVariable,
+  AnyTypeAnnotation,
+  GenericTypeAnnotation,
+  QualifiedTypeIdentifier,
+  QualifiedTypeofIdentifier,
+  AFunction,
+} from 'hermes-estree';
+
+import {SimpleTransform} from '../transform/SimpleTransform';
+import {createSyntaxError} from '../utils/createSyntaxError';
+
+const nodeWith = SimpleTransform.nodeWith;
+
+// Rely on the mapper to fix up parent relationships.
+const EMPTY_PARENT: $FlowFixMe = null;
+
+function createSimpleGenericTypeAnnotation(
+  name: string,
+  nodeForLoc: ESNode,
+): GenericTypeAnnotation {
+  return {
+    type: 'GenericTypeAnnotation',
+    id: {
+      type: 'Identifier',
+      name,
+      optional: false,
+      typeAnnotation: null,
+      loc: nodeForLoc.loc,
+      range: nodeForLoc.range,
+      parent: EMPTY_PARENT,
+    },
+    typeParameters: null,
+    loc: nodeForLoc.loc,
+    range: nodeForLoc.range,
+    parent: nodeForLoc.parent,
+  };
+}
+
+function createAnyTypeAnnotation(node: ESNode): AnyTypeAnnotation {
+  return {
+    type: 'AnyTypeAnnotation',
+    loc: node.loc,
+    range: node.range,
+    parent: node.parent,
+  };
+}
+
+/**
+ * Convert DeclareEnum nodes to DeclareVariable
+ */
+function mapDeclareEnum(node: DeclareEnum): DeclareVariable {
+  return {
+    type: 'DeclareVariable',
+    kind: 'const',
+    id: nodeWith(node.id, {
+      typeAnnotation: {
+        type: 'TypeAnnotation',
+        typeAnnotation: createAnyTypeAnnotation(node.body),
+        loc: node.body.loc,
+        range: node.body.range,
+        parent: EMPTY_PARENT,
+      },
+    }),
+    loc: node.loc,
+    range: node.range,
+    parent: node.parent,
+  };
+}
+
+/**
+ * Remove `this` param from functions.
+ */
+function mapFunction(node: AFunction): AFunction {
+  // Remove the first parameter if it is a this-type annotation,
+  // which is not recognized by Babel.
+  if (node.params.length !== 0 && node.params[0].name === 'this') {
+    return nodeWith(node, {
+      params: node.params.slice(1),
+    });
+  }
+
+  return node;
+}
+
+/**
+ * Convert to QualifiedTypeIdentifier
+ */
+function mapQualifiedTypeofIdentifier(
+  node: QualifiedTypeofIdentifier,
+): QualifiedTypeIdentifier {
+  return {
+    type: 'QualifiedTypeIdentifier',
+    qualification:
+      node.qualification.type === 'QualifiedTypeofIdentifier'
+        ? mapQualifiedTypeofIdentifier(node.qualification)
+        : node.qualification,
+    id: node.id,
+    loc: node.loc,
+    range: node.range,
+    parent: node.parent,
+  };
+}
+
+export function transformProgram(
+  program: Program,
+  _options: ParserOptions,
+): Program {
+  return SimpleTransform.transformProgram(program, {
+    transform(node: ESNode) {
+      switch (node.type) {
+        case 'SymbolTypeAnnotation': {
+          // Convert to simple generic type annotation
+          return createSimpleGenericTypeAnnotation('symbol', node);
+        }
+        case 'BigIntTypeAnnotation': {
+          // Convert to simple generic type annotation
+          return createSimpleGenericTypeAnnotation('bigint', node);
+        }
+        case 'ObjectTypeAnnotation': {
+          const shouldStrip = node.properties.some(
+            prop => prop.type === 'ObjectTypeMappedTypeProperty',
+          );
+          if (shouldStrip) {
+            return createAnyTypeAnnotation(node);
+          }
+
+          return node;
+        }
+        case 'ObjectTypeMappedTypeProperty': {
+          throw createSyntaxError(
+            node,
+            `Invalid AST structure, ObjectTypeMappedTypeProperty found outside of an ObjectTypeAnnotation`,
+          );
+        }
+        case 'IndexedAccessType':
+        case 'OptionalIndexedAccessType':
+        case 'KeyofTypeAnnotation':
+        case 'ConditionalTypeAnnotation':
+        case 'InferTypeAnnotation':
+        case 'TupleTypeLabeledElement':
+        case 'TupleTypeSpreadElement':
+        case 'ComponentTypeAnnotation':
+        case 'TypeOperator':
+        case 'TypePredicate': {
+          // Babel does not support these generic types, so convert to any
+          return createAnyTypeAnnotation(node);
+        }
+        case 'QualifiedTypeofIdentifier': {
+          return mapQualifiedTypeofIdentifier(node);
+        }
+        case 'DeclareEnum': {
+          return mapDeclareEnum(node);
+        }
+        case 'FunctionDeclaration':
+        case 'FunctionExpression': {
+          return mapFunction(node);
+        }
+        default: {
+          return node;
+        }
+      }
+    },
+  });
+}

package/dist/generated/ESTreeVisitorKeys.js

@@ -27,6 +27,7 @@ module.exports = {
   ArrayPattern: ['elements', 'typeAnnotation'],
   ArrayTypeAnnotation: ['elementType'],
   ArrowFunctionExpression: ['id', 'params', 'body', 'typeParameters', 'returnType', 'predicate'],
+  AsExpression: ['expression', 'typeAnnotation'],
   AssignmentExpression: ['left', 'right'],
   AssignmentPattern: ['left', 'right'],
   AwaitExpression: ['argument'],
@@ -174,6 +175,7 @@ module.exports = {
   TypeAnnotation: ['typeAnnotation'],
   TypeCastExpression: ['expression', 'typeAnnotation'],
   TypeofTypeAnnotation: ['argument'],
+  TypeOperator: ['typeAnnotation'],
   TypeParameter: ['bound', 'variance', 'default'],
   TypeParameterDeclaration: ['params'],
   TypeParameterInstantiation: ['params'],