hermes-parser 0.32.1 → 0.33.1

package/dist/estree/TransformMatchSyntax.js.flow

@@ -24,8 +24,11 @@ import type {
   Identifier,
   Literal,
   MatchExpression,
+  MatchIdentifierPattern,
   MatchMemberPattern,
+  MatchObjectPatternProperty,
   MatchPattern,
+  MatchRestPattern,
   MatchStatement,
   MemberExpression,
   ObjectPattern,
@@ -57,18 +60,18 @@ import {
   typeofExpression,
   variableDeclaration,
 } from '../utils/Builders';
-import {createGenID} from '../utils/GenID';
+import GenID from '../utils/GenID';
 
 /**
  * Generated identifiers.
  * `GenID` is initialized in the transform.
  */
-let GenID: ?ReturnType<typeof createGenID> = null;
+let genID: GenID | null = null;
 function genIdent(): Identifier {
-  if (GenID == null) {
+  if (genID == null) {
     throw Error('GenID must be initialized at the start of the transform.');
   }
-  return ident(GenID.genID());
+  return ident(genID.id());
 }
 
 /**
@@ -86,6 +89,7 @@ type Condition =
   | {type: 'is-nan', key: Key}
   | {type: 'array', key: Key, length: number, lengthOp: 'eq' | 'gte'}
   | {type: 'object', key: Key}
+  | {type: 'instanceof', key: Key, constructor: Expression}
   | {type: 'prop-exists', key: Key, propName: string}
   | {type: 'or', orConditions: Array<Array<Condition>>};
 
@@ -194,6 +198,7 @@ function needsPropExistsCond(pattern: MatchPattern): boolean {
     case 'MatchLiteralPattern':
     case 'MatchUnaryPattern':
     case 'MatchObjectPattern':
+    case 'MatchInstancePattern':
     case 'MatchArrayPattern':
       return false;
     case 'MatchAsPattern': {
@@ -207,6 +212,74 @@ function needsPropExistsCond(pattern: MatchPattern): boolean {
   }
 }
 
+/**
+ * Analyzes properties of both object patterns and instance patterns.
+ */
+function analyzeProperties(
+  key: Key,
+  pattern: MatchPattern,
+  seenBindingNames: Set<string>,
+  properties: ReadonlyArray<MatchObjectPatternProperty>,
+  rest: MatchRestPattern | null,
+): {
+  conditions: Array<Condition>,
+  bindings: Array<Binding>,
+} {
+  const conditions: Array<Condition> = [];
+  const bindings: Array<Binding> = [];
+  const objKeys: Array<Identifier | Literal> = [];
+  const seenNames = new Set<string>();
+
+  properties.forEach(prop => {
+    const {key: objKey, pattern: propPattern} = prop;
+    objKeys.push(objKey);
+    const name = objKeyToString(objKey);
+    if (seenNames.has(name)) {
+      throw createSyntaxError(
+        propPattern,
+        `Duplicate property name '${name}' in match object pattern.`,
+      );
+    }
+    seenNames.add(name);
+    const propKey: Key = key.concat(objKey);
+    if (needsPropExistsCond(propPattern)) {
+      conditions.push({
+        type: 'prop-exists',
+        key,
+        propName: name,
+      });
+    }
+    const {conditions: childConditions, bindings: childBindings} =
+      analyzePattern(propPattern, propKey, seenBindingNames);
+    conditions.push(...childConditions);
+    bindings.push(...childBindings);
+  });
+  if (rest != null && rest.argument != null) {
+    const {id, kind} = rest.argument;
+    checkDuplicateBindingName(seenBindingNames, rest.argument, id.name);
+    checkBindingKind(pattern, kind);
+    bindings.push({
+      type: 'object-rest',
+      key,
+      exclude: objKeys,
+      kind,
+      id,
+    });
+  }
+  return {conditions, bindings};
+}
+
+function constructorExpression(
+  constructor: MatchIdentifierPattern | MatchMemberPattern,
+): Expression {
+  switch (constructor.type) {
+    case 'MatchIdentifierPattern':
+      return constructor.id;
+    case 'MatchMemberPattern':
+      return convertMemberPattern(constructor);
+  }
+}
+
 /**
  * Analyzes a match pattern, and produced both the conditions and bindings
  * produced by that pattern.
@@ -317,46 +390,39 @@ function analyzePattern(
     }
     case 'MatchObjectPattern': {
       const {properties, rest} = pattern;
-      const conditions: Array<Condition> = [{type: 'object', key}];
-      const bindings: Array<Binding> = [];
-      const objKeys: Array<Identifier | Literal> = [];
-      const seenNames = new Set<string>();
-      properties.forEach(prop => {
-        const {key: objKey, pattern: propPattern} = prop;
-        objKeys.push(objKey);
-        const name = objKeyToString(objKey);
-        if (seenNames.has(name)) {
-          throw createSyntaxError(
-            propPattern,
-            `Duplicate property name '${name}' in match object pattern.`,
-          );
-        }
-        seenNames.add(name);
-        const propKey: Key = key.concat(objKey);
-        if (needsPropExistsCond(propPattern)) {
-          conditions.push({
-            type: 'prop-exists',
-            key,
-            propName: name,
-          });
-        }
-        const {conditions: childConditions, bindings: childBindings} =
-          analyzePattern(propPattern, propKey, seenBindingNames);
-        conditions.push(...childConditions);
-        bindings.push(...childBindings);
-      });
-      if (rest != null && rest.argument != null) {
-        const {id, kind} = rest.argument;
-        checkDuplicateBindingName(seenBindingNames, rest.argument, id.name);
-        checkBindingKind(pattern, kind);
-        bindings.push({
-          type: 'object-rest',
+      const {conditions: propertyConditions, bindings} = analyzeProperties(
+        key,
+        pattern,
+        seenBindingNames,
+        properties,
+        rest,
+      );
+      const conditions: Array<Condition> = [
+        {type: 'object', key},
+        ...propertyConditions,
+      ];
+      return {conditions, bindings};
+    }
+    case 'MatchInstancePattern': {
+      const {
+        targetConstructor,
+        properties: {properties, rest},
+      } = pattern;
+      const {conditions: propertyConditions, bindings} = analyzeProperties(
+        key,
+        pattern,
+        seenBindingNames,
+        properties,
+        rest,
+      );
+      const conditions: Array<Condition> = [
+        {
+          type: 'instanceof',
           key,
-          exclude: objKeys,
-          kind,
-          id,
-        });
-      }
+          constructor: constructorExpression(targetConstructor),
+        },
+        ...propertyConditions,
+      ];
       return {conditions, bindings};
     }
     case 'MatchOrPattern': {
@@ -499,6 +565,18 @@ function testsOfCondition(
         disjunction([conjunction([typeofObject, notNull]), typeofFunction]),
       ];
     }
+    case 'instanceof': {
+      const {key, constructor} = condition;
+      return [
+        {
+          type: 'BinaryExpression',
+          left: expressionOfKey(root, key),
+          right: constructor,
+          operator: 'instanceof',
+          ...etc(),
+        },
+      ];
+    }
     case 'prop-exists': {
       // <propName> in <x>
       const {key, propName} = condition;
@@ -881,7 +959,7 @@ export function transformProgram(
 ): Program {
   // Initialize so each file transformed starts freshly incrementing the
   // variable name counter, and has its own usage tracking.
-  GenID = createGenID('m');
+  genID = new GenID('m');
   return SimpleTransform.transformProgram(program, {
     transform(node: ESNode) {
       switch (node.type) {
@@ -895,12 +973,12 @@ export function transformProgram(
           // A rudimentary check to avoid some collisions with our generated
           // variable names. Ideally, we would have access a scope analyzer
           // inside the transform instead.
-          if (GenID == null) {
+          if (genID == null) {
             throw Error(
               'GenID must be initialized at the start of the transform.',
             );
           }
-          GenID.addUsage(node.name);
+          genID.addUsage(node.name);
           return node;
         }
         default: {

package/dist/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;
+      }
+    }
+
+  });
+}