hermes-parser 0.32.1 → 0.33.0

package/dist/estree/TransformRecordSyntax.js.flow

@@ -0,0 +1,308 @@
+/**
+ * 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';
+
+/**
+ * Transform record declarations.
+ */
+
+import type {ParserOptions} from '../ParserOptions';
+import type {
+  AssignmentPattern,
+  ClassDeclaration,
+  ClassMember,
+  ESNode,
+  Identifier,
+  MemberExpression,
+  MethodDefinition,
+  NewExpression,
+  ObjectExpression,
+  ObjectPattern,
+  ObjectPropertyKey,
+  Program,
+  RecordDeclaration,
+  RecordDeclarationProperty,
+  RecordDeclarationStaticProperty,
+  RecordExpression,
+  ThisExpression,
+} from 'hermes-estree';
+
+import {isBigIntLiteral} from 'hermes-estree';
+import {SimpleTransform} from '../transform/SimpleTransform';
+import {
+  deepCloneNode,
+  shallowCloneNode,
+} from '../transform/astNodeMutationHelpers';
+import {EMPTY_PARENT, etc, ident} from '../utils/Builders';
+import isReservedWord from '../utils/isReservedWord';
+import GenID from '../utils/GenID';
+
+function nameOfKey(key: ObjectPropertyKey): string {
+  switch (key.type) {
+    case 'Identifier':
+      return key.name;
+    case 'Literal':
+      if (isBigIntLiteral(key)) {
+        return key.bigint;
+      }
+      return String(key.value);
+  }
+}
+
+function mapRecordDeclaration(
+  genID: GenID,
+  node: RecordDeclaration,
+): ClassDeclaration {
+  const ownProperties: Array<RecordDeclarationProperty> = [];
+  const staticProperties: Array<RecordDeclarationStaticProperty> = [];
+  const methods: Array<MethodDefinition> = [];
+  const staticMethods: Array<MethodDefinition> = [];
+
+  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<string, string>();
+
+  // Create constructor parameter as an object pattern with all properties
+  const constructorParam: ObjectPattern = {
+    type: 'ObjectPattern',
+    properties: ownProperties.map(prop => {
+      const {key, defaultValue} = prop;
+      const keyName = nameOfKey(key);
+
+      const getValue = (
+        bindingIdent: Identifier,
+      ): AssignmentPattern | Identifier =>
+        defaultValue != null
+          ? {
+              type: 'AssignmentPattern',
+              left: bindingIdent,
+              right: deepCloneNode(defaultValue),
+              ...etc(),
+            }
+          : bindingIdent;
+
+      switch (key.type) {
+        case 'Identifier': {
+          const needsNewBinding = isReservedWord(keyName);
+          const bindingName = needsNewBinding ? genID.id() : keyName;
+          const bindingIdent = ident(bindingName);
+          if (needsNewBinding) {
+            reservedPropNames.set(keyName, bindingName);
+          }
+
+          if (needsNewBinding) {
+            return {
+              type: 'Property',
+              kind: 'init',
+              key: shallowCloneNode(key),
+              value: getValue(bindingIdent),
+              shorthand: false,
+              method: false,
+              computed: false,
+              ...etc(),
+              parent: EMPTY_PARENT,
+            };
+          } else {
+            return {
+              type: 'Property',
+              kind: 'init',
+              key: shallowCloneNode(key),
+              value: getValue(bindingIdent),
+              shorthand: true,
+              method: false,
+              computed: false,
+              ...etc(),
+              parent: EMPTY_PARENT,
+            };
+          }
+        }
+        case 'Literal': {
+          const bindingName = genID.id();
+          const bindingIdent = ident(bindingName);
+          reservedPropNames.set(keyName, bindingName);
+
+          return {
+            type: 'Property',
+            kind: 'init',
+            key: shallowCloneNode(key),
+            value: getValue(bindingIdent),
+            shorthand: false,
+            method: false,
+            computed: false,
+            ...etc(),
+            parent: EMPTY_PARENT,
+          };
+        }
+      }
+    }),
+    typeAnnotation: null,
+    ...etc(),
+  };
+
+  // Create the constructor method
+  const constructor: MethodDefinition = {
+    type: 'MethodDefinition',
+    key: ident('constructor'),
+    kind: 'constructor',
+    computed: false,
+    static: false,
+    value: {
+      type: 'FunctionExpression',
+      id: null,
+      params: [constructorParam],
+      body: {
+        type: 'BlockStatement',
+        body: ownProperties.map(({key}) => {
+          const keyName = nameOfKey(key);
+          const bindingIdent = ident(reservedPropNames.get(keyName) ?? keyName);
+          const object: ThisExpression = {type: 'ThisExpression', ...etc()};
+          const memberExpression: MemberExpression =
+            key.type === 'Identifier'
+              ? {
+                  type: 'MemberExpression',
+                  object,
+                  property: shallowCloneNode(key),
+                  computed: false,
+                  optional: false,
+                  ...etc(),
+                }
+              : {
+                  type: 'MemberExpression',
+                  object,
+                  property: shallowCloneNode(key),
+                  computed: true,
+                  optional: false,
+                  ...etc(),
+                };
+          return {
+            type: 'ExpressionStatement',
+            expression: {
+              type: 'AssignmentExpression',
+              operator: '=',
+              left: memberExpression,
+              right: bindingIdent,
+              ...etc(),
+            },
+            directive: null,
+            ...etc(),
+          };
+        }),
+        ...etc(),
+      },
+      generator: false,
+      async: false,
+      predicate: null,
+      returnType: null,
+      typeParameters: null,
+      ...etc(),
+    },
+    ...etc(),
+    parent: EMPTY_PARENT,
+  };
+
+  const classStaticProperties: ReadonlyArray<ClassMember> =
+    staticProperties.map(prop => ({
+      type: 'PropertyDefinition',
+      key: shallowCloneNode(prop.key),
+      value: deepCloneNode(prop.value),
+      static: true,
+      typeAnnotation: null,
+      variance: null,
+      computed: false,
+      declare: false,
+      optional: false,
+      ...etc(),
+      parent: EMPTY_PARENT,
+    }));
+
+  const classBodyElements: ReadonlyArray<ClassMember> = [
+    constructor,
+    ...methods,
+    ...classStaticProperties,
+    ...staticMethods,
+  ];
+
+  return {
+    type: 'ClassDeclaration',
+    id: shallowCloneNode(node.id),
+    body: {
+      type: 'ClassBody',
+      body: classBodyElements,
+      ...etc(),
+      parent: EMPTY_PARENT,
+    },
+    superClass: null,
+    typeParameters: null,
+    superTypeArguments: null,
+    implements: [],
+    decorators: [],
+    ...etc(),
+  };
+}
+
+function mapRecordExpression(node: RecordExpression): NewExpression {
+  const obj: ObjectExpression = {
+    type: 'ObjectExpression',
+    properties: node.properties.properties,
+    ...etc(),
+  };
+  return {
+    type: 'NewExpression',
+    callee: node.recordConstructor,
+    arguments: [obj],
+    typeArguments: null,
+    ...etc(),
+  };
+}
+
+export function transformProgram(
+  program: Program,
+  _options: ParserOptions,
+): Program {
+  const genID = new GenID('r');
+  return SimpleTransform.transformProgram(program, {
+    transform(node: ESNode) {
+      switch (node.type) {
+        case 'RecordDeclaration': {
+          return mapRecordDeclaration(genID, node);
+        }
+        case 'RecordExpression': {
+          return mapRecordExpression(node);
+        }
+        case 'Identifier': {
+          // A rudimentary check to avoid some collisions with our generated
+          // variable names. Ideally, we would have access a scope analyzer
+          // inside the transform instead.
+          genID.addUsage(node.name);
+          return node;
+        }
+        default:
+          return node;
+      }
+    },
+  });
+}

