hermes-parser 0.32.0 → 0.33.0

package/dist/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/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: {