fediversity.eu/node_modules/sucrase/dist/parser/plugins/flow.js

1106 lines
38 KiB
JavaScript
Raw Normal View History

2024-03-26 16:28:28 +01:00
"use strict";Object.defineProperty(exports, "__esModule", {value: true});/* eslint max-len: 0 */
var _index = require('../tokenizer/index');
var _keywords = require('../tokenizer/keywords');
var _types = require('../tokenizer/types');
var _base = require('../traverser/base');
var _expression = require('../traverser/expression');
var _statement = require('../traverser/statement');
var _util = require('../traverser/util');
function isMaybeDefaultImport(lookahead) {
return (
(lookahead.type === _types.TokenType.name || !!(lookahead.type & _types.TokenType.IS_KEYWORD)) &&
lookahead.contextualKeyword !== _keywords.ContextualKeyword._from
);
}
function flowParseTypeInitialiser(tok) {
const oldIsType = _index.pushTypeContext.call(void 0, 0);
_util.expect.call(void 0, tok || _types.TokenType.colon);
flowParseType();
_index.popTypeContext.call(void 0, oldIsType);
}
function flowParsePredicate() {
_util.expect.call(void 0, _types.TokenType.modulo);
_util.expectContextual.call(void 0, _keywords.ContextualKeyword._checks);
if (_index.eat.call(void 0, _types.TokenType.parenL)) {
_expression.parseExpression.call(void 0, );
_util.expect.call(void 0, _types.TokenType.parenR);
}
}
function flowParseTypeAndPredicateInitialiser() {
const oldIsType = _index.pushTypeContext.call(void 0, 0);
_util.expect.call(void 0, _types.TokenType.colon);
if (_index.match.call(void 0, _types.TokenType.modulo)) {
flowParsePredicate();
} else {
flowParseType();
if (_index.match.call(void 0, _types.TokenType.modulo)) {
flowParsePredicate();
}
}
_index.popTypeContext.call(void 0, oldIsType);
}
function flowParseDeclareClass() {
_index.next.call(void 0, );
flowParseInterfaceish(/* isClass */ true);
}
function flowParseDeclareFunction() {
_index.next.call(void 0, );
_expression.parseIdentifier.call(void 0, );
if (_index.match.call(void 0, _types.TokenType.lessThan)) {
flowParseTypeParameterDeclaration();
}
_util.expect.call(void 0, _types.TokenType.parenL);
flowParseFunctionTypeParams();
_util.expect.call(void 0, _types.TokenType.parenR);
flowParseTypeAndPredicateInitialiser();
_util.semicolon.call(void 0, );
}
function flowParseDeclare() {
if (_index.match.call(void 0, _types.TokenType._class)) {
flowParseDeclareClass();
} else if (_index.match.call(void 0, _types.TokenType._function)) {
flowParseDeclareFunction();
} else if (_index.match.call(void 0, _types.TokenType._var)) {
flowParseDeclareVariable();
} else if (_util.eatContextual.call(void 0, _keywords.ContextualKeyword._module)) {
if (_index.eat.call(void 0, _types.TokenType.dot)) {
flowParseDeclareModuleExports();
} else {
flowParseDeclareModule();
}
} else if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._type)) {
flowParseDeclareTypeAlias();
} else if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._opaque)) {
flowParseDeclareOpaqueType();
} else if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._interface)) {
flowParseDeclareInterface();
} else if (_index.match.call(void 0, _types.TokenType._export)) {
flowParseDeclareExportDeclaration();
} else {
_util.unexpected.call(void 0, );
}
}
function flowParseDeclareVariable() {
_index.next.call(void 0, );
flowParseTypeAnnotatableIdentifier();
_util.semicolon.call(void 0, );
}
function flowParseDeclareModule() {
if (_index.match.call(void 0, _types.TokenType.string)) {
_expression.parseExprAtom.call(void 0, );
} else {
_expression.parseIdentifier.call(void 0, );
}
_util.expect.call(void 0, _types.TokenType.braceL);
while (!_index.match.call(void 0, _types.TokenType.braceR) && !_base.state.error) {
if (_index.match.call(void 0, _types.TokenType._import)) {
_index.next.call(void 0, );
_statement.parseImport.call(void 0, );
} else {
_util.unexpected.call(void 0, );
}
}
_util.expect.call(void 0, _types.TokenType.braceR);
}
function flowParseDeclareExportDeclaration() {
_util.expect.call(void 0, _types.TokenType._export);
if (_index.eat.call(void 0, _types.TokenType._default)) {
if (_index.match.call(void 0, _types.TokenType._function) || _index.match.call(void 0, _types.TokenType._class)) {
// declare export default class ...
// declare export default function ...
flowParseDeclare();
} else {
// declare export default [type];
flowParseType();
_util.semicolon.call(void 0, );
}
} else if (
_index.match.call(void 0, _types.TokenType._var) || // declare export var ...
_index.match.call(void 0, _types.TokenType._function) || // declare export function ...
_index.match.call(void 0, _types.TokenType._class) || // declare export class ...
_util.isContextual.call(void 0, _keywords.ContextualKeyword._opaque) // declare export opaque ..
) {
flowParseDeclare();
} else if (
_index.match.call(void 0, _types.TokenType.star) || // declare export * from ''
_index.match.call(void 0, _types.TokenType.braceL) || // declare export {} ...
_util.isContextual.call(void 0, _keywords.ContextualKeyword._interface) || // declare export interface ...
_util.isContextual.call(void 0, _keywords.ContextualKeyword._type) || // declare export type ...
_util.isContextual.call(void 0, _keywords.ContextualKeyword._opaque) // declare export opaque type ...
) {
_statement.parseExport.call(void 0, );
} else {
_util.unexpected.call(void 0, );
}
}
function flowParseDeclareModuleExports() {
_util.expectContextual.call(void 0, _keywords.ContextualKeyword._exports);
flowParseTypeAnnotation();
_util.semicolon.call(void 0, );
}
function flowParseDeclareTypeAlias() {
_index.next.call(void 0, );
flowParseTypeAlias();
}
function flowParseDeclareOpaqueType() {
_index.next.call(void 0, );
flowParseOpaqueType(true);
}
function flowParseDeclareInterface() {
_index.next.call(void 0, );
flowParseInterfaceish();
}
// Interfaces
function flowParseInterfaceish(isClass = false) {
flowParseRestrictedIdentifier();
if (_index.match.call(void 0, _types.TokenType.lessThan)) {
flowParseTypeParameterDeclaration();
}
if (_index.eat.call(void 0, _types.TokenType._extends)) {
do {
flowParseInterfaceExtends();
} while (!isClass && _index.eat.call(void 0, _types.TokenType.comma));
}
if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._mixins)) {
_index.next.call(void 0, );
do {
flowParseInterfaceExtends();
} while (_index.eat.call(void 0, _types.TokenType.comma));
}
if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._implements)) {
_index.next.call(void 0, );
do {
flowParseInterfaceExtends();
} while (_index.eat.call(void 0, _types.TokenType.comma));
}
flowParseObjectType(isClass, false, isClass);
}
function flowParseInterfaceExtends() {
flowParseQualifiedTypeIdentifier(false);
if (_index.match.call(void 0, _types.TokenType.lessThan)) {
flowParseTypeParameterInstantiation();
}
}
function flowParseInterface() {
flowParseInterfaceish();
}
function flowParseRestrictedIdentifier() {
_expression.parseIdentifier.call(void 0, );
}
function flowParseTypeAlias() {
flowParseRestrictedIdentifier();
if (_index.match.call(void 0, _types.TokenType.lessThan)) {
flowParseTypeParameterDeclaration();
}
flowParseTypeInitialiser(_types.TokenType.eq);
_util.semicolon.call(void 0, );
}
function flowParseOpaqueType(declare) {
_util.expectContextual.call(void 0, _keywords.ContextualKeyword._type);
flowParseRestrictedIdentifier();
if (_index.match.call(void 0, _types.TokenType.lessThan)) {
flowParseTypeParameterDeclaration();
}
// Parse the supertype
if (_index.match.call(void 0, _types.TokenType.colon)) {
flowParseTypeInitialiser(_types.TokenType.colon);
}
if (!declare) {
flowParseTypeInitialiser(_types.TokenType.eq);
}
_util.semicolon.call(void 0, );
}
function flowParseTypeParameter() {
flowParseVariance();
flowParseTypeAnnotatableIdentifier();
if (_index.eat.call(void 0, _types.TokenType.eq)) {
flowParseType();
}
}
function flowParseTypeParameterDeclaration() {
const oldIsType = _index.pushTypeContext.call(void 0, 0);
// istanbul ignore else: this condition is already checked at all call sites
if (_index.match.call(void 0, _types.TokenType.lessThan) || _index.match.call(void 0, _types.TokenType.typeParameterStart)) {
_index.next.call(void 0, );
} else {
_util.unexpected.call(void 0, );
}
do {
flowParseTypeParameter();
if (!_index.match.call(void 0, _types.TokenType.greaterThan)) {
_util.expect.call(void 0, _types.TokenType.comma);
}
} while (!_index.match.call(void 0, _types.TokenType.greaterThan) && !_base.state.error);
_util.expect.call(void 0, _types.TokenType.greaterThan);
_index.popTypeContext.call(void 0, oldIsType);
} exports.flowParseTypeParameterDeclaration = flowParseTypeParameterDeclaration;
function flowParseTypeParameterInstantiation() {
const oldIsType = _index.pushTypeContext.call(void 0, 0);
_util.expect.call(void 0, _types.TokenType.lessThan);
while (!_index.match.call(void 0, _types.TokenType.greaterThan) && !_base.state.error) {
flowParseType();
if (!_index.match.call(void 0, _types.TokenType.greaterThan)) {
_util.expect.call(void 0, _types.TokenType.comma);
}
}
_util.expect.call(void 0, _types.TokenType.greaterThan);
_index.popTypeContext.call(void 0, oldIsType);
}
function flowParseInterfaceType() {
_util.expectContextual.call(void 0, _keywords.ContextualKeyword._interface);
if (_index.eat.call(void 0, _types.TokenType._extends)) {
do {
flowParseInterfaceExtends();
} while (_index.eat.call(void 0, _types.TokenType.comma));
}
flowParseObjectType(false, false, false);
}
function flowParseObjectPropertyKey() {
if (_index.match.call(void 0, _types.TokenType.num) || _index.match.call(void 0, _types.TokenType.string)) {
_expression.parseExprAtom.call(void 0, );
} else {
_expression.parseIdentifier.call(void 0, );
}
}
function flowParseObjectTypeIndexer() {
// Note: bracketL has already been consumed
if (_index.lookaheadType.call(void 0, ) === _types.TokenType.colon) {
flowParseObjectPropertyKey();
flowParseTypeInitialiser();
} else {
flowParseType();
}
_util.expect.call(void 0, _types.TokenType.bracketR);
flowParseTypeInitialiser();
}
function flowParseObjectTypeInternalSlot() {
// Note: both bracketL have already been consumed
flowParseObjectPropertyKey();
_util.expect.call(void 0, _types.TokenType.bracketR);
_util.expect.call(void 0, _types.TokenType.bracketR);
if (_index.match.call(void 0, _types.TokenType.lessThan) || _index.match.call(void 0, _types.TokenType.parenL)) {
flowParseObjectTypeMethodish();
} else {
_index.eat.call(void 0, _types.TokenType.question);
flowParseTypeInitialiser();
}
}
function flowParseObjectTypeMethodish() {
if (_index.match.call(void 0, _types.TokenType.lessThan)) {
flowParseTypeParameterDeclaration();
}
_util.expect.call(void 0, _types.TokenType.parenL);
while (!_index.match.call(void 0, _types.TokenType.parenR) && !_index.match.call(void 0, _types.TokenType.ellipsis) && !_base.state.error) {
flowParseFunctionTypeParam();
if (!_index.match.call(void 0, _types.TokenType.parenR)) {
_util.expect.call(void 0, _types.TokenType.comma);
}
}
if (_index.eat.call(void 0, _types.TokenType.ellipsis)) {
flowParseFunctionTypeParam();
}
_util.expect.call(void 0, _types.TokenType.parenR);
flowParseTypeInitialiser();
}
function flowParseObjectTypeCallProperty() {
flowParseObjectTypeMethodish();
}
function flowParseObjectType(allowStatic, allowExact, allowProto) {
let endDelim;
if (allowExact && _index.match.call(void 0, _types.TokenType.braceBarL)) {
_util.expect.call(void 0, _types.TokenType.braceBarL);
endDelim = _types.TokenType.braceBarR;
} else {
_util.expect.call(void 0, _types.TokenType.braceL);
endDelim = _types.TokenType.braceR;
}
while (!_index.match.call(void 0, endDelim) && !_base.state.error) {
if (allowProto && _util.isContextual.call(void 0, _keywords.ContextualKeyword._proto)) {
const lookahead = _index.lookaheadType.call(void 0, );
if (lookahead !== _types.TokenType.colon && lookahead !== _types.TokenType.question) {
_index.next.call(void 0, );
allowStatic = false;
}
}
if (allowStatic && _util.isContextual.call(void 0, _keywords.ContextualKeyword._static)) {
const lookahead = _index.lookaheadType.call(void 0, );
if (lookahead !== _types.TokenType.colon && lookahead !== _types.TokenType.question) {
_index.next.call(void 0, );
}
}
flowParseVariance();
if (_index.eat.call(void 0, _types.TokenType.bracketL)) {
if (_index.eat.call(void 0, _types.TokenType.bracketL)) {
flowParseObjectTypeInternalSlot();
} else {
flowParseObjectTypeIndexer();
}
} else if (_index.match.call(void 0, _types.TokenType.parenL) || _index.match.call(void 0, _types.TokenType.lessThan)) {
flowParseObjectTypeCallProperty();
} else {
if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._get) || _util.isContextual.call(void 0, _keywords.ContextualKeyword._set)) {
const lookahead = _index.lookaheadType.call(void 0, );
if (lookahead === _types.TokenType.name || lookahead === _types.TokenType.string || lookahead === _types.TokenType.num) {
_index.next.call(void 0, );
}
}
flowParseObjectTypeProperty();
}
flowObjectTypeSemicolon();
}
_util.expect.call(void 0, endDelim);
}
function flowParseObjectTypeProperty() {
if (_index.match.call(void 0, _types.TokenType.ellipsis)) {
_util.expect.call(void 0, _types.TokenType.ellipsis);
if (!_index.eat.call(void 0, _types.TokenType.comma)) {
_index.eat.call(void 0, _types.TokenType.semi);
}
// Explicit inexact object syntax.
if (_index.match.call(void 0, _types.TokenType.braceR)) {
return;
}
flowParseType();
} else {
flowParseObjectPropertyKey();
if (_index.match.call(void 0, _types.TokenType.lessThan) || _index.match.call(void 0, _types.TokenType.parenL)) {
// This is a method property
flowParseObjectTypeMethodish();
} else {
_index.eat.call(void 0, _types.TokenType.question);
flowParseTypeInitialiser();
}
}
}
function flowObjectTypeSemicolon() {
if (!_index.eat.call(void 0, _types.TokenType.semi) && !_index.eat.call(void 0, _types.TokenType.comma) && !_index.match.call(void 0, _types.TokenType.braceR) && !_index.match.call(void 0, _types.TokenType.braceBarR)) {
_util.unexpected.call(void 0, );
}
}
function flowParseQualifiedTypeIdentifier(initialIdAlreadyParsed) {
if (!initialIdAlreadyParsed) {
_expression.parseIdentifier.call(void 0, );
}
while (_index.eat.call(void 0, _types.TokenType.dot)) {
_expression.parseIdentifier.call(void 0, );
}
}
function flowParseGenericType() {
flowParseQualifiedTypeIdentifier(true);
if (_index.match.call(void 0, _types.TokenType.lessThan)) {
flowParseTypeParameterInstantiation();
}
}
function flowParseTypeofType() {
_util.expect.call(void 0, _types.TokenType._typeof);
flowParsePrimaryType();
}
function flowParseTupleType() {
_util.expect.call(void 0, _types.TokenType.bracketL);
// We allow trailing commas
while (_base.state.pos < _base.input.length && !_index.match.call(void 0, _types.TokenType.bracketR)) {
flowParseType();
if (_index.match.call(void 0, _types.TokenType.bracketR)) {
break;
}
_util.expect.call(void 0, _types.TokenType.comma);
}
_util.expect.call(void 0, _types.TokenType.bracketR);
}
function flowParseFunctionTypeParam() {
const lookahead = _index.lookaheadType.call(void 0, );
if (lookahead === _types.TokenType.colon || lookahead === _types.TokenType.question) {
_expression.parseIdentifier.call(void 0, );
_index.eat.call(void 0, _types.TokenType.question);
flowParseTypeInitialiser();
} else {
flowParseType();
}
}
function flowParseFunctionTypeParams() {
while (!_index.match.call(void 0, _types.TokenType.parenR) && !_index.match.call(void 0, _types.TokenType.ellipsis) && !_base.state.error) {
flowParseFunctionTypeParam();
if (!_index.match.call(void 0, _types.TokenType.parenR)) {
_util.expect.call(void 0, _types.TokenType.comma);
}
}
if (_index.eat.call(void 0, _types.TokenType.ellipsis)) {
flowParseFunctionTypeParam();
}
}
// The parsing of types roughly parallels the parsing of expressions, and
// primary types are kind of like primary expressions...they're the
// primitives with which other types are constructed.
function flowParsePrimaryType() {
let isGroupedType = false;
const oldNoAnonFunctionType = _base.state.noAnonFunctionType;
switch (_base.state.type) {
case _types.TokenType.name: {
if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._interface)) {
flowParseInterfaceType();
return;
}
_expression.parseIdentifier.call(void 0, );
flowParseGenericType();
return;
}
case _types.TokenType.braceL:
flowParseObjectType(false, false, false);
return;
case _types.TokenType.braceBarL:
flowParseObjectType(false, true, false);
return;
case _types.TokenType.bracketL:
flowParseTupleType();
return;
case _types.TokenType.lessThan:
flowParseTypeParameterDeclaration();
_util.expect.call(void 0, _types.TokenType.parenL);
flowParseFunctionTypeParams();
_util.expect.call(void 0, _types.TokenType.parenR);
_util.expect.call(void 0, _types.TokenType.arrow);
flowParseType();
return;
case _types.TokenType.parenL:
_index.next.call(void 0, );
// Check to see if this is actually a grouped type
if (!_index.match.call(void 0, _types.TokenType.parenR) && !_index.match.call(void 0, _types.TokenType.ellipsis)) {
if (_index.match.call(void 0, _types.TokenType.name)) {
const token = _index.lookaheadType.call(void 0, );
isGroupedType = token !== _types.TokenType.question && token !== _types.TokenType.colon;
} else {
isGroupedType = true;
}
}
if (isGroupedType) {
_base.state.noAnonFunctionType = false;
flowParseType();
_base.state.noAnonFunctionType = oldNoAnonFunctionType;
// A `,` or a `) =>` means this is an anonymous function type
if (
_base.state.noAnonFunctionType ||
!(_index.match.call(void 0, _types.TokenType.comma) || (_index.match.call(void 0, _types.TokenType.parenR) && _index.lookaheadType.call(void 0, ) === _types.TokenType.arrow))
) {
_util.expect.call(void 0, _types.TokenType.parenR);
return;
} else {
// Eat a comma if there is one
_index.eat.call(void 0, _types.TokenType.comma);
}
}
flowParseFunctionTypeParams();
_util.expect.call(void 0, _types.TokenType.parenR);
_util.expect.call(void 0, _types.TokenType.arrow);
flowParseType();
return;
case _types.TokenType.minus:
_index.next.call(void 0, );
_expression.parseLiteral.call(void 0, );
return;
case _types.TokenType.string:
case _types.TokenType.num:
case _types.TokenType._true:
case _types.TokenType._false:
case _types.TokenType._null:
case _types.TokenType._this:
case _types.TokenType._void:
case _types.TokenType.star:
_index.next.call(void 0, );
return;
default:
if (_base.state.type === _types.TokenType._typeof) {
flowParseTypeofType();
return;
} else if (_base.state.type & _types.TokenType.IS_KEYWORD) {
_index.next.call(void 0, );
_base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType.name;
return;
}
}
_util.unexpected.call(void 0, );
}
function flowParsePostfixType() {
flowParsePrimaryType();
while (!_util.canInsertSemicolon.call(void 0, ) && (_index.match.call(void 0, _types.TokenType.bracketL) || _index.match.call(void 0, _types.TokenType.questionDot))) {
_index.eat.call(void 0, _types.TokenType.questionDot);
_util.expect.call(void 0, _types.TokenType.bracketL);
if (_index.eat.call(void 0, _types.TokenType.bracketR)) {
// Array type
} else {
// Indexed access type
flowParseType();
_util.expect.call(void 0, _types.TokenType.bracketR);
}
}
}
function flowParsePrefixType() {
if (_index.eat.call(void 0, _types.TokenType.question)) {
flowParsePrefixType();
} else {
flowParsePostfixType();
}
}
function flowParseAnonFunctionWithoutParens() {
flowParsePrefixType();
if (!_base.state.noAnonFunctionType && _index.eat.call(void 0, _types.TokenType.arrow)) {
flowParseType();
}
}
function flowParseIntersectionType() {
_index.eat.call(void 0, _types.TokenType.bitwiseAND);
flowParseAnonFunctionWithoutParens();
while (_index.eat.call(void 0, _types.TokenType.bitwiseAND)) {
flowParseAnonFunctionWithoutParens();
}
}
function flowParseUnionType() {
_index.eat.call(void 0, _types.TokenType.bitwiseOR);
flowParseIntersectionType();
while (_index.eat.call(void 0, _types.TokenType.bitwiseOR)) {
flowParseIntersectionType();
}
}
function flowParseType() {
flowParseUnionType();
}
function flowParseTypeAnnotation() {
flowParseTypeInitialiser();
} exports.flowParseTypeAnnotation = flowParseTypeAnnotation;
function flowParseTypeAnnotatableIdentifier() {
_expression.parseIdentifier.call(void 0, );
if (_index.match.call(void 0, _types.TokenType.colon)) {
flowParseTypeAnnotation();
}
}
function flowParseVariance() {
if (_index.match.call(void 0, _types.TokenType.plus) || _index.match.call(void 0, _types.TokenType.minus)) {
_index.next.call(void 0, );
_base.state.tokens[_base.state.tokens.length - 1].isType = true;
}
} exports.flowParseVariance = flowParseVariance;
// ==================================
// Overrides
// ==================================
function flowParseFunctionBodyAndFinish(funcContextId) {
// For arrow functions, `parseArrow` handles the return type itself.
if (_index.match.call(void 0, _types.TokenType.colon)) {
flowParseTypeAndPredicateInitialiser();
}
_expression.parseFunctionBody.call(void 0, false, funcContextId);
} exports.flowParseFunctionBodyAndFinish = flowParseFunctionBodyAndFinish;
function flowParseSubscript(
startTokenIndex,
noCalls,
stopState,
) {
if (_index.match.call(void 0, _types.TokenType.questionDot) && _index.lookaheadType.call(void 0, ) === _types.TokenType.lessThan) {
if (noCalls) {
stopState.stop = true;
return;
}
_index.next.call(void 0, );
flowParseTypeParameterInstantiation();
_util.expect.call(void 0, _types.TokenType.parenL);
_expression.parseCallExpressionArguments.call(void 0, );
return;
} else if (!noCalls && _index.match.call(void 0, _types.TokenType.lessThan)) {
const snapshot = _base.state.snapshot();
flowParseTypeParameterInstantiation();
_util.expect.call(void 0, _types.TokenType.parenL);
_expression.parseCallExpressionArguments.call(void 0, );
if (_base.state.error) {
_base.state.restoreFromSnapshot(snapshot);
} else {
return;
}
}
_expression.baseParseSubscript.call(void 0, startTokenIndex, noCalls, stopState);
} exports.flowParseSubscript = flowParseSubscript;
function flowStartParseNewArguments() {
if (_index.match.call(void 0, _types.TokenType.lessThan)) {
const snapshot = _base.state.snapshot();
flowParseTypeParameterInstantiation();
if (_base.state.error) {
_base.state.restoreFromSnapshot(snapshot);
}
}
} exports.flowStartParseNewArguments = flowStartParseNewArguments;
// interfaces
function flowTryParseStatement() {
if (_index.match.call(void 0, _types.TokenType.name) && _base.state.contextualKeyword === _keywords.ContextualKeyword._interface) {
const oldIsType = _index.pushTypeContext.call(void 0, 0);
_index.next.call(void 0, );
flowParseInterface();
_index.popTypeContext.call(void 0, oldIsType);
return true;
} else if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._enum)) {
flowParseEnumDeclaration();
return true;
}
return false;
} exports.flowTryParseStatement = flowTryParseStatement;
function flowTryParseExportDefaultExpression() {
if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._enum)) {
flowParseEnumDeclaration();
return true;
}
return false;
} exports.flowTryParseExportDefaultExpression = flowTryParseExportDefaultExpression;
// declares, interfaces and type aliases
function flowParseIdentifierStatement(contextualKeyword) {
if (contextualKeyword === _keywords.ContextualKeyword._declare) {
if (
_index.match.call(void 0, _types.TokenType._class) ||
_index.match.call(void 0, _types.TokenType.name) ||
_index.match.call(void 0, _types.TokenType._function) ||
_index.match.call(void 0, _types.TokenType._var) ||
_index.match.call(void 0, _types.TokenType._export)
) {
const oldIsType = _index.pushTypeContext.call(void 0, 1);
flowParseDeclare();
_index.popTypeContext.call(void 0, oldIsType);
}
} else if (_index.match.call(void 0, _types.TokenType.name)) {
if (contextualKeyword === _keywords.ContextualKeyword._interface) {
const oldIsType = _index.pushTypeContext.call(void 0, 1);
flowParseInterface();
_index.popTypeContext.call(void 0, oldIsType);
} else if (contextualKeyword === _keywords.ContextualKeyword._type) {
const oldIsType = _index.pushTypeContext.call(void 0, 1);
flowParseTypeAlias();
_index.popTypeContext.call(void 0, oldIsType);
} else if (contextualKeyword === _keywords.ContextualKeyword._opaque) {
const oldIsType = _index.pushTypeContext.call(void 0, 1);
flowParseOpaqueType(false);
_index.popTypeContext.call(void 0, oldIsType);
}
}
_util.semicolon.call(void 0, );
} exports.flowParseIdentifierStatement = flowParseIdentifierStatement;
// export type
function flowShouldParseExportDeclaration() {
return (
_util.isContextual.call(void 0, _keywords.ContextualKeyword._type) ||
_util.isContextual.call(void 0, _keywords.ContextualKeyword._interface) ||
_util.isContextual.call(void 0, _keywords.ContextualKeyword._opaque) ||
_util.isContextual.call(void 0, _keywords.ContextualKeyword._enum)
);
} exports.flowShouldParseExportDeclaration = flowShouldParseExportDeclaration;
function flowShouldDisallowExportDefaultSpecifier() {
return (
_index.match.call(void 0, _types.TokenType.name) &&
(_base.state.contextualKeyword === _keywords.ContextualKeyword._type ||
_base.state.contextualKeyword === _keywords.ContextualKeyword._interface ||
_base.state.contextualKeyword === _keywords.ContextualKeyword._opaque ||
_base.state.contextualKeyword === _keywords.ContextualKeyword._enum)
);
} exports.flowShouldDisallowExportDefaultSpecifier = flowShouldDisallowExportDefaultSpecifier;
function flowParseExportDeclaration() {
if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._type)) {
const oldIsType = _index.pushTypeContext.call(void 0, 1);
_index.next.call(void 0, );
if (_index.match.call(void 0, _types.TokenType.braceL)) {
// export type { foo, bar };
_statement.parseExportSpecifiers.call(void 0, );
_statement.parseExportFrom.call(void 0, );
} else {
// export type Foo = Bar;
flowParseTypeAlias();
}
_index.popTypeContext.call(void 0, oldIsType);
} else if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._opaque)) {
const oldIsType = _index.pushTypeContext.call(void 0, 1);
_index.next.call(void 0, );
// export opaque type Foo = Bar;
flowParseOpaqueType(false);
_index.popTypeContext.call(void 0, oldIsType);
} else if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._interface)) {
const oldIsType = _index.pushTypeContext.call(void 0, 1);
_index.next.call(void 0, );
flowParseInterface();
_index.popTypeContext.call(void 0, oldIsType);
} else {
_statement.parseStatement.call(void 0, true);
}
} exports.flowParseExportDeclaration = flowParseExportDeclaration;
function flowShouldParseExportStar() {
return _index.match.call(void 0, _types.TokenType.star) || (_util.isContextual.call(void 0, _keywords.ContextualKeyword._type) && _index.lookaheadType.call(void 0, ) === _types.TokenType.star);
} exports.flowShouldParseExportStar = flowShouldParseExportStar;
function flowParseExportStar() {
if (_util.eatContextual.call(void 0, _keywords.ContextualKeyword._type)) {
const oldIsType = _index.pushTypeContext.call(void 0, 2);
_statement.baseParseExportStar.call(void 0, );
_index.popTypeContext.call(void 0, oldIsType);
} else {
_statement.baseParseExportStar.call(void 0, );
}
} exports.flowParseExportStar = flowParseExportStar;
// parse a the super class type parameters and implements
function flowAfterParseClassSuper(hasSuper) {
if (hasSuper && _index.match.call(void 0, _types.TokenType.lessThan)) {
flowParseTypeParameterInstantiation();
}
if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._implements)) {
const oldIsType = _index.pushTypeContext.call(void 0, 0);
_index.next.call(void 0, );
_base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType._implements;
do {
flowParseRestrictedIdentifier();
if (_index.match.call(void 0, _types.TokenType.lessThan)) {
flowParseTypeParameterInstantiation();
}
} while (_index.eat.call(void 0, _types.TokenType.comma));
_index.popTypeContext.call(void 0, oldIsType);
}
} exports.flowAfterParseClassSuper = flowAfterParseClassSuper;
// parse type parameters for object method shorthand
function flowStartParseObjPropValue() {
// method shorthand
if (_index.match.call(void 0, _types.TokenType.lessThan)) {
flowParseTypeParameterDeclaration();
if (!_index.match.call(void 0, _types.TokenType.parenL)) _util.unexpected.call(void 0, );
}
} exports.flowStartParseObjPropValue = flowStartParseObjPropValue;
function flowParseAssignableListItemTypes() {
const oldIsType = _index.pushTypeContext.call(void 0, 0);
_index.eat.call(void 0, _types.TokenType.question);
if (_index.match.call(void 0, _types.TokenType.colon)) {
flowParseTypeAnnotation();
}
_index.popTypeContext.call(void 0, oldIsType);
} exports.flowParseAssignableListItemTypes = flowParseAssignableListItemTypes;
// parse typeof and type imports
function flowStartParseImportSpecifiers() {
if (_index.match.call(void 0, _types.TokenType._typeof) || _util.isContextual.call(void 0, _keywords.ContextualKeyword._type)) {
const lh = _index.lookaheadTypeAndKeyword.call(void 0, );
if (isMaybeDefaultImport(lh) || lh.type === _types.TokenType.braceL || lh.type === _types.TokenType.star) {
_index.next.call(void 0, );
}
}
} exports.flowStartParseImportSpecifiers = flowStartParseImportSpecifiers;
// parse import-type/typeof shorthand
function flowParseImportSpecifier() {
const isTypeKeyword =
_base.state.contextualKeyword === _keywords.ContextualKeyword._type || _base.state.type === _types.TokenType._typeof;
if (isTypeKeyword) {
_index.next.call(void 0, );
} else {
_expression.parseIdentifier.call(void 0, );
}
if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._as) && !_util.isLookaheadContextual.call(void 0, _keywords.ContextualKeyword._as)) {
_expression.parseIdentifier.call(void 0, );
if (isTypeKeyword && !_index.match.call(void 0, _types.TokenType.name) && !(_base.state.type & _types.TokenType.IS_KEYWORD)) {
// `import {type as ,` or `import {type as }`
} else {
// `import {type as foo`
_expression.parseIdentifier.call(void 0, );
}
} else {
if (isTypeKeyword && (_index.match.call(void 0, _types.TokenType.name) || !!(_base.state.type & _types.TokenType.IS_KEYWORD))) {
// `import {type foo`
_expression.parseIdentifier.call(void 0, );
}
if (_util.eatContextual.call(void 0, _keywords.ContextualKeyword._as)) {
_expression.parseIdentifier.call(void 0, );
}
}
} exports.flowParseImportSpecifier = flowParseImportSpecifier;
// parse function type parameters - function foo<T>() {}
function flowStartParseFunctionParams() {
// Originally this checked if the method is a getter/setter, but if it was, we'd crash soon
// anyway, so don't try to propagate that information.
if (_index.match.call(void 0, _types.TokenType.lessThan)) {
const oldIsType = _index.pushTypeContext.call(void 0, 0);
flowParseTypeParameterDeclaration();
_index.popTypeContext.call(void 0, oldIsType);
}
} exports.flowStartParseFunctionParams = flowStartParseFunctionParams;
// parse flow type annotations on variable declarator heads - let foo: string = bar
function flowAfterParseVarHead() {
if (_index.match.call(void 0, _types.TokenType.colon)) {
flowParseTypeAnnotation();
}
} exports.flowAfterParseVarHead = flowAfterParseVarHead;
// parse the return type of an async arrow function - let foo = (async (): number => {});
function flowStartParseAsyncArrowFromCallExpression() {
if (_index.match.call(void 0, _types.TokenType.colon)) {
const oldNoAnonFunctionType = _base.state.noAnonFunctionType;
_base.state.noAnonFunctionType = true;
flowParseTypeAnnotation();
_base.state.noAnonFunctionType = oldNoAnonFunctionType;
}
} exports.flowStartParseAsyncArrowFromCallExpression = flowStartParseAsyncArrowFromCallExpression;
// We need to support type parameter declarations for arrow functions. This
// is tricky. There are three situations we need to handle
//
// 1. This is either JSX or an arrow function. We'll try JSX first. If that
// fails, we'll try an arrow function. If that fails, we'll throw the JSX
// error.
// 2. This is an arrow function. We'll parse the type parameter declaration,
// parse the rest, make sure the rest is an arrow function, and go from
// there
// 3. This is neither. Just call the super method
function flowParseMaybeAssign(noIn, isWithinParens) {
if (_index.match.call(void 0, _types.TokenType.lessThan)) {
const snapshot = _base.state.snapshot();
let wasArrow = _expression.baseParseMaybeAssign.call(void 0, noIn, isWithinParens);
if (_base.state.error) {
_base.state.restoreFromSnapshot(snapshot);
_base.state.type = _types.TokenType.typeParameterStart;
} else {
return wasArrow;
}
const oldIsType = _index.pushTypeContext.call(void 0, 0);
flowParseTypeParameterDeclaration();
_index.popTypeContext.call(void 0, oldIsType);
wasArrow = _expression.baseParseMaybeAssign.call(void 0, noIn, isWithinParens);
if (wasArrow) {
return true;
}
_util.unexpected.call(void 0, );
}
return _expression.baseParseMaybeAssign.call(void 0, noIn, isWithinParens);
} exports.flowParseMaybeAssign = flowParseMaybeAssign;
// handle return types for arrow functions
function flowParseArrow() {
if (_index.match.call(void 0, _types.TokenType.colon)) {
const oldIsType = _index.pushTypeContext.call(void 0, 0);
const snapshot = _base.state.snapshot();
const oldNoAnonFunctionType = _base.state.noAnonFunctionType;
_base.state.noAnonFunctionType = true;
flowParseTypeAndPredicateInitialiser();
_base.state.noAnonFunctionType = oldNoAnonFunctionType;
if (_util.canInsertSemicolon.call(void 0, )) _util.unexpected.call(void 0, );
if (!_index.match.call(void 0, _types.TokenType.arrow)) _util.unexpected.call(void 0, );
if (_base.state.error) {
_base.state.restoreFromSnapshot(snapshot);
}
_index.popTypeContext.call(void 0, oldIsType);
}
return _index.eat.call(void 0, _types.TokenType.arrow);
} exports.flowParseArrow = flowParseArrow;
function flowParseSubscripts(startTokenIndex, noCalls = false) {
if (
_base.state.tokens[_base.state.tokens.length - 1].contextualKeyword === _keywords.ContextualKeyword._async &&
_index.match.call(void 0, _types.TokenType.lessThan)
) {
const snapshot = _base.state.snapshot();
const wasArrow = parseAsyncArrowWithTypeParameters();
if (wasArrow && !_base.state.error) {
return;
}
_base.state.restoreFromSnapshot(snapshot);
}
_expression.baseParseSubscripts.call(void 0, startTokenIndex, noCalls);
} exports.flowParseSubscripts = flowParseSubscripts;
// Returns true if there was an arrow function here.
function parseAsyncArrowWithTypeParameters() {
_base.state.scopeDepth++;
const startTokenIndex = _base.state.tokens.length;
_statement.parseFunctionParams.call(void 0, );
if (!_expression.parseArrow.call(void 0, )) {
return false;
}
_expression.parseArrowExpression.call(void 0, startTokenIndex);
return true;
}
function flowParseEnumDeclaration() {
_util.expectContextual.call(void 0, _keywords.ContextualKeyword._enum);
_base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType._enum;
_expression.parseIdentifier.call(void 0, );
flowParseEnumBody();
}
function flowParseEnumBody() {
if (_util.eatContextual.call(void 0, _keywords.ContextualKeyword._of)) {
_index.next.call(void 0, );
}
_util.expect.call(void 0, _types.TokenType.braceL);
flowParseEnumMembers();
_util.expect.call(void 0, _types.TokenType.braceR);
}
function flowParseEnumMembers() {
while (!_index.match.call(void 0, _types.TokenType.braceR) && !_base.state.error) {
if (_index.eat.call(void 0, _types.TokenType.ellipsis)) {
break;
}
flowParseEnumMember();
if (!_index.match.call(void 0, _types.TokenType.braceR)) {
_util.expect.call(void 0, _types.TokenType.comma);
}
}
}
function flowParseEnumMember() {
_expression.parseIdentifier.call(void 0, );
if (_index.eat.call(void 0, _types.TokenType.eq)) {
// Flow enum values are always just one token (a string, number, or boolean literal).
_index.next.call(void 0, );
}
}