flow-parser 0.328.0 → 0.329.0

package/README.md

@@ -28,3 +28,44 @@ The Flow parser exposes a single `parse(code, [options])` function, where `code`
   - `TransformEnumSyntax`
     - `enable`: `boolean` - Whether to enable the transform. By default, `false`.
     - `getRuntime` (optional): `() => Expression` - The expression which should be a reference to the Flow Enums runtime. By default, is `require('flow-enums-runtime')`.
+
+## Babel plugin
+
+Flow parser plugin for [Babel](https://babeljs.io/). This plugin switches Babel to use `flow-parser` instead of the `@babel/parser`. The Flow parser uses Rust compiled to WASM for full Flow syntax support.
+
+### Install
+
+Using npm:
+
+```sh
+npm install --save-dev flow-parser
+```
+
+or using yarn:
+
+```sh
+yarn add flow-parser --dev
+```
+
+### Usage
+
+The plugin can be enabled via:
+
+```
+// babel.config.json
+{
+  "plugins": ["flow-parser/babel-plugin"]
+}
+```
+
+If parser options need to be provide you can do so via the `parserOpts` config:
+
+```
+// babel.config.json
+{
+  "plugins": ["flow-parser/babel-plugin"],
+  "parserOpts": {
+    "allowReturnOutsideFunction": true
+  }
+}
+```

package/dist/FlowParser.js

@@ -12,6 +12,12 @@ function _interopRequireDefault(e) {
     default: e
   };
 }
+function asWireNode(value) {
+  if (value == null || typeof value !== 'object') {
+    return null;
+  }
+  return value;
+}
 let FlowParserWASM;
 let flowParse;
 let flowParseResult_free;
@@ -22,6 +28,7 @@ let flowParseResult_getProgramBuffer;
 let flowParseResult_getPositionBuffer;
 let flowParseResult_getPositionBufferSize;
 let flowParseResult_getStringBuffer;
+const BABEL_LOWERING_ERROR_PREFIX = '$FlowBabelLoweringError$';
 function initFlowParserWASM() {
   if (FlowParserWASM != null) {
     return;
@@ -31,7 +38,7 @@ function initFlowParserWASM() {
       throw toThrow;
     }
   });
-  flowParse = FlowParserWASM.cwrap('hermesParse', 'number', ['number', 'number', 'number', 'number', 'number', 'number', 'number', 'number', 'number', 'number', 'number', 'number', 'number', 'number', 'number', 'number']);
+  flowParse = FlowParserWASM.cwrap('hermesParse', 'number', ['number', 'number', 'number', 'number', 'number', 'number', 'number', 'number', 'number', 'number', 'number', 'number', 'number', 'number', 'number', 'number', 'number', 'number', 'number', 'number', 'number']);
   flowParseResult_free = FlowParserWASM.cwrap('hermesParseResult_free', 'void', ['number']);
   flowParseResult_getError = FlowParserWASM.cwrap('hermesParseResult_getError', 'string', ['number']);
   flowParseResult_getErrorLine = FlowParserWASM.cwrap('hermesParseResult_getErrorLine', 'number', ['number']);