package/dist/generated/ESTreeVisitorKeys.js

@@ -26,7 +26,7 @@ module.exports = {
   ArrayExpression: ['elements'],
   ArrayPattern: ['elements', 'typeAnnotation'],
   ArrayTypeAnnotation: ['elementType'],
-  ArrowFunctionExpression: ['id', 'params', 'body', 'typeParameters', 'returnType', 'predicate'],
+  ArrowFunctionExpression: ['params', 'body', 'typeParameters', 'returnType', 'predicate'],
   AsConstExpression: ['expression'],
   AsExpression: ['expression', 'typeAnnotation'],
   AssignmentExpression: ['left', 'right'],
@@ -43,8 +43,8 @@ module.exports = {
   CatchClause: ['param', 'body'],
   ChainExpression: ['expression'],
   ClassBody: ['body'],
-  ClassDeclaration: ['id', 'typeParameters', 'superClass', 'superTypeParameters', 'implements', 'decorators', 'body'],
-  ClassExpression: ['id', 'typeParameters', 'superClass', 'superTypeParameters', 'implements', 'decorators', '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'],
@@ -138,6 +138,8 @@ module.exports = {
   MatchExpression: ['argument', 'cases'],
   MatchExpressionCase: ['pattern', 'body', 'guard'],
   MatchIdentifierPattern: ['id'],
+  MatchInstanceObjectPattern: ['properties', 'rest'],
+  MatchInstancePattern: ['targetConstructor', 'properties'],
   MatchLiteralPattern: ['literal'],
   MatchMemberPattern: ['base', 'property'],
   MatchObjectPattern: ['properties', 'rest'],
@@ -152,6 +154,7 @@ module.exports = {
   MetaProperty: ['meta', 'property'],
   MethodDefinition: ['key', 'value'],
   MixedTypeAnnotation: [],
+  NeverTypeAnnotation: [],
   NewExpression: ['callee', 'typeArguments', 'arguments'],
   NullableTypeAnnotation: ['typeAnnotation'],
   NullLiteralTypeAnnotation: [],
@@ -174,6 +177,13 @@ module.exports = {
   PropertyDefinition: ['key', 'value', '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'],
   RestElement: ['argument'],
   ReturnStatement: ['argument'],
   SequenceExpression: ['expressions'],
@@ -192,7 +202,7 @@ module.exports = {
   ThisTypeAnnotation: [],
   ThrowStatement: ['argument'],
   TryStatement: ['block', 'handler', 'finalizer'],
-  TupleTypeAnnotation: ['types'],
+  TupleTypeAnnotation: ['elementTypes'],
   TupleTypeLabeledElement: ['label', 'elementType', 'variance'],
   TupleTypeSpreadElement: ['label', 'typeAnnotation'],
   TypeAlias: ['id', 'typeParameters', 'right'],
@@ -205,7 +215,9 @@ module.exports = {
   TypeParameterInstantiation: ['params'],
   TypePredicate: ['parameterName', 'typeAnnotation'],
   UnaryExpression: ['argument'],
+  UndefinedTypeAnnotation: [],
   UnionTypeAnnotation: ['types'],
+  UnknownTypeAnnotation: [],
   UpdateExpression: ['argument'],
   VariableDeclaration: ['declarations'],
   VariableDeclarator: ['id', 'init'],

package/dist/generated/ParserVisitorKeys.js

@@ -42,7 +42,6 @@ const HERMES_AST_VISITOR_KEYS = {
     elementType: 'Node'
   },
   ArrowFunctionExpression: {
-    id: 'Node',
     params: 'NodeList',
     body: 'Node',
     typeParameters: 'Node',
@@ -102,7 +101,7 @@ const HERMES_AST_VISITOR_KEYS = {
     id: 'Node',
     typeParameters: 'Node',
     superClass: 'Node',
-    superTypeParameters: 'Node',
+    superTypeArguments: 'Node',
     implements: 'NodeList',
     decorators: 'NodeList',
     body: 'Node'
@@ -111,7 +110,7 @@ const HERMES_AST_VISITOR_KEYS = {
     id: 'Node',
     typeParameters: 'Node',
     superClass: 'Node',
-    superTypeParameters: 'Node',
+    superTypeArguments: 'Node',
     implements: 'NodeList',
     decorators: 'NodeList',
     body: 'Node'
@@ -484,6 +483,14 @@ const HERMES_AST_VISITOR_KEYS = {
   MatchIdentifierPattern: {
     id: 'Node'
   },
+  MatchInstanceObjectPattern: {
+    properties: 'NodeList',
+    rest: 'Node'
+  },
+  MatchInstancePattern: {
+    targetConstructor: 'Node',
+    properties: 'Node'
+  },
   MatchLiteralPattern: {
     literal: 'Node'
   },
@@ -531,6 +538,7 @@ const HERMES_AST_VISITOR_KEYS = {
     value: 'Node'
   },
   MixedTypeAnnotation: {},
+  NeverTypeAnnotation: {},
   NewExpression: {
     callee: 'Node',
     typeArguments: 'Node',
@@ -618,6 +626,37 @@ const HERMES_AST_VISITOR_KEYS = {
     qualification: 'Node',
     id: 'Node'
   },
+  RecordDeclaration: {
+    id: 'Node',
+    typeParameters: 'Node',
+    implements: 'NodeList',
+    body: 'Node'
+  },
+  RecordDeclarationBody: {
+    elements: 'NodeList'
+  },
+  RecordDeclarationImplements: {
+    id: 'Node',
+    typeArguments: 'Node'
+  },
+  RecordDeclarationProperty: {
+    key: 'Node',
+    typeAnnotation: 'Node',
+    defaultValue: 'Node'
+  },
+  RecordDeclarationStaticProperty: {
+    key: 'Node',
+    typeAnnotation: 'Node',
+    value: 'Node'
+  },
+  RecordExpression: {
+    recordConstructor: 'Node',
+    typeArguments: 'Node',
+    properties: 'Node'
+  },
+  RecordExpressionProperties: {
+    properties: 'NodeList'
+  },
   RegExpLiteral: {},
   RestElement: {
     argument: 'Node'
@@ -667,7 +706,7 @@ const HERMES_AST_VISITOR_KEYS = {
     finalizer: 'Node'
   },
   TupleTypeAnnotation: {
-    types: 'NodeList'
+    elementTypes: 'NodeList'
   },
   TupleTypeLabeledElement: {
     label: 'Node',
@@ -715,9 +754,11 @@ const HERMES_AST_VISITOR_KEYS = {
   UnaryExpression: {
     argument: 'Node'
   },
+  UndefinedTypeAnnotation: {},
   UnionTypeAnnotation: {
     types: 'NodeList'
   },
+  UnknownTypeAnnotation: {},
   UpdateExpression: {
     argument: 'Node'
   },

package/dist/index.js

@@ -37,6 +37,8 @@ var TransformEnumSyntax = _interopRequireWildcard(require("./estree/TransformEnu
 
 var TransformMatchSyntax = _interopRequireWildcard(require("./estree/TransformMatchSyntax"));
 
+var TransformRecordSyntax = _interopRequireWildcard(require("./estree/TransformRecordSyntax"));
+
 var StripFlowTypesForBabel = _interopRequireWildcard(require("./estree/StripFlowTypesForBabel"));
 
 var TransformESTreeToBabel = _interopRequireWildcard(require("./babel/TransformESTreeToBabel"));
@@ -126,6 +128,10 @@ function getOptions(options = { ...DEFAULTS
     options.enableExperimentalFlowMatchSyntax = true; // Enable by default
   }
 
+  if (options.enableExperimentalFlowRecordSyntax == null) {
+    options.enableExperimentalFlowRecordSyntax = true; // Enable by default
+  }
+
   options.tokens = options.tokens === true;
   options.allowReturnOutsideFunction = options.allowReturnOutsideFunction === true;
   return options;
@@ -142,7 +148,7 @@ function parse(code, opts) {
     return estreeAST;
   }
 
-  const loweredESTreeAST = [TransformEnumSyntax.transformProgram, TransformMatchSyntax.transformProgram, TransformComponentSyntax.transformProgram, StripFlowTypesForBabel.transformProgram].reduce((ast, transform) => transform(ast, options), estreeAST);
+  const loweredESTreeAST = [TransformEnumSyntax.transformProgram, TransformMatchSyntax.transformProgram, TransformComponentSyntax.transformProgram, TransformRecordSyntax.transformProgram, StripFlowTypesForBabel.transformProgram].reduce((ast, transform) => transform(ast, options), estreeAST);
   return TransformESTreeToBabel.transformProgram(loweredESTreeAST, options);
 }
 
@@ -150,6 +156,7 @@ const Transforms = {
   transformEnumSyntax: TransformEnumSyntax.transformProgram,
   transformMatchSyntax: TransformMatchSyntax.transformProgram,
   transformComponentSyntax: TransformComponentSyntax.transformProgram,
+  transformRecordSyntax: TransformRecordSyntax.transformProgram,
   stripFlowTypesForBabel: StripFlowTypesForBabel.transformProgram,
   stripFlowTypes: StripFlowTypes.transformProgram
 };

package/dist/index.js.flow

@@ -20,6 +20,7 @@ import FlowVisitorKeys from './generated/ESTreeVisitorKeys';
 import * as TransformComponentSyntax from './estree/TransformComponentSyntax';
 import * as TransformEnumSyntax from './estree/TransformEnumSyntax';
 import * as TransformMatchSyntax from './estree/TransformMatchSyntax';
+import * as TransformRecordSyntax from './estree/TransformRecordSyntax';
 import * as StripFlowTypesForBabel from './estree/StripFlowTypesForBabel';
 import * as TransformESTreeToBabel from './babel/TransformESTreeToBabel';
 import * as StripFlowTypes from './estree/StripFlowTypes';
@@ -58,6 +59,10 @@ function getOptions(options?: ParserOptions = {...DEFAULTS}) {
     options.enableExperimentalFlowMatchSyntax = true; // Enable by default
   }
 
+  if (options.enableExperimentalFlowRecordSyntax == null) {
+    options.enableExperimentalFlowRecordSyntax = true; // Enable by default
+  }
+
   options.tokens = options.tokens === true;
   options.allowReturnOutsideFunction =
     options.allowReturnOutsideFunction === true;
@@ -96,6 +101,7 @@ export function parse(
     TransformEnumSyntax.transformProgram,
     TransformMatchSyntax.transformProgram,
     TransformComponentSyntax.transformProgram,
+    TransformRecordSyntax.transformProgram,
     StripFlowTypesForBabel.transformProgram,
   ].reduce((ast, transform) => transform(ast, options), estreeAST);
 
@@ -116,6 +122,7 @@ const Transforms = {
   transformEnumSyntax: TransformEnumSyntax.transformProgram,
   transformMatchSyntax: TransformMatchSyntax.transformProgram,
   transformComponentSyntax: TransformComponentSyntax.transformProgram,
+  transformRecordSyntax: TransformRecordSyntax.transformProgram,
   stripFlowTypesForBabel: StripFlowTypesForBabel.transformProgram,
   stripFlowTypes: StripFlowTypes.transformProgram,
 };

package/dist/src/HermesParser.js

@@ -51,7 +51,7 @@ function initHermesParserWASM() {
     }
 
   });
-  hermesParse = HermesParserWASM.cwrap('hermesParse', 'number', ['number', 'number', 'number', 'number', 'number', 'number', 'number']);
+  hermesParse = HermesParserWASM.cwrap('hermesParse', 'number', ['number', 'number', 'number', 'number', 'number', 'number', 'number', 'number']);
   hermesParseResult_free = HermesParserWASM.cwrap('hermesParseResult_free', 'void', ['number']);
   hermesParseResult_getError = HermesParserWASM.cwrap('hermesParseResult_getError', 'string', ['number']);
   hermesParseResult_getErrorLine = HermesParserWASM.cwrap('hermesParseResult_getErrorLine', 'number', ['number']);
@@ -81,7 +81,7 @@ function parse(source, options) {
   try {
     // Copy source text onto WASM heap
     copyToHeap(sourceBuffer, sourceAddr);
-    const parseResult = hermesParse(sourceAddr, sourceBuffer.length + 1, options.flow === 'detect', options.enableExperimentalComponentSyntax, options.enableExperimentalFlowMatchSyntax, options.tokens, options.allowReturnOutsideFunction);
+    const parseResult = hermesParse(sourceAddr, sourceBuffer.length + 1, options.flow === 'detect', options.enableExperimentalComponentSyntax, options.enableExperimentalFlowMatchSyntax, options.enableExperimentalFlowRecordSyntax, options.tokens, options.allowReturnOutsideFunction);
 
     try {
       // Extract and throw error from parse result if parsing failed