hermes-parser 0.32.1 → 0.33.1

package/dist/src/estree/TransformRecordSyntax.js

@@ -0,0 +1,294 @@
+/**
+ * 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
+ */
+'use strict';
+/**
+ * Transform record declarations.
+ */
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.transformProgram = transformProgram;
+
+var _hermesEstree = require("hermes-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, _hermesEstree.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(); // Create constructor parameter as an object pattern with all properties
+
+  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)()
+  }; // Create the constructor method
+
+  const constructor = {
+    type: 'MethodDefinition',
+    key: (0, _Builders.ident)('constructor'),
+    kind: 'constructor',
+    computed: false,
+    static: false,
+    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,
+    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':
+          {
+            // 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/src/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/src/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/src/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/src/utils/GenID.js

@@ -12,30 +12,35 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.createGenID = createGenID;
+exports.default = void 0;
 const genPrefix = '$$gen$';
 
-function createGenID(uniqueTransformPrefix) {
-  let genN = 0;
-  const used = new Set();
-  return {
-    genID() {
-      let name;
-
-      do {
-        name = `${genPrefix}${uniqueTransformPrefix}${genN}`;
-        genN++;
-      } while (used.has(name));
-
-      used.add(name);
-      return name;
-    },
-
-    addUsage(name) {
-      if (name.startsWith(genPrefix)) {
-        used.add(name);
-      }
+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/dist/src/utils/isReservedWord.js

@@ -0,0 +1,62 @@
+/**
+ * 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
+ */
+'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/dist/utils/GenID.js

@@ -12,30 +12,35 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.createGenID = createGenID;
+exports.default = void 0;
 const genPrefix = '$$gen$';
 
-function createGenID(uniqueTransformPrefix) {
-  let genN = 0;
-  const used = new Set();
-  return {
-    genID() {
-      let name;
-
-      do {
-        name = `${genPrefix}${uniqueTransformPrefix}${genN}`;
-        genN++;
-      } while (used.has(name));
-
-      used.add(name);
-      return name;
-    },
-
-    addUsage(name) {
-      if (name.startsWith(genPrefix)) {
-        used.add(name);
-      }
+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;