hermes-parser 0.32.1 → 0.33.1

package/dist/HermesParserWASM.js.flow

@@ -44,7 +44,16 @@ export type HermesParserWASM = $ReadOnly<{
     (
       'hermesParse',
       'number',
-      ['number', 'number', 'number', 'number', 'number', 'number', 'number'],
+      [
+        'number',
+        'number',
+        'number',
+        'number',
+        'number',
+        'number',
+        'number',
+        'number',
+      ],
     ): (
       number,
       number,
@@ -53,6 +62,7 @@ export type HermesParserWASM = $ReadOnly<{
       CBoolean,
       CBoolean,
       CBoolean,
+      CBoolean,
     ) => number,
     ('hermesParseResult_free', 'void', ['number']): number => void,
     ('hermesParseResult_getError', 'string', ['number']): number => string,

package/dist/ParserOptions.js

@@ -14,5 +14,5 @@ exports.ParserOptionsKeys = void 0;
  * 
  * @format
  */
-const ParserOptionsKeys = new Set(['allowReturnOutsideFunction', 'babel', 'flow', 'enableExperimentalComponentSyntax', 'enableExperimentalFlowMatchSyntax', 'reactRuntimeTarget', 'sourceFilename', 'sourceType', 'tokens', 'transformOptions']);
+const ParserOptionsKeys = new Set(['allowReturnOutsideFunction', 'babel', 'flow', 'enableExperimentalComponentSyntax', 'enableExperimentalFlowMatchSyntax', 'enableExperimentalFlowRecordSyntax', 'reactRuntimeTarget', 'sourceFilename', 'sourceType', 'tokens', 'transformOptions']);
 exports.ParserOptionsKeys = ParserOptionsKeys;

package/dist/ParserOptions.js.flow

@@ -16,6 +16,7 @@ export type ParserOptions = {
   flow?: 'all' | 'detect',
   enableExperimentalComponentSyntax?: boolean,
   enableExperimentalFlowMatchSyntax?: boolean,
+  enableExperimentalFlowRecordSyntax?: boolean,
   reactRuntimeTarget?: '18' | '19',
   sourceFilename?: string,
   sourceType?: 'module' | 'script' | 'unambiguous',
@@ -33,6 +34,7 @@ export const ParserOptionsKeys: $ReadOnlySet<$Keys<ParserOptions>> = new Set([
   'flow',
   'enableExperimentalComponentSyntax',
   'enableExperimentalFlowMatchSyntax',
+  'enableExperimentalFlowRecordSyntax',
   'reactRuntimeTarget',
   'sourceFilename',
   'sourceType',

package/dist/babel/TransformESTreeToBabel.js

@@ -30,6 +30,8 @@ const FlowESTreeAndBabelVisitorKeys = { ..._ESTreeVisitorKeys.default,
   BigIntLiteral: [],
   BlockStatement: ['directives', ..._ESTreeVisitorKeys.default.BlockStatement],
   BooleanLiteral: [],
+  ClassExpression: ['superTypeParameters', ..._ESTreeVisitorKeys.default.ClassExpression],
+  ClassDeclaration: ['superTypeParameters', ..._ESTreeVisitorKeys.default.ClassDeclaration],
   ClassMethod: ['key', 'params', 'body', 'returnType', 'typeParameters'],
   ClassPrivateMethod: ['key', 'params', 'body', 'returnType', 'typeParameters'],
   ClassProperty: ['key', 'value', 'typeAnnotation', 'variance'],
@@ -50,6 +52,7 @@ const FlowESTreeAndBabelVisitorKeys = { ..._ESTreeVisitorKeys.default,
   RegExpLiteral: [],
   RestElement: [..._ESTreeVisitorKeys.default.RestElement, 'typeAnnotation'],
   StringLiteral: [],
+  TupleTypeAnnotation: ['types'],
   CommentBlock: [],
   CommentLine: []
 };
@@ -821,10 +824,74 @@ function transformNode(node) {
     case 'TupleTypeAnnotation':
       {
         // $FlowExpectedError[cannot-write]
-        delete node.inexact;
+        delete node.inexact; // $FlowExpectedError[prop-missing]
+
+        node.types = node.elementTypes; // $FlowExpectedError[cannot-write]
+
+        delete node.elementTypes;
         return node;
       }
 
+    case 'UnknownTypeAnnotation':
+      {
+        return {
+          type: 'GenericTypeAnnotation',
+          id: {
+            type: 'Identifier',
+            name: 'unknown',
+            optional: false,
+            typeAnnotation: null,
+            loc: node.loc,
+            range: node.range,
+            parent: EMPTY_PARENT
+          },
+          typeParameters: null,
+          loc: node.loc,
+          range: node.range,
+          parent: EMPTY_PARENT
+        };
+      }
+
+    case 'NeverTypeAnnotation':
+      {
+        return {
+          type: 'GenericTypeAnnotation',
+          id: {
+            type: 'Identifier',
+            name: 'never',
+            optional: false,
+            typeAnnotation: null,
+            loc: node.loc,
+            range: node.range,
+            parent: EMPTY_PARENT
+          },
+          typeParameters: null,
+          loc: node.loc,
+          range: node.range,
+          parent: EMPTY_PARENT
+        };
+      }
+
+    case 'UndefinedTypeAnnotation':
+      {
+        return {
+          type: 'GenericTypeAnnotation',
+          id: {
+            type: 'Identifier',
+            name: 'undefined',
+            optional: false,
+            typeAnnotation: null,
+            loc: node.loc,
+            range: node.range,
+            parent: EMPTY_PARENT
+          },
+          typeParameters: null,
+          loc: node.loc,
+          range: node.range,
+          parent: EMPTY_PARENT
+        };
+      }
+
     case 'JSXText':
       {
         // $FlowExpectedError[prop-missing]
@@ -987,9 +1054,15 @@ function transformNode(node) {
           delete node.implements;
         }
 
-        if (node.superTypeParameters == null) {
+        if (node.superTypeArguments == null) {
+          // $FlowExpectedError[cannot-write]
+          delete node.superTypeArguments;
+        } else {
           // $FlowExpectedError[cannot-write]
-          delete node.superTypeParameters;
+          // $FlowExpectedError[prop-missing]
+          node.superTypeParameters = node.superTypeArguments; // $FlowExpectedError[cannot-write]
+
+          delete node.superTypeArguments;
         }
 
         if (node.typeParameters == null) {

package/dist/babel/TransformESTreeToBabel.js.flow

@@ -59,6 +59,11 @@ const FlowESTreeAndBabelVisitorKeys: VisitorKeys = {
   BigIntLiteral: [],
   BlockStatement: ['directives', ...FlowVisitorKeys.BlockStatement],
   BooleanLiteral: [],
+  ClassExpression: ['superTypeParameters', ...FlowVisitorKeys.ClassExpression],
+  ClassDeclaration: [
+    'superTypeParameters',
+    ...FlowVisitorKeys.ClassDeclaration,
+  ],
   ClassMethod: ['key', 'params', 'body', 'returnType', 'typeParameters'],
   ClassPrivateMethod: ['key', 'params', 'body', 'returnType', 'typeParameters'],
   ClassProperty: ['key', 'value', 'typeAnnotation', 'variance'],
@@ -85,6 +90,7 @@ const FlowESTreeAndBabelVisitorKeys: VisitorKeys = {
   RegExpLiteral: [],
   RestElement: [...FlowVisitorKeys.RestElement, 'typeAnnotation'],
   StringLiteral: [],
+  TupleTypeAnnotation: ['types'],
   CommentBlock: [],
   CommentLine: [],
 };
@@ -1040,9 +1046,68 @@ function transformNode(node: ESNodeOrBabelNode): ESNodeOrBabelNode | null {
     case 'TupleTypeAnnotation': {
       // $FlowExpectedError[cannot-write]
       delete node.inexact;
+      // $FlowExpectedError[prop-missing]
+      node.types = node.elementTypes;
+      // $FlowExpectedError[cannot-write]
+      delete node.elementTypes;
       return node;
     }
 
+    case 'UnknownTypeAnnotation': {
+      return {
+        type: 'GenericTypeAnnotation',
+        id: {
+          type: 'Identifier',
+          name: 'unknown',
+          optional: false,
+          typeAnnotation: null,
+          loc: node.loc,
+          range: node.range,
+          parent: EMPTY_PARENT,
+        },
+        typeParameters: null,
+        loc: node.loc,
+        range: node.range,
+        parent: EMPTY_PARENT,
+      };
+    }
+    case 'NeverTypeAnnotation': {
+      return {
+        type: 'GenericTypeAnnotation',
+        id: {
+          type: 'Identifier',
+          name: 'never',
+          optional: false,
+          typeAnnotation: null,
+          loc: node.loc,
+          range: node.range,
+          parent: EMPTY_PARENT,
+        },
+        typeParameters: null,
+        loc: node.loc,
+        range: node.range,
+        parent: EMPTY_PARENT,
+      };
+    }
+    case 'UndefinedTypeAnnotation': {
+      return {
+        type: 'GenericTypeAnnotation',
+        id: {
+          type: 'Identifier',
+          name: 'undefined',
+          optional: false,
+          typeAnnotation: null,
+          loc: node.loc,
+          range: node.range,
+          parent: EMPTY_PARENT,
+        },
+        typeParameters: null,
+        loc: node.loc,
+        range: node.range,
+        parent: EMPTY_PARENT,
+      };
+    }
+
     case 'JSXText': {
       // $FlowExpectedError[prop-missing]
       node.extra = {
@@ -1167,9 +1232,15 @@ function transformNode(node: ESNodeOrBabelNode): ESNodeOrBabelNode | null {
         // $FlowExpectedError[cannot-write]
         delete node.implements;
       }
-      if (node.superTypeParameters == null) {
+      if (node.superTypeArguments == null) {
+        // $FlowExpectedError[cannot-write]
+        delete node.superTypeArguments;
+      } else {
+        // $FlowExpectedError[cannot-write]
+        // $FlowExpectedError[prop-missing]
+        node.superTypeParameters = node.superTypeArguments;
         // $FlowExpectedError[cannot-write]
-        delete node.superTypeParameters;
+        delete node.superTypeArguments;
       }
       if (node.typeParameters == null) {
         // $FlowExpectedError[cannot-write]

package/dist/estree/StripFlowTypes.js

@@ -117,7 +117,7 @@ function transformProgram(program, _options) {
           {
             return nodeWith(node, {
               typeParameters: null,
-              superTypeParameters: null,
+              superTypeArguments: null,
               implements: [],
               decorators: []
             });

package/dist/estree/StripFlowTypes.js.flow

@@ -105,7 +105,7 @@ export function transformProgram(
         case 'ClassExpression': {
           return nodeWith(node, {
             typeParameters: null,
-            superTypeParameters: null,
+            superTypeArguments: null,
             implements: [],
             decorators: [],
           });

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