@@ -58,6 +65,7 @@ function parse(source, options) {
   let filenameLen = 0;
   let parseResult = 0;
   try {
+    var _options$transformOpt, _options$transformOpt2, _options$transformOpt3, _options$transformOpt4;
     sourceAddr = FlowParserWASM._malloc(sourceBuffer.length + 1);
     if (!sourceAddr) {
       throw new Error('Parser out of memory');
@@ -73,7 +81,28 @@ function parse(source, options) {
     copyToHeap(sourceBuffer, sourceAddr);
     const enableTypes = options.enableTypes === false ? 0 : 1;
     const sourceTypeCode = options.sourceType === 'script' ? 1 : options.sourceType === 'module' ? 2 : 0;
-    parseResult = flowParse(sourceAddr, sourceBuffer.length + 1, filenameAddr, filenameLen, flag(options.enableExperimentalComponentSyntax), flag(options.enableExperimentalFlowMatchSyntax), flag(options.enableExperimentalDecorators), flag(options.tokens), flag(options.allowReturnOutsideFunction), flag(options.assertOperator), flag(options.enableEnums), flag(options.enableRecords), enableTypes, sourceTypeCode, flag(options.enableTypesPragmaDetection), 0);
+    parseResult = flowParse(sourceAddr, sourceBuffer.length + 1, filenameAddr, filenameLen, flag(options.enableExperimentalComponentSyntax), flag(options.enableExperimentalFlowMatchSyntax), flag(options.enableExperimentalDecorators), flag(options.tokens), flag(options.allowReturnOutsideFunction), flag(options.assertOperator), flag(options.enableEnums), flag(options.enableRecords), enableTypes, sourceTypeCode, flag(options.enableTypesPragmaDetection), 0, flag(options.babel), flag((_options$transformOpt = options.transformOptions) == null ? void 0 : (_options$transformOpt2 = _options$transformOpt.TransformEnumSyntax) == null ? void 0 : _options$transformOpt2.enable), flag(((_options$transformOpt3 = options.transformOptions) == null ? void 0 : (_options$transformOpt4 = _options$transformOpt3.TransformEnumSyntax) == null ? void 0 : _options$transformOpt4.getRuntime) != null), options.reactRuntimeTarget === '19' ? 19 : 18, options.throwOnParseErrors === false ? 0 : 1);
+    if (options.babel === true) {
+      const error = flowParseResult_getError(parseResult);
+      const line = flowParseResult_getErrorLine(parseResult);
+      const column = flowParseResult_getErrorColumn(parseResult);
+      if (error != null && error.startsWith(BABEL_LOWERING_ERROR_PREFIX)) {
+        const syntaxError = new SyntaxError(error.slice(BABEL_LOWERING_ERROR_PREFIX.length));
+        syntaxError.loc = {
+          line,
+          column
+        };
+        throw syntaxError;
+      }
+      if (error != null && error.length > 0 && options.throwOnParseErrors !== false) {
+        const syntaxError = new SyntaxError(`${error} (${line}:${column})`);
+        syntaxError.loc = {
+          line,
+          column
+        };
+        throw syntaxError;
+      }
+    }
     const programBuffer = flowParseResult_getProgramBuffer(parseResult);
     if (!programBuffer) {
       const err = flowParseResult_getError(parseResult);
@@ -84,19 +113,25 @@ function parse(source, options) {
       };
       throw syntaxError;
     }
-    const deserializer = new _FlowParserDeserializer.default(programBuffer, flowParseResult_getPositionBuffer(parseResult), flowParseResult_getPositionBufferSize(parseResult), flowParseResult_getStringBuffer(parseResult), FlowParserWASM, options);
-    const ast = deserializer.deserialize();
-    if (ast.type !== 'Program') {
-      throw new Error(`Expected Program, got ${ast.type}`);
+    const deserialized = new _FlowParserDeserializer.default(programBuffer, flowParseResult_getPositionBuffer(parseResult), flowParseResult_getPositionBufferSize(parseResult), flowParseResult_getStringBuffer(parseResult), FlowParserWASM, options).deserialize();
+    if (options.babel === true) {
+      if (deserialized.type !== 'File') {
+        throw new Error(`Expected File, got ${deserialized.type}`);
+      }
+      return deserialized;
+    }
+    if (deserialized.type !== 'Program') {
+      throw new Error(`Expected Program, got ${deserialized.type}`);
     }
+    const ast = deserialized;
     const sourceFilename = typeof options.sourceFilename === 'string' ? options.sourceFilename : null;
     const visitedNodes = new WeakSet();
     const locRanges = new WeakMap();
     function fixLocs(node) {
-      if (node == null || typeof node !== 'object') {
+      const wireNode = asWireNode(node);
+      if (wireNode == null) {
         return;
       }
-      const wireNode = node;
       if (visitedNodes.has(wireNode)) {
         return;
       }
@@ -168,8 +203,7 @@ function parse(source, options) {
   }
 }
 function asProgram(ast) {
-  const program = ast;
-  return program;
+  return ast;
 }
 function detectSourceType(program) {
   if (!Array.isArray(program.body)) {

package/dist/FlowParser.js.flow

@@ -14,6 +14,7 @@ import type {Program} from 'flow-estree';
 import type {ParserOptions} from './ParserOptions';
 import type {FlowParserProgram} from './FlowParserDeserializer';
 import type {FlowParserWASM as FlowParserWASMType} from './FlowParserWASM';
+import type {BabelFile} from './babel/BabelAST';
 
 import FlowParserDeserializer from './FlowParserDeserializer';
 import FlowParserWASMModule from './FlowParserWASM';
@@ -36,6 +37,11 @@ type FlowParse = (
   number,
   number,
   number,
+  number,
+  number,
+  number,
+  number,
+  number,
 ) => number;
 
 type WireSourceLocation = {
@@ -53,6 +59,15 @@ type WireNode = {
   [string]: unknown,
 };
 
+function asWireNode(value: unknown): ?WireNode {
+  if (value == null || typeof value !== 'object') {
+    return null;
+  }
+  // $FlowExpectedError[incompatible-type] Dynamic binary-schema envelope.
+  // $FlowExpectedError[incompatible-variance] Dynamic binary-schema envelope.
+  return value;
+}
+
 let FlowParserWASM: FlowParserWASMType;
 let flowParse: FlowParse;
 let flowParseResult_free: number => void;
@@ -64,6 +79,8 @@ let flowParseResult_getPositionBuffer: number => number;
 let flowParseResult_getPositionBufferSize: number => number;
 let flowParseResult_getStringBuffer: number => number;
 
+const BABEL_LOWERING_ERROR_PREFIX = '$FlowBabelLoweringError$';
+
 /**
  * Init the WASM wrapper code generated by `emscripten` for the
  * Flow Rust parser WASM binary.
@@ -113,6 +130,11 @@ function initFlowParserWASM(): void {
     'number',
     'number',
     'number',
+    'number',
+    'number',
+    'number',
+    'number',
+    'number',
   ]);
 
   flowParseResult_free = FlowParserWASM.cwrap(
@@ -178,7 +200,7 @@ function flag(v: unknown): 0 | 1 {
   return v === true ? 1 : 0;
 }
 
-function parse(source: string, options: ParserOptions): Program {
+function parse(source: string, options: ParserOptions): Program | BabelFile {
   initFlowParserWASM();
 
   const sourceBuffer = Buffer.from(source, 'utf8');
@@ -265,8 +287,37 @@ function parse(source: string, options: ParserOptions): Program {
       // `enableTypes` directly.
       flag(options.enableTypesPragmaDetection),
       0,
+      flag(options.babel),
+      flag(options.transformOptions?.TransformEnumSyntax?.enable),
+      flag(options.transformOptions?.TransformEnumSyntax?.getRuntime != null),
+      options.reactRuntimeTarget === '19' ? 19 : 18,
+      options.throwOnParseErrors === false ? 0 : 1,
     );
 
+    if (options.babel === true) {
+      const error = flowParseResult_getError(parseResult);
+      const line = flowParseResult_getErrorLine(parseResult);
+      const column = flowParseResult_getErrorColumn(parseResult);
+      if (error?.startsWith(BABEL_LOWERING_ERROR_PREFIX)) {
+        const syntaxError = new SyntaxError(
+          error.slice(BABEL_LOWERING_ERROR_PREFIX.length),
+        );
+        // $FlowExpectedError[prop-missing] SyntaxError loc is a parser extension.
+        syntaxError.loc = {line, column};
+        throw syntaxError;
+      }
+      if (
+        error != null &&
+        error.length > 0 &&
+        options.throwOnParseErrors !== false
+      ) {
+        const syntaxError = new SyntaxError(`${error} (${line}:${column})`);
+        // $FlowExpectedError[prop-missing] SyntaxError loc is a parser extension.
+        syntaxError.loc = {line, column};
+        throw syntaxError;
+      }
+    }
+
     // The Rust parser always returns a (possibly partial) AST plus an
     // error list, mirroring the OCaml behaviour. Errors are surfaced as
     // `program.errors` by the deserializer; only fall back to throwing if
@@ -283,18 +334,24 @@ function parse(source: string, options: ParserOptions): Program {
       throw syntaxError;
     }
 
-    const deserializer = new FlowParserDeserializer(
+    const deserialized = new FlowParserDeserializer(
       programBuffer,
       flowParseResult_getPositionBuffer(parseResult),
       flowParseResult_getPositionBufferSize(parseResult),
       flowParseResult_getStringBuffer(parseResult),
       FlowParserWASM,
       options,
-    );
-    const ast = deserializer.deserialize();
-    if (ast.type !== 'Program') {
-      throw new Error(`Expected Program, got ${ast.type}`);
+    ).deserialize();
+    if (options.babel === true) {
+      if (deserialized.type !== 'File') {
+        throw new Error(`Expected File, got ${deserialized.type}`);
+      }
+      return deserialized;
+    }
+    if (deserialized.type !== 'Program') {
+      throw new Error(`Expected Program, got ${deserialized.type}`);
     }
+    const ast = deserialized;
 
     // Wire→ESTree loc/range normalization. The wire format carries
     // `rangeStart` / `rangeEnd` on the loc object; ESTree consumers expect a
@@ -318,12 +375,10 @@ function parse(source: string, options: ParserOptions): Program {
     const locRanges: WeakMap<WireSourceLocation, [number, number]> =
       new WeakMap();
     function fixLocs(node: unknown): void {
-      if (node == null || typeof node !== 'object') {
+      const wireNode = asWireNode(node);
+      if (wireNode == null) {
         return;
       }
-      // $FlowFixMe[incompatible-variance] Dynamic ESTree serializer object.
-      // $FlowFixMe[incompatible-type] Dynamic ESTree serializer object.
-      const wireNode: WireNode = node;
       if (visitedNodes.has(wireNode)) {
         return;
       }
@@ -423,8 +478,8 @@ function asProgram(ast: FlowParserProgram): Program {
   // FlowParserProgram is the deserialized wire shape. `fixLocs` above mutates
   // that shape into the public ESTree Program shape, including loc/range
   // fields that Flow cannot prove from the serializer protocol.
-  const program: $FlowFixMe = ast;
-  return program;
+  // $FlowExpectedError[incompatible-type] Normalized binary-schema boundary.
+  return ast;
 }
 
 function detectSourceType(program: FlowParserProgram): 'script' | 'module' {

package/dist/FlowParserDeserializer.js

@@ -11,6 +11,7 @@ function _interopRequireDefault(e) {
     default: e
   };
 }
+const LOCATION_IDENTIFIER_NAME = 1 << 0;
 class FlowParserDeserializer {
   constructor(programBuffer, positionBuffer, positionBufferSize, stringBufferBase, wasmParser, options) {
     this.programBufferIdx = void 0;
@@ -18,10 +19,13 @@ class FlowParserDeserializer {
     this.positionBufferSize = void 0;
     this.stringBufferBase = void 0;
     this.locMap = void 0;
+    this.extendedPositions = void 0;
+    this.extendedRanges = void 0;
     this.HEAPU8 = void 0;
     this.HEAPU32 = void 0;
     this.HEAPF64 = void 0;
     this.options = void 0;
+    this.extendedLocationHeaders = void 0;
     this.commentTypes = ['Block', 'Line'];
     this.tokenTypes = ['Boolean', 'Identifier', 'Keyword', 'Null', 'Numeric', 'BigInt', 'Punctuator', 'String', 'RegularExpression', 'Template', 'JSXText'];
     this.programBufferIdx = programBuffer / 4;
@@ -29,21 +33,36 @@ class FlowParserDeserializer {
     this.positionBufferSize = positionBufferSize;
     this.stringBufferBase = stringBufferBase;
     this.locMap = {};
+    this.extendedPositions = [];
+    this.extendedRanges = new WeakMap();
     this.HEAPU8 = wasmParser.HEAPU8;
     this.HEAPU32 = wasmParser.HEAPU32;
     this.HEAPF64 = wasmParser.HEAPF64;
     this.options = options;
+    this.extendedLocationHeaders = false;
   }
   next() {
     const num = this.HEAPU32[this.programBufferIdx++];
     return num;
   }
   deserialize() {
+    if (this.HEAPU32[this.programBufferIdx] === 0) {
+      return this.deserializeESTreeProgram();
+    }
+    this.extendedLocationHeaders = true;
+    this.prepareExtendedPositions();
+    const root = this.deserializeNode();
+    if (root == null) {
+      throw new Error('Expected serialized parser root');
+    }
+    return root;
+  }
+  deserializeESTreeProgram() {
     const program = {
       type: 'Program',
       loc: this.addEmptyLoc(),
       body: this.deserializeNodeList(),
-      comments: this.deserializeComments()
+      comments: this.deserializeESTreeComments()
     };
     program.interpreter = this.deserializeNode();
     if (this.options.tokens === true) {
@@ -98,8 +117,15 @@ class FlowParserDeserializer {
     if (nodeType === 0) {
       return null;
     }
-    const nodeDeserializer = _FlowParserNodeDeserializers.default[nodeType - 1].bind(this);
-    return nodeDeserializer();
+    const deserializeNode = _FlowParserNodeDeserializers.default[nodeType - 1];
+    if (deserializeNode == null) {
+      throw new Error(`Unknown serialized node kind ${nodeType - 1} at program word ${this.programBufferIdx - 1}`);
+    }
+    const node = deserializeNode.call(this);
+    if (this.extendedLocationHeaders) {
+      this.addExtendedRange(node);
+    }
+    return node;
   }
   deserializeNodeList() {
     const size = this.next();
@@ -109,18 +135,44 @@ class FlowParserDeserializer {
     }
     return nodeList;
   }
+  deserializeEnumRuntime() {
+    var _this$options$transfo, _this$options$transfo2;
+    const getRuntime = (_this$options$transfo = this.options.transformOptions) == null ? void 0 : (_this$options$transfo2 = _this$options$transfo.TransformEnumSyntax) == null ? void 0 : _this$options$transfo2.getRuntime;
+    if (typeof getRuntime !== 'function') {
+      throw new Error('Expected TransformEnumSyntax.getRuntime callback');
+    }
+    return getRuntime();
+  }
   deserializeComments() {
     const size = this.next();
     const comments = [];
     for (let i = 0; i < size; i++) {
-      const commentType = this.commentTypes[this.next()];
+      const commentType = this.deserializeString();
+      if (commentType == null) {
+        throw new Error('Expected serialized comment type');
+      }
       const loc = this.addEmptyLoc();
-      const value = this.deserializeString();
-      comments.push({
+      const comment = {
         type: commentType,
         loc,
-        value
-      });
+        value: this.deserializeString()
+      };
+      this.addExtendedRange(comment);
+      comments.push(comment);
+    }
+    return comments;
+  }
+  deserializeESTreeComments() {
+    const size = this.next();
+    const comments = [];
+    for (let i = 0; i < size; i++) {
+      const commentType = this.commentTypes[this.next()];
+      const comment = {
+        type: commentType,
+        loc: this.addEmptyLoc(),
+        value: this.deserializeString()
+      };
+      comments.push(comment);
     }
     return comments;
   }
@@ -131,19 +183,78 @@ class FlowParserDeserializer {
       const tokenType = this.tokenTypes[this.next()];
       const loc = this.addEmptyLoc();
       const value = this.deserializeString();
-      tokens.push({
+      const token = {
         type: tokenType,
         loc,
         value
-      });
+      };
+      tokens.push(token);
     }
     return tokens;
   }
   addEmptyLoc() {
+    const locId = this.next();
+    if (this.extendedLocationHeaders) {
+      const flags = this.next();
+      const position = this.extendedPositions[locId];
+      if (position == null) {
+        throw new Error(`Missing serialized extended location ${locId}`);
+      }
+      const loc = position.loc;
+      if (flags & LOCATION_IDENTIFIER_NAME) {
+        const identifierName = this.deserializeString();
+        if (identifierName != null) {
+          loc.identifierName = identifierName;
+        }
+      }
+      this.extendedRanges.set(loc, position);
+      return loc;
+    }
     const loc = {};
-    this.locMap[this.next()] = loc;
+    this.locMap[locId] = loc;
     return loc;
   }
+  prepareExtendedPositions() {
+    let index = this.positionBufferIdx;
+    for (let i = 0; i < this.positionBufferSize; i++) {
+      var _this$extendedPositio;
+      const locId = this.HEAPU32[index++];
+      const kind = this.HEAPU32[index++];
+      const line = this.HEAPU32[index++];
+      const column = this.HEAPU32[index++];
+      const offset = this.HEAPU32[index++];
+      const position = (_this$extendedPositio = this.extendedPositions[locId]) != null ? _this$extendedPositio : {
+        loc: {},
+        start: 0,
+        end: 0
+      };
+      if (kind === 0) {
+        position.loc.start = {
+          line,
+          column
+        };
+        position.start = offset;
+      } else {
+        position.loc.end = {
+          line,
+          column
+        };
+        position.end = offset;
+      }
+      this.extendedPositions[locId] = position;
+    }
+  }
+  addExtendedRange(owner) {
+    if (owner.loc == null) {
+      return;
+    }
+    const position = this.extendedRanges.get(owner.loc);
+    if (position == null) {
+      return;
+    }
+    owner.start = position.start;
+    owner.end = position.end;
+  }
   fillLocs() {
     for (let i = 0; i < this.positionBufferSize; i++) {
       const locId = this.HEAPU32[this.positionBufferIdx++];
@@ -152,6 +263,9 @@ class FlowParserDeserializer {
       const column = this.HEAPU32[this.positionBufferIdx++];
       const offset = this.HEAPU32[this.positionBufferIdx++];
       const loc = this.locMap[locId];
+      if (loc == null) {
+        throw new Error(`Missing serialized location ${locId}`);
+      }
       if (kind === 0) {
         loc.start = {
           line,