hermes-parser 0.32.0 → 0.33.0

package/dist/src/estree/TransformEnumSyntax.js

@@ -0,0 +1,106 @@
+/**
+ * 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 Flow Enum declarations (https://flow.org/en/docs/enums/).
+ */
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.transformProgram = transformProgram;
+
+var _hermesEstree = require("hermes-estree");
+
+var _SimpleTransform = require("../transform/SimpleTransform");
+
+var _Builders = require("../utils/Builders");
+
+function mapEnumDeclaration(node, options) {
+  var _options$transformOpt, _options$transformOpt2;
+
+  const {
+    body
+  } = node;
+  const {
+    members
+  } = body;
+  const getRuntime = (_options$transformOpt = options.transformOptions) == null ? void 0 : (_options$transformOpt2 = _options$transformOpt.TransformEnumSyntax) == null ? void 0 : _options$transformOpt2.getRuntime;
+  const enumModule = typeof getRuntime === 'function' ? getRuntime() : (0, _Builders.callExpression)((0, _Builders.ident)('require'), [(0, _Builders.stringLiteral)('flow-enums-runtime')]);
+  const mirrored = body.type === 'EnumStringBody' && (!members.length || members[0].type === 'EnumDefaultedMember');
+  const enumExpression = mirrored ? (0, _Builders.callExpression)({
+    type: 'MemberExpression',
+    object: enumModule,
+    property: (0, _Builders.ident)('Mirrored'),
+    computed: false,
+    optional: false,
+    ...(0, _Builders.etc)()
+  }, [{
+    type: 'ArrayExpression',
+    elements: members.map(member => (0, _Builders.stringLiteral)(member.id.name)),
+    trailingComma: false,
+    ...(0, _Builders.etc)()
+  }]) : (0, _Builders.callExpression)(enumModule, [{
+    type: 'ObjectExpression',
+    properties: members.map(member => ({
+      type: 'Property',
+      key: member.id,
+      value: // String enums with `EnumDefaultedMember` are handled above by
+      // calculation of `mirrored`.
+      member.type === 'EnumDefaultedMember' ? (0, _Builders.callExpression)((0, _Builders.ident)('Symbol'), [(0, _Builders.stringLiteral)(member.id.name)]) : member.init,
+      kind: 'init',
+      method: false,
+      shorthand: false,
+      computed: false,
+      ...(0, _Builders.etc)(),
+      parent: _Builders.EMPTY_PARENT
+    })),
+    ...(0, _Builders.etc)()
+  }]);
+  return (0, _Builders.variableDeclaration)('const', node.id, enumExpression);
+}
+
+function transformProgram(program, options) {
+  return _SimpleTransform.SimpleTransform.transformProgram(program, {
+    transform(node) {
+      switch (node.type) {
+        case 'EnumDeclaration':
+          {
+            return mapEnumDeclaration(node, options);
+          }
+
+        case 'ExportDefaultDeclaration':
+          {
+            const {
+              declaration
+            } = node;
+
+            if ((0, _hermesEstree.isEnumDeclaration)(declaration)) {
+              const enumDeclaration = mapEnumDeclaration(declaration, options);
+
+              const exportDefault = _SimpleTransform.SimpleTransform.nodeWith(node, {
+                declaration: (0, _Builders.ident)(declaration.id.name)
+              });
+
+              return [enumDeclaration, exportDefault];
+            } else {
+              return node;
+            }
+          }
+
+        default:
+          {
+            return node;
+          }
+      }
+    }
+
+  });
+}

package/dist/src/estree/TransformMatchSyntax.js

@@ -25,20 +25,22 @@ var _createSyntaxError = require("../utils/createSyntaxError");
 
 var _Builders = require("../utils/Builders");
 
-var _GenID = require("../utils/GenID");
+var _GenID = _interopRequireDefault(require("../utils/GenID"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 /**
  * Generated identifiers.
  * `GenID` is initialized in the transform.
  */
-let GenID = null;
+let genID = null;
 
 function genIdent() {
-  if (GenID == null) {
+  if (genID == null) {
     throw Error('GenID must be initialized at the start of the transform.');
   }
 
-  return (0, _Builders.ident)(GenID.genID());
+  return (0, _Builders.ident)(genID.id());
 }
 /**
  * A series of properties.
@@ -138,6 +140,7 @@ function needsPropExistsCond(pattern) {
     case 'MatchLiteralPattern':
     case 'MatchUnaryPattern':
     case 'MatchObjectPattern':
+    case 'MatchInstancePattern':
     case 'MatchArrayPattern':
       return false;
 
@@ -158,6 +161,78 @@ function needsPropExistsCond(pattern) {
       }
   }
 }
+/**
+ * Analyzes properties of both object patterns and instance patterns.
+ */
+
+
+function analyzeProperties(key, pattern, seenBindingNames, properties, rest) {
+  const conditions = [];
+  const bindings = [];
+  const objKeys = [];
+  const seenNames = new Set();
+  properties.forEach(prop => {
+    const {
+      key: objKey,
+      pattern: propPattern
+    } = prop;
+    objKeys.push(objKey);
+    const name = objKeyToString(objKey);
+
+    if (seenNames.has(name)) {
+      throw (0, _createSyntaxError.createSyntaxError)(propPattern, `Duplicate property name '${name}' in match object pattern.`);
+    }
+
+    seenNames.add(name);
+    const propKey = 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) {
+  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.
@@ -360,60 +435,38 @@ function analyzePattern(pattern, key, seenBindingNames) {
           properties,
           rest
         } = pattern;
+        const {
+          conditions: propertyConditions,
+          bindings
+        } = analyzeProperties(key, pattern, seenBindingNames, properties, rest);
         const conditions = [{
           type: 'object',
           key
-        }];
-        const bindings = [];
-        const objKeys = [];
-        const seenNames = new Set();
-        properties.forEach(prop => {
-          const {
-            key: objKey,
-            pattern: propPattern
-          } = prop;
-          objKeys.push(objKey);
-          const name = objKeyToString(objKey);
-
-          if (seenNames.has(name)) {
-            throw (0, _createSyntaxError.createSyntaxError)(propPattern, `Duplicate property name '${name}' in match object pattern.`);
-          }
-
-          seenNames.add(name);
-          const propKey = key.concat(objKey);
+        }, ...propertyConditions];
+        return {
+          conditions,
+          bindings
+        };
+      }
 
-          if (needsPropExistsCond(propPattern)) {
-            conditions.push({
-              type: 'prop-exists',
-              key,
-              propName: name
-            });
+    case 'MatchInstancePattern':
+      {
+        const {
+          targetConstructor,
+          properties: {
+            properties,
+            rest
           }
-
-          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
-          });
-        }
-
+        } = pattern;
+        const {
+          conditions: propertyConditions,
+          bindings
+        } = analyzeProperties(key, pattern, seenBindingNames, properties, rest);
+        const conditions = [{
+          type: 'instanceof',
+          key,
+          constructor: constructorExpression(targetConstructor)
+        }, ...propertyConditions];
         return {
           conditions,
           bindings
@@ -567,6 +620,21 @@ function testsOfCondition(root, condition) {
         return [(0, _Builders.disjunction)([(0, _Builders.conjunction)([typeofObject, notNull]), typeofFunction])];
       }
 
+    case 'instanceof':
+      {
+        const {
+          key,
+          constructor
+        } = condition;
+        return [{
+          type: 'BinaryExpression',
+          left: expressionOfKey(root, key),
+          right: constructor,
+          operator: 'instanceof',
+          ...(0, _Builders.etc)()
+        }];
+      }
+
     case 'prop-exists':
       {
         // <propName> in <x>
@@ -968,7 +1036,7 @@ function mapMatchStatement(node) {
 function transformProgram(program, _options) {
   // Initialize so each file transformed starts freshly incrementing the
   // variable name counter, and has its own usage tracking.
-  GenID = (0, _GenID.createGenID)('m');
+  genID = new _GenID.default('m');
   return _SimpleTransform.SimpleTransform.transformProgram(program, {
     transform(node) {
       switch (node.type) {
@@ -987,11 +1055,11 @@ function transformProgram(program, _options) {
             // 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;
           }
 

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