hermes-estree 0.8.0 → 0.10.0

package/dist/generated/HermesESTreeSelectorTypes.js.flow

@@ -6,6 +6,13 @@
  *
  * @flow strict
  * @format
+ * @generated
+ */
+
+/*
+ * !!! GENERATED FILE !!!
+ *
+ * Any manual changes to this file will be overwritten. To regenerate run `yarn build`.
  */
 
 // lint directives to let us do some basic validation of generated files
@@ -25,6 +32,7 @@ import type {
   AssignmentPattern,
   AwaitExpression,
   BigIntLiteralTypeAnnotation,
+  BigIntTypeAnnotation,
   BinaryExpression,
   BlockStatement,
   BooleanLiteralTypeAnnotation,
@@ -1044,6 +1052,9 @@ interface PropertyDefinition_With_variance extends PropertyDefinition {
 interface PropertyDefinition_With_typeAnnotation extends PropertyDefinition {
   +typeAnnotation: $NonMaybeType<PropertyDefinition['typeAnnotation']>;
 }
+interface PropertyDefinition_With_tsModifiers extends PropertyDefinition {
+  +tsModifiers: $NonMaybeType<PropertyDefinition['tsModifiers']>;
+}
 interface QualifiedTypeIdentifier_With_qualification
   extends QualifiedTypeIdentifier {
   +qualification: $NonMaybeType<QualifiedTypeIdentifier['qualification']>;
@@ -1341,6 +1352,7 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'BigIntLiteralTypeAnnotation[raw]'?: (
     node: BigIntLiteralTypeAnnotation_With_raw,
   ) => void,
+  +BigIntTypeAnnotation?: (node: BigIntTypeAnnotation) => void,
   +BinaryExpression?: (node: BinaryExpression) => void,
   +'BinaryExpression[left]'?: (node: BinaryExpression_With_left) => void,
   +'BinaryExpression[right]'?: (node: BinaryExpression_With_right) => void,
@@ -1980,6 +1992,9 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'PropertyDefinition[typeAnnotation]'?: (
     node: PropertyDefinition_With_typeAnnotation,
   ) => void,
+  +'PropertyDefinition[tsModifiers]'?: (
+    node: PropertyDefinition_With_tsModifiers,
+  ) => void,
   +QualifiedTypeIdentifier?: (node: QualifiedTypeIdentifier) => void,
   +'QualifiedTypeIdentifier[qualification]'?: (
     node: QualifiedTypeIdentifier_With_qualification,
@@ -2185,6 +2200,7 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'BigIntLiteralTypeAnnotation[raw]:exit'?: (
     node: BigIntLiteralTypeAnnotation_With_raw,
   ) => void,
+  +'BigIntTypeAnnotation:exit'?: (node: BigIntTypeAnnotation) => void,
   +'BinaryExpression:exit'?: (node: BinaryExpression) => void,
   +'BinaryExpression[left]:exit'?: (node: BinaryExpression_With_left) => void,
   +'BinaryExpression[right]:exit'?: (node: BinaryExpression_With_right) => void,
@@ -2884,6 +2900,9 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'PropertyDefinition[typeAnnotation]:exit'?: (
     node: PropertyDefinition_With_typeAnnotation,
   ) => void,
+  +'PropertyDefinition[tsModifiers]:exit'?: (
+    node: PropertyDefinition_With_tsModifiers,
+  ) => void,
   +'QualifiedTypeIdentifier:exit'?: (node: QualifiedTypeIdentifier) => void,
   +'QualifiedTypeIdentifier[qualification]:exit'?: (
     node: QualifiedTypeIdentifier_With_qualification,

package/dist/generated/predicates.js

@@ -6,6 +6,13 @@
  *
  * 
  * @format
+ * @generated
+ */
+
+/*
+ * !!! GENERATED FILE !!!
+ *
+ * Any manual changes to this file will be overwritten. To regenerate run `yarn build`.
  */
 // lint directives to let us do some basic validation of generated files
 
@@ -30,6 +37,7 @@ exports.isAsyncKeyword = isAsyncKeyword;
 exports.isAwaitExpression = isAwaitExpression;
 exports.isAwaitKeyword = isAwaitKeyword;
 exports.isBigIntLiteralTypeAnnotation = isBigIntLiteralTypeAnnotation;
+exports.isBigIntTypeAnnotation = isBigIntTypeAnnotation;
 exports.isBinaryExpression = isBinaryExpression;
 exports.isBitwiseANDEqualToken = isBitwiseANDEqualToken;
 exports.isBitwiseANDToken = isBitwiseANDToken;
@@ -313,6 +321,10 @@ function isBigIntLiteralTypeAnnotation(node) {
   return node.type === 'BigIntLiteralTypeAnnotation';
 }
 
+function isBigIntTypeAnnotation(node) {
+  return node.type === 'BigIntTypeAnnotation';
+}
+
 function isBinaryExpression(node) {
   return node.type === 'BinaryExpression';
 }
@@ -1218,47 +1230,47 @@ function isYieldToken(node) {
 }
 
 function isAsKeyword(node) {
-  return (node.type === 'Identifier' || node.type === 'Keyword') && node.value === 'as';
+  return node.type === 'Identifier' && node.name === 'as' || node.type === 'Keyword' && node.value === 'as';
 }
 
 function isAsyncKeyword(node) {
-  return (node.type === 'Identifier' || node.type === 'Keyword') && node.value === 'async';
+  return node.type === 'Identifier' && node.name === 'async' || node.type === 'Keyword' && node.value === 'async';
 }
 
 function isAwaitKeyword(node) {
-  return (node.type === 'Identifier' || node.type === 'Keyword') && node.value === 'await';
+  return node.type === 'Identifier' && node.name === 'await' || node.type === 'Keyword' && node.value === 'await';
 }
 
 function isDeclareKeyword(node) {
-  return (node.type === 'Identifier' || node.type === 'Keyword') && node.value === 'declare';
+  return node.type === 'Identifier' && node.name === 'declare' || node.type === 'Keyword' && node.value === 'declare';
 }
 
 function isFromKeyword(node) {
-  return (node.type === 'Identifier' || node.type === 'Keyword') && node.value === 'from';
+  return node.type === 'Identifier' && node.name === 'from' || node.type === 'Keyword' && node.value === 'from';
 }
 
 function isGetKeyword(node) {
-  return (node.type === 'Identifier' || node.type === 'Keyword') && node.value === 'get';
+  return node.type === 'Identifier' && node.name === 'get' || node.type === 'Keyword' && node.value === 'get';
 }
 
 function isLetKeyword(node) {
-  return (node.type === 'Identifier' || node.type === 'Keyword') && node.value === 'let';
+  return node.type === 'Identifier' && node.name === 'let' || node.type === 'Keyword' && node.value === 'let';
 }
 
 function isModuleKeyword(node) {
-  return (node.type === 'Identifier' || node.type === 'Keyword') && node.value === 'module';
+  return node.type === 'Identifier' && node.name === 'module' || node.type === 'Keyword' && node.value === 'module';
 }
 
 function isOfKeyword(node) {
-  return (node.type === 'Identifier' || node.type === 'Keyword') && node.value === 'of';
+  return node.type === 'Identifier' && node.name === 'of' || node.type === 'Keyword' && node.value === 'of';
 }
 
 function isSetKeyword(node) {
-  return (node.type === 'Identifier' || node.type === 'Keyword') && node.value === 'set';
+  return node.type === 'Identifier' && node.name === 'set' || node.type === 'Keyword' && node.value === 'set';
 }
 
 function isTypeKeyword(node) {
-  return (node.type === 'Identifier' || node.type === 'Keyword') && node.value === 'type';
+  return node.type === 'Identifier' && node.name === 'type' || node.type === 'Keyword' && node.value === 'type';
 }
 
 function isCommaToken(node) {

package/dist/generated/predicates.js.flow

@@ -6,6 +6,13 @@
  *
  * @flow strict-local
  * @format
+ * @generated
+ */
+
+/*
+ * !!! GENERATED FILE !!!
+ *
+ * Any manual changes to this file will be overwritten. To regenerate run `yarn build`.
  */
 
 // lint directives to let us do some basic validation of generated files
@@ -56,6 +63,10 @@ export function isBigIntLiteralTypeAnnotation(
   return node.type === 'BigIntLiteralTypeAnnotation';
 }
 
+export function isBigIntTypeAnnotation(node: ESNode | Token): boolean %checks {
+  return node.type === 'BigIntTypeAnnotation';
+}
+
 export function isBinaryExpression(node: ESNode | Token): boolean %checks {
   return node.type === 'BinaryExpression';
 }
@@ -1024,78 +1035,78 @@ export function isYieldToken(node: ESNode | Token): boolean %checks {
 
 export function isAsKeyword(node: ESNode | Token): boolean %checks {
   return (
-    (node.type === 'Identifier' || node.type === 'Keyword') &&
-    node.value === 'as'
+    (node.type === 'Identifier' && node.name === 'as') ||
+    (node.type === 'Keyword' && node.value === 'as')
   );
 }
 
 export function isAsyncKeyword(node: ESNode | Token): boolean %checks {
   return (
-    (node.type === 'Identifier' || node.type === 'Keyword') &&
-    node.value === 'async'
+    (node.type === 'Identifier' && node.name === 'async') ||
+    (node.type === 'Keyword' && node.value === 'async')
   );
 }
 
 export function isAwaitKeyword(node: ESNode | Token): boolean %checks {
   return (
-    (node.type === 'Identifier' || node.type === 'Keyword') &&
-    node.value === 'await'
+    (node.type === 'Identifier' && node.name === 'await') ||
+    (node.type === 'Keyword' && node.value === 'await')
   );
 }
 
 export function isDeclareKeyword(node: ESNode | Token): boolean %checks {
   return (
-    (node.type === 'Identifier' || node.type === 'Keyword') &&
-    node.value === 'declare'
+    (node.type === 'Identifier' && node.name === 'declare') ||
+    (node.type === 'Keyword' && node.value === 'declare')
   );
 }
 
 export function isFromKeyword(node: ESNode | Token): boolean %checks {
   return (
-    (node.type === 'Identifier' || node.type === 'Keyword') &&
-    node.value === 'from'
+    (node.type === 'Identifier' && node.name === 'from') ||
+    (node.type === 'Keyword' && node.value === 'from')
   );
 }
 
 export function isGetKeyword(node: ESNode | Token): boolean %checks {
   return (
-    (node.type === 'Identifier' || node.type === 'Keyword') &&
-    node.value === 'get'
+    (node.type === 'Identifier' && node.name === 'get') ||
+    (node.type === 'Keyword' && node.value === 'get')
   );
 }
 
 export function isLetKeyword(node: ESNode | Token): boolean %checks {
   return (
-    (node.type === 'Identifier' || node.type === 'Keyword') &&
-    node.value === 'let'
+    (node.type === 'Identifier' && node.name === 'let') ||
+    (node.type === 'Keyword' && node.value === 'let')
   );
 }
 
 export function isModuleKeyword(node: ESNode | Token): boolean %checks {
   return (
-    (node.type === 'Identifier' || node.type === 'Keyword') &&
-    node.value === 'module'
+    (node.type === 'Identifier' && node.name === 'module') ||
+    (node.type === 'Keyword' && node.value === 'module')
   );
 }
 
 export function isOfKeyword(node: ESNode | Token): boolean %checks {
   return (
-    (node.type === 'Identifier' || node.type === 'Keyword') &&
-    node.value === 'of'
+    (node.type === 'Identifier' && node.name === 'of') ||
+    (node.type === 'Keyword' && node.value === 'of')
   );
 }
 
 export function isSetKeyword(node: ESNode | Token): boolean %checks {
   return (
-    (node.type === 'Identifier' || node.type === 'Keyword') &&
-    node.value === 'set'
+    (node.type === 'Identifier' && node.name === 'set') ||
+    (node.type === 'Keyword' && node.value === 'set')
   );
 }
 
 export function isTypeKeyword(node: ESNode | Token): boolean %checks {
   return (
-    (node.type === 'Identifier' || node.type === 'Keyword') &&
-    node.value === 'type'
+    (node.type === 'Identifier' && node.name === 'type') ||
+    (node.type === 'Keyword' && node.value === 'type')
   );
 }
 

package/dist/predicates.js

@@ -29,7 +29,9 @@ var _exportNames = {
   isNullLiteral: true,
   isNumericLiteral: true,
   isRegExpLiteral: true,
-  isStringLiteral: true
+  isStringLiteral: true,
+  isExpression: true,
+  isStatement: true
 };
 exports.isBigIntLiteral = isBigIntLiteral;
 exports.isBooleanLiteral = isBooleanLiteral;
@@ -37,6 +39,7 @@ exports.isClass = isClass;
 exports.isClassMember = isClassMember;
 exports.isClassMemberWithNonComputedName = isClassMemberWithNonComputedName;
 exports.isComment = isComment;
+exports.isExpression = isExpression;
 exports.isFunction = isFunction;
 exports.isMemberExpressionWithNonComputedProperty = isMemberExpressionWithNonComputedProperty;
 exports.isMethodDefinitionWithNonComputedName = isMethodDefinitionWithNonComputedName;
@@ -47,6 +50,7 @@ exports.isObjectPropertyWithShorthand = isObjectPropertyWithShorthand;
 exports.isOptionalMemberExpressionWithNonComputedProperty = isOptionalMemberExpressionWithNonComputedProperty;
 exports.isPropertyDefinitionWithNonComputedName = isPropertyDefinitionWithNonComputedName;
 exports.isRegExpLiteral = isRegExpLiteral;
+exports.isStatement = isStatement;
 exports.isStringLiteral = isStringLiteral;
 
 var _predicates = require("./generated/predicates");
@@ -124,4 +128,12 @@ function isRegExpLiteral(node) {
 
 function isStringLiteral(node) {
   return (0, _predicates.isLiteral)(node) && node.literalType === 'string';
+}
+
+function isExpression(node) {
+  return (0, _predicates.isThisExpression)(node) || (0, _predicates.isArrayExpression)(node) || (0, _predicates.isObjectExpression)(node) || (0, _predicates.isFunctionExpression)(node) || (0, _predicates.isArrowFunctionExpression)(node) || (0, _predicates.isYieldExpression)(node) || (0, _predicates.isLiteral)(node) || (0, _predicates.isUnaryExpression)(node) || (0, _predicates.isUpdateExpression)(node) || (0, _predicates.isBinaryExpression)(node) || (0, _predicates.isAssignmentExpression)(node) || (0, _predicates.isLogicalExpression)(node) || (0, _predicates.isMemberExpression)(node) || (0, _predicates.isConditionalExpression)(node) || (0, _predicates.isCallExpression)(node) || (0, _predicates.isNewExpression)(node) || (0, _predicates.isSequenceExpression)(node) || (0, _predicates.isTemplateLiteral)(node) || (0, _predicates.isTaggedTemplateExpression)(node) || (0, _predicates.isClassExpression)(node) || (0, _predicates.isMetaProperty)(node) || (0, _predicates.isIdentifier)(node) || (0, _predicates.isAwaitExpression)(node) || (0, _predicates.isImportExpression)(node) || (0, _predicates.isChainExpression)(node) || (0, _predicates.isTypeCastExpression)(node) || (0, _predicates.isJSXFragment)(node) || (0, _predicates.isJSXElement)(node);
+}
+
+function isStatement(node) {
+  return (0, _predicates.isBlockStatement)(node) || (0, _predicates.isBreakStatement)(node) || (0, _predicates.isClassDeclaration)(node) || (0, _predicates.isContinueStatement)(node) || (0, _predicates.isDebuggerStatement)(node) || (0, _predicates.isDeclareClass)(node) || (0, _predicates.isDeclareVariable)(node) || (0, _predicates.isDeclareFunction)(node) || (0, _predicates.isDeclareInterface)(node) || (0, _predicates.isDeclareModule)(node) || (0, _predicates.isDeclareOpaqueType)(node) || (0, _predicates.isDeclareTypeAlias)(node) || (0, _predicates.isDoWhileStatement)(node) || (0, _predicates.isEmptyStatement)(node) || (0, _predicates.isEnumDeclaration)(node) || (0, _predicates.isExpressionStatement)(node) || (0, _predicates.isForInStatement)(node) || (0, _predicates.isForOfStatement)(node) || (0, _predicates.isForStatement)(node) || (0, _predicates.isFunctionDeclaration)(node) || (0, _predicates.isIfStatement)(node) || (0, _predicates.isInterfaceDeclaration)(node) || (0, _predicates.isLabeledStatement)(node) || (0, _predicates.isOpaqueType)(node) || (0, _predicates.isReturnStatement)(node) || (0, _predicates.isSwitchStatement)(node) || (0, _predicates.isThrowStatement)(node) || (0, _predicates.isTryStatement)(node) || (0, _predicates.isTypeAlias)(node) || (0, _predicates.isVariableDeclaration)(node) || (0, _predicates.isWhileStatement)(node) || (0, _predicates.isWithStatement)(node);
 }

package/dist/predicates.js.flow

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @flow strict
+ * @flow strict-local
  * @format
  */
 
@@ -13,18 +13,71 @@
 import type {ESNode, Token} from './types';
 
 import {
+  isArrayExpression,
   isArrowFunctionExpression,
+  isAssignmentExpression,
+  isAwaitExpression,
+  isBinaryExpression,
   isBlockComment,
+  isBlockStatement,
+  isBreakStatement,
+  isCallExpression,
+  isChainExpression,
   isClassDeclaration,
   isClassExpression,
+  isConditionalExpression,
+  isContinueStatement,
+  isDebuggerStatement,
+  isDeclareClass,
+  isDeclareFunction,
+  isDeclareInterface,
+  isDeclareModule,
+  isDeclareOpaqueType,
+  isDeclareTypeAlias,
+  isDeclareVariable,
+  isDoWhileStatement,
+  isEmptyStatement,
+  isEnumDeclaration,
+  isExpressionStatement,
+  isForInStatement,
+  isForOfStatement,
+  isForStatement,
   isFunctionDeclaration,
   isFunctionExpression,
+  isIdentifier,
+  isIfStatement,
+  isImportExpression,
+  isInterfaceDeclaration,
+  isJSXElement,
+  isJSXFragment,
+  isLabeledStatement,
   isLineComment,
   isLiteral,
+  isLogicalExpression,
   isMemberExpression,
+  isMetaProperty,
   isMethodDefinition,
-  isPropertyDefinition,
+  isNewExpression,
+  isObjectExpression,
+  isOpaqueType,
   isProperty,
+  isPropertyDefinition,
+  isReturnStatement,
+  isSequenceExpression,
+  isSwitchStatement,
+  isTaggedTemplateExpression,
+  isTemplateLiteral,
+  isThisExpression,
+  isThrowStatement,
+  isTryStatement,
+  isTypeAlias,
+  isTypeCastExpression,
+  isUnaryExpression,
+  isUpdateExpression,
+  isVariableDeclaration,
+  isWhileStatement,
+  isWithStatement,
+  isYieldExpression,
 } from './generated/predicates';
 
 export * from './generated/predicates';
@@ -112,3 +165,73 @@ export function isRegExpLiteral(node: ESNode): boolean %checks {
 export function isStringLiteral(node: ESNode): boolean %checks {
   return isLiteral(node) && node.literalType === 'string';
 }
+
+export function isExpression(node: ESNode): boolean %checks {
+  return (
+    isThisExpression(node) ||
+    isArrayExpression(node) ||
+    isObjectExpression(node) ||
+    isFunctionExpression(node) ||
+    isArrowFunctionExpression(node) ||
+    isYieldExpression(node) ||
+    isLiteral(node) ||
+    isUnaryExpression(node) ||
+    isUpdateExpression(node) ||
+    isBinaryExpression(node) ||
+    isAssignmentExpression(node) ||
+    isLogicalExpression(node) ||
+    isMemberExpression(node) ||
+    isConditionalExpression(node) ||
+    isCallExpression(node) ||
+    isNewExpression(node) ||
+    isSequenceExpression(node) ||
+    isTemplateLiteral(node) ||
+    isTaggedTemplateExpression(node) ||
+    isClassExpression(node) ||
+    isMetaProperty(node) ||
+    isIdentifier(node) ||
+    isAwaitExpression(node) ||
+    isImportExpression(node) ||
+    isChainExpression(node) ||
+    isTypeCastExpression(node) ||
+    isJSXFragment(node) ||
+    isJSXElement(node)
+  );
+}
+
+export function isStatement(node: ESNode): boolean %checks {
+  return (
+    isBlockStatement(node) ||
+    isBreakStatement(node) ||
+    isClassDeclaration(node) ||
+    isContinueStatement(node) ||
+    isDebuggerStatement(node) ||
+    isDeclareClass(node) ||
+    isDeclareVariable(node) ||
+    isDeclareFunction(node) ||
+    isDeclareInterface(node) ||
+    isDeclareModule(node) ||
+    isDeclareOpaqueType(node) ||
+    isDeclareTypeAlias(node) ||
+    isDoWhileStatement(node) ||
+    isEmptyStatement(node) ||
+    isEnumDeclaration(node) ||
+    isExpressionStatement(node) ||
+    isForInStatement(node) ||
+    isForOfStatement(node) ||
+    isForStatement(node) ||
+    isFunctionDeclaration(node) ||
+    isIfStatement(node) ||
+    isInterfaceDeclaration(node) ||
+    isLabeledStatement(node) ||
+    isOpaqueType(node) ||
+    isReturnStatement(node) ||
+    isSwitchStatement(node) ||
+    isThrowStatement(node) ||
+    isTryStatement(node) ||
+    isTypeAlias(node) ||
+    isVariableDeclaration(node) ||
+    isWhileStatement(node) ||
+    isWithStatement(node)
+  );
+}

package/dist/types.js.flow

@@ -38,7 +38,10 @@
 
 export type Range = [number, number];
 
-export interface BaseToken {
+export interface ObjectWithLoc {
+  +loc: SourceLocation;
+}
+export interface BaseToken extends ObjectWithLoc {
   +loc: SourceLocation;
   +range: Range;
 }
@@ -106,7 +109,7 @@ export interface Position {
 }
 
 // note: this is only ever present on Program.interpreter, never in the body
-interface InterpreterDirective extends BaseNode {
+export interface InterpreterDirective extends BaseNode {
   type: 'InterpreterDirective';
   value: string;
 }
@@ -221,34 +224,38 @@ export type AFunction =
   | ArrowFunctionExpression;
 
 export type Statement =
-  | ExpressionStatement
   | BlockStatement
-  | EmptyStatement
-  | DebuggerStatement
-  | WithStatement
-  | ReturnStatement
-  | LabeledStatement
   | BreakStatement
+  | ClassDeclaration
   | ContinueStatement
+  | DebuggerStatement
+  | DeclareClass
+  | DeclareVariable
+  | DeclareFunction
+  | DeclareInterface
+  | DeclareModule
+  | DeclareOpaqueType
+  | DeclareTypeAlias
+  | DoWhileStatement
+  | EmptyStatement
+  | EnumDeclaration
+  | ExpressionStatement
+  | ForInStatement
+  | ForOfStatement
+  | ForStatement
+  | FunctionDeclaration
   | IfStatement
+  | InterfaceDeclaration
+  | LabeledStatement
+  | OpaqueType
+  | ReturnStatement
   | SwitchStatement
   | ThrowStatement
   | TryStatement
-  | WhileStatement
-  | DoWhileStatement
-  | ForStatement
-  | ForInStatement
-  | ForOfStatement
   | TypeAlias
-  | OpaqueType
-  | InterfaceDeclaration
-  | FunctionDeclaration
   | VariableDeclaration
-  | ClassDeclaration
-  | DeclareTypeAlias
-  | DeclareOpaqueType
-  | DeclareInterface
-  | DeclareModule;
+  | WhileStatement
+  | WithStatement;
 
 // nodes that can be the direct parent of a statement
 export type StatementParentSingle =
@@ -388,6 +395,8 @@ export interface VariableDeclarator extends BaseNode {
   +type: 'VariableDeclarator';
   +id: BindingName;
   +init?: Expression | null;
+
+  +parent: VariableDeclaration;
 }
 
 export type Expression =
@@ -445,7 +454,11 @@ export type ObjectProperty =
   | ObjectPropertyWithNonShorthandStaticName
   | ObjectPropertyWithShorthandStaticName
   | ObjectPropertyWithComputedName;
-export interface ObjectPropertyWithNonShorthandStaticName extends BaseNode {
+interface ObjectPropertyBase extends BaseNode {
+  +parent: ObjectExpression | ObjectPattern;
+}
+export interface ObjectPropertyWithNonShorthandStaticName
+  extends ObjectPropertyBase {
   +type: 'Property';
   +computed: false;
   // non-computed, non-shorthand names are constrained significantly
@@ -455,7 +468,8 @@ export interface ObjectPropertyWithNonShorthandStaticName extends BaseNode {
   +method: boolean;
   +shorthand: false;
 }
-export interface ObjectPropertyWithShorthandStaticName extends BaseNode {
+export interface ObjectPropertyWithShorthandStaticName
+  extends ObjectPropertyBase {
   +type: 'Property';
   +computed: false;
   // shorthand keys *must* be identifiers
@@ -463,10 +477,10 @@ export interface ObjectPropertyWithShorthandStaticName extends BaseNode {
   // shorthand values *must* be identifiers (that look the same as the key)
   +value: Identifier;
   +kind: 'init';
-  +method: boolean;
+  +method: false;
   +shorthand: true;
 }
-export interface ObjectPropertyWithComputedName extends BaseNode {
+export interface ObjectPropertyWithComputedName extends ObjectPropertyBase {
   +type: 'Property';
   +computed: true;
   // computed names can be any expression
@@ -486,6 +500,8 @@ interface DestructuringObjectPropertyBase extends BaseNode {
   // destructuring properties cannot be methods
   +kind: 'init';
   +method: false;
+
+  +parent: ObjectExpression | ObjectPattern;
 }
 export interface DestructuringObjectPropertyWithNonShorthandStaticName
   extends DestructuringObjectPropertyBase {
@@ -840,7 +856,7 @@ interface BaseClass extends BaseNode {
   +body: ClassBody;
 
   +typeParameters: null | TypeParameterDeclaration;
-  +superTypeParameters: null | TypeParameterDeclaration;
+  +superTypeParameters: null | TypeParameterInstantiation;
   +implements: $ReadOnlyArray<ClassImplements>;
   +decorators: $ReadOnlyArray<Decorator>;
 }
@@ -862,6 +878,8 @@ export type ClassMemberWithNonComputedName =
 export interface ClassBody extends BaseNode {
   +type: 'ClassBody';
   +body: $ReadOnlyArray<ClassMember>;
+
+  +parent: AClass;
 }
 
 export type MethodDefinition =
@@ -870,6 +888,8 @@ export type MethodDefinition =
   | MethodDefinitionWithNonComputedName;
 interface MethodDefinitionBase extends BaseNode {
   +value: FunctionExpression;
+
+  +parent: ClassBody;
 }
 export interface MethodDefinitionConstructor extends MethodDefinitionBase {
   +type: 'MethodDefinition';
@@ -906,6 +926,8 @@ interface PropertyDefinitionBase extends BaseNode {
   +declare: boolean;
   // hermes always emit this as false
   +optional: false;
+
+  +parent: ClassBody;
 }
 export interface PropertyDefinitionWithComputedName
   extends PropertyDefinitionBase {
@@ -966,6 +988,8 @@ export interface ImportAttribute extends BaseNode {
   +type: 'ImportAttribute';
   +key: Identifier;
   +value: StringLiteral;
+
+  +parent: ImportDeclaration | ImportExpression;
 }
 
 export interface ImportSpecifier extends BaseNode {
@@ -973,6 +997,8 @@ export interface ImportSpecifier extends BaseNode {
   +imported: Identifier;
   +local: Identifier;
   +importKind: null | 'type' | 'typeof';
+
+  +parent: ImportDeclaration;
 }
 
 export interface ImportExpression extends BaseNode {
@@ -984,11 +1010,15 @@ export interface ImportExpression extends BaseNode {
 export interface ImportDefaultSpecifier extends BaseNode {
   +type: 'ImportDefaultSpecifier';
   +local: Identifier;
+
+  +parent: ImportDeclaration;
 }
 
 export interface ImportNamespaceSpecifier extends BaseNode {
   +type: 'ImportNamespaceSpecifier';
   +local: Identifier;
+
+  +parent: ImportDeclaration;
 }
 
 export type DefaultDeclaration = FunctionDeclaration | ClassDeclaration;
@@ -1000,13 +1030,30 @@ export type NamedDeclaration =
   | InterfaceDeclaration
   | EnumDeclaration;
 
-export interface ExportNamedDeclaration extends BaseNode {
+interface ExportNamedDeclarationBase extends BaseNode {
   +type: 'ExportNamedDeclaration';
   +declaration?: NamedDeclaration | null;
   +specifiers: $ReadOnlyArray<ExportSpecifier>;
-  +source?: Literal | null;
+  +source?: StringLiteral | null;
   +exportKind: 'value' | 'type';
 }
+export interface ExportNamedDeclarationWithSpecifiers
+  extends ExportNamedDeclarationBase {
+  +type: 'ExportNamedDeclaration';
+  +declaration: null;
+  +source: null;
+  +specifiers: $ReadOnlyArray<ExportSpecifier>;
+}
+export interface ExportNamedDeclarationWithDeclaration
+  extends ExportNamedDeclarationBase {
+  +type: 'ExportNamedDeclaration';
+  +declaration: NamedDeclaration;
+  +source: null;
+  +specifiers: [];
+}
+export type ExportNamedDeclaration =
+  | ExportNamedDeclarationWithSpecifiers
+  | ExportNamedDeclarationWithDeclaration;
 
 export interface ExportSpecifier extends BaseNode {
   +type: 'ExportSpecifier';
@@ -1021,7 +1068,7 @@ export interface ExportDefaultDeclaration extends BaseNode {
 
 export interface ExportAllDeclaration extends BaseNode {
   +type: 'ExportAllDeclaration';
-  +source: Literal;
+  +source: StringLiteral;
   +exportKind: 'value' | 'type';
   +exported?: Identifier | null;
 }
@@ -1038,6 +1085,7 @@ export interface AwaitExpression extends BaseNode {
 export type TypeAnnotationType =
   | NumberTypeAnnotation
   | StringTypeAnnotation
+  | BigIntTypeAnnotation
   | BooleanTypeAnnotation
   | NullLiteralTypeAnnotation
   | AnyTypeAnnotation
@@ -1101,6 +1149,9 @@ export interface NumberTypeAnnotation extends BaseNode {
 export interface StringTypeAnnotation extends BaseNode {
   +type: 'StringTypeAnnotation';
 }
+export interface BigIntTypeAnnotation extends BaseNode {
+  +type: 'BigIntTypeAnnotation';
+}
 export interface BooleanTypeAnnotation extends BaseNode {
   +type: 'BooleanTypeAnnotation';
 }
@@ -1137,13 +1188,14 @@ export interface NumberLiteralTypeAnnotation extends BaseNode {
 }
 export interface BigIntLiteralTypeAnnotation extends BaseNode {
   +type: 'BigIntLiteralTypeAnnotation';
-  +value: null;
+  +bigint: string;
+  +value: null /* | bigint */;
   +raw: string;
 }
 export interface BooleanLiteralTypeAnnotation extends BaseNode {
   +type: 'BooleanLiteralTypeAnnotation';
   +value: boolean;
-  +raw: string;
+  +raw: 'true' | 'false';
 }
 export interface ArrayTypeAnnotation extends BaseNode {
   +type: 'ArrayTypeAnnotation';
@@ -1172,7 +1224,7 @@ export interface TypeofTypeAnnotation extends BaseNode {
 }
 export interface TupleTypeAnnotation extends BaseNode {
   +type: 'TupleTypeAnnotation';
-  +types: TypeAnnotationType;
+  +types: $ReadOnlyArray<TypeAnnotationType>;
 }
 
 // type T = { [[foo]]: number };
@@ -1183,6 +1235,8 @@ export interface ObjectTypeInternalSlot extends BaseNode {
   +static: boolean;
   +method: boolean;
   +value: TypeAnnotation;
+
+  +parent: ObjectTypeAnnotation;
 }
 
 export interface InterfaceTypeAnnotation extends BaseInterfaceNode {
@@ -1204,16 +1258,20 @@ export interface FunctionTypeAnnotation extends BaseNode {
   +returnType: TypeAnnotationType;
   +rest: null | FunctionTypeParam;
   +typeParameters: null | TypeParameterDeclaration;
-  +this: TypeAnnotationType | null;
+  +this: FunctionTypeParam | null;
 }
 export interface FunctionTypeParam extends BaseNode {
   +type: 'FunctionTypeParam';
   +name: Identifier | null;
   +typeAnnotation: TypeAnnotationType;
   +optional: boolean;
+
+  +parent: FunctionTypeAnnotation;
 }
 export interface InferredPredicate extends BaseNode {
   +type: 'InferredPredicate';
+
+  +parent: AFunction | DeclareFunction;
 }
 
 export interface ObjectTypeAnnotation extends BaseNode {
@@ -1225,44 +1283,87 @@ export interface ObjectTypeAnnotation extends BaseNode {
   +callProperties: $ReadOnlyArray<ObjectTypeCallProperty>;
   +internalSlots: $ReadOnlyArray<ObjectTypeInternalSlot>;
 }
-export interface ObjectTypeProperty extends BaseNode {
+interface ObjectTypePropertyBase extends BaseNode {
   +type: 'ObjectTypeProperty';
-  +key: Identifier;
+  +key: Identifier | StringLiteral;
   +value: TypeAnnotationType;
   +method: boolean;
   +optional: boolean;
-  +static: false; // can't be static
-  +proto: false; // ???
+  +static: boolean; // only applies to the "declare class" case
+  +proto: boolean; // only applies to the "declare class" case
+  +variance: Variance | null;
+  +kind: 'init' | 'get' | 'set';
+
+  +parent: ObjectTypeAnnotation;
+}
+export interface ObjectTypeMethodSignature extends ObjectTypePropertyBase {
+  +type: 'ObjectTypeProperty';
+  +value: FunctionTypeAnnotation;
+  +method: true;
+  +optional: false;
+  +variance: null;
+  +kind: 'init';
+
+  +parent: ObjectTypeAnnotation;
+}
+export interface ObjectTypePropertySignature extends ObjectTypePropertyBase {
+  +type: 'ObjectTypeProperty';
+  +value: TypeAnnotationType;
+  +method: false;
+  +optional: boolean;
   +variance: Variance | null;
   +kind: 'init';
+
+  +parent: ObjectTypeAnnotation;
 }
+export interface ObjectTypeAccessorSignature extends ObjectTypePropertyBase {
+  +type: 'ObjectTypeProperty';
+  +value: FunctionTypeAnnotation;
+  +method: false;
+  +optional: false;
+  +variance: null;
+  +kind: 'get' | 'set';
+
+  +parent: ObjectTypeAnnotation;
+}
+export type ObjectTypeProperty =
+  | ObjectTypeMethodSignature
+  | ObjectTypePropertySignature
+  | ObjectTypeAccessorSignature;
+
 export interface ObjectTypeCallProperty extends BaseNode {
   +type: 'ObjectTypeCallProperty';
   +value: FunctionTypeAnnotation;
-  +static: false; // can't be static
+  +static: boolean; // can only be static when defined on a declare class
+
+  +parent: ObjectTypeAnnotation;
 }
 export interface ObjectTypeIndexer extends BaseNode {
   +type: 'ObjectTypeIndexer';
   +id: null | Identifier;
   +key: TypeAnnotationType;
   +value: TypeAnnotationType;
-  +static: false; // can't be static
+  +static: boolean; // can only be static when defined on a declare class
   +variance: null | Variance;
+
+  +parent: ObjectTypeAnnotation;
 }
 export interface ObjectTypeSpreadProperty extends BaseNode {
   +type: 'ObjectTypeSpreadProperty';
   +argument: TypeAnnotationType;
+
+  +parent: ObjectTypeAnnotation;
 }
 
 export interface IndexedAccessType extends BaseNode {
   +type: 'IndexedAccessType';
-  +objectType: TypeAnnotation;
-  +indexType: TypeAnnotation;
+  +objectType: TypeAnnotationType;
+  +indexType: TypeAnnotationType;
 }
 export interface OptionalIndexedAccessType extends BaseNode {
   +type: 'OptionalIndexedAccessType';
-  +objectType: TypeAnnotation;
-  +indexType: TypeAnnotation;
+  +objectType: TypeAnnotationType;
+  +indexType: TypeAnnotationType;
   +optional: boolean;
 }
 
@@ -1288,18 +1389,24 @@ export interface InterfaceDeclaration extends BaseInterfaceDeclaration {
 export interface InterfaceExtends extends BaseNode {
   +type: 'InterfaceExtends';
   +id: Identifier;
-  +typeParameters: null | TypeParameterDeclaration;
+  +typeParameters: null | TypeParameterInstantiation;
+
+  +parent: InterfaceDeclaration | DeclareInterface;
 }
 
 export interface ClassImplements extends BaseNode {
   +type: 'ClassImplements';
   +id: Identifier;
-  +typeParameters: null | TypeParameterDeclaration;
+  +typeParameters: null | TypeParameterInstantiation;
+
+  +parent: AClass | DeclareClass;
 }
 
 export interface Decorator extends BaseNode {
   +type: 'Decorator';
   +expression: Expression;
+
+  +parent: AClass;
 }
 
 export interface TypeParameterDeclaration extends BaseNode {
@@ -1312,10 +1419,14 @@ export interface TypeParameter extends BaseNode {
   +bound: null | TypeAnnotation;
   +variance: null | Variance;
   +default: null | TypeAnnotationType;
+
+  +parent: TypeParameterDeclaration;
 }
 export interface TypeParameterInstantiation extends BaseNode {
   +type: 'TypeParameterInstantiation';
   +params: $ReadOnlyArray<TypeAnnotationType>;
+
+  +parent: GenericTypeAnnotation | CallExpression | NewExpression;
 }
 
 export interface EnumDeclaration extends BaseNode {
@@ -1336,46 +1447,62 @@ export interface EnumNumberBody extends BaseInferrableEnumBody {
   // enum number members cannot be defaulted
   +members: $ReadOnlyArray<EnumNumberMember>;
   +explicitType: boolean;
+
+  +parent: EnumDeclaration;
 }
 
 export interface EnumNumberMember extends BaseNode {
   +type: 'EnumNumberMember';
   +id: Identifier;
   +init: NumericLiteral;
+
+  +parent: EnumNumberBody;
 }
 
 export interface EnumStringBody extends BaseInferrableEnumBody {
   +type: 'EnumStringBody';
   +members: $ReadOnlyArray<EnumStringMember | EnumDefaultedMember>;
+
+  +parent: EnumDeclaration;
 }
 
 export interface EnumStringMember extends BaseNode {
   +type: 'EnumStringMember';
   +id: Identifier;
   +init: StringLiteral;
+
+  +parent: EnumStringBody;
 }
 
 export interface EnumBooleanBody extends BaseInferrableEnumBody {
   +type: 'EnumBooleanBody';
   // enum boolean members cannot be defaulted
   +members: $ReadOnlyArray<EnumBooleanMember>;
+
+  +parent: EnumDeclaration;
 }
 
 export interface EnumBooleanMember extends BaseNode {
   +type: 'EnumBooleanMember';
   +id: Identifier;
   +init: BooleanLiteral;
+
+  +parent: EnumBooleanBody;
 }
 
 export interface EnumSymbolBody extends BaseEnumBody {
   +type: 'EnumSymbolBody';
   // enum symbol members can only be defaulted
   +members: $ReadOnlyArray<EnumDefaultedMember>;
+
+  +parent: EnumDeclaration;
 }
 
 export interface EnumDefaultedMember extends BaseNode {
   +type: 'EnumDefaultedMember';
   +id: Identifier;
+
+  +parent: EnumStringBody | EnumSymbolBody;
 }
 
 /*****************
@@ -1412,7 +1539,12 @@ export interface DeclareVariable extends BaseNode {
 
 export interface DeclareFunction extends BaseNode {
   +type: 'DeclareFunction';
-  +id: Identifier;
+  // the function signature is stored as a type annotation on the ID
+  +id: interface extends Identifier {
+    +typeAnnotation: interface extends TypeAnnotation {
+      +typeAnnotation: FunctionTypeAnnotation,
+    },
+  };
   +predicate: InferredPredicate | DeclaredPredicate | null;
 }
 
@@ -1441,19 +1573,49 @@ export interface DeclareExportAllDeclaration extends BaseNode {
   +source: StringLiteral;
 }
 
-export interface DeclareExportDeclaration extends BaseNode {
+interface DeclareExportDeclarationBase extends BaseNode {
   +type: 'DeclareExportDeclaration';
   +specifiers: $ReadOnlyArray<ExportSpecifier>;
+  +source: StringLiteral | null;
+  +default: boolean;
+}
+export interface DeclareExportDefaultDeclaration
+  extends DeclareExportDeclarationBase {
+  +type: 'DeclareExportDeclaration';
+  +declaration: DeclareClass | DeclareFunction | TypeAnnotationType;
+  +default: true;
+  // default cannot have a source
+  +source: null;
+  // default cannot have specifiers
+  +specifiers: [];
+}
+export interface DeclareExportDeclarationNamedWithDeclaration
+  extends DeclareExportDeclarationBase {
+  +type: 'DeclareExportDeclaration';
   +declaration:
-    | TypeAlias
     | DeclareClass
     | DeclareFunction
-    | DeclareOpaqueType
     | DeclareInterface
-    | null;
-  +source: StringLiteral | null;
-  +default: boolean;
+    | DeclareOpaqueType
+    | DeclareVariable;
+  +default: false;
+  +source: null;
+  // default cannot have specifiers and a declaration
+  +specifiers: [];
+}
+export interface DeclareExportDeclarationNamedWithSpecifiers
+  extends DeclareExportDeclarationBase {
+  +type: 'DeclareExportDeclaration';
+  // with a source you can't have a declaration
+  +declaration: null;
+  +default: false;
+  +source: StringLiteral;
+  +specifiers: $ReadOnlyArray<ExportSpecifier>;
 }
+export type DeclareExportDeclaration =
+  | DeclareExportDefaultDeclaration
+  | DeclareExportDeclarationNamedWithDeclaration
+  | DeclareExportDeclarationNamedWithSpecifiers;
 
 export interface DeclareModuleExports extends BaseNode {
   +type: 'DeclareModuleExports';
@@ -1502,15 +1664,21 @@ export interface JSXAttribute extends BaseNode {
   +type: 'JSXAttribute';
   +name: JSXIdentifier;
   +value: Literal | JSXExpression | null;
+
+  +parent: JSXOpeningElement;
 }
 
 export interface JSXClosingElement extends BaseNode {
   +type: 'JSXClosingElement';
   +name: JSXTagNameExpression;
+
+  +parent: JSXElement;
 }
 
 export interface JSXClosingFragment extends BaseNode {
   +type: 'JSXClosingFragment';
+
+  +parent: JSXFragment;
 }
 
 export interface JSXElement extends BaseNode {
@@ -1526,7 +1694,7 @@ export interface JSXEmptyExpression extends BaseNode {
 
 export interface JSXExpressionContainer extends BaseNode {
   +type: 'JSXExpressionContainer';
-  +expression: Expression;
+  +expression: Expression | JSXEmptyExpression;
 }
 
 export interface JSXFragment extends BaseNode {
@@ -1558,15 +1726,21 @@ export interface JSXOpeningElement extends BaseNode {
   +selfClosing: boolean;
   +name: JSXTagNameExpression;
   +attributes: $ReadOnlyArray<JSXAttribute | JSXSpreadAttribute>;
+
+  +parent: JSXElement;
 }
 
 export interface JSXOpeningFragment extends BaseNode {
   +type: 'JSXOpeningFragment';
+
+  +parent: JSXFragment;
 }
 
 export interface JSXSpreadAttribute extends BaseNode {
   +type: 'JSXSpreadAttribute';
   +argument: Expression;
+
+  +parent: JSXOpeningElement;
 }
 
 export interface JSXText extends BaseNode {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hermes-estree",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "description": "Flow types for the Flow-ESTree spec produced by the hermes parser",
   "main": "dist/index.js",
   "license": "MIT",
@@ -9,6 +9,8 @@
     "url": "git@github.com:facebook/hermes.git"
   },
   "files": [
-    "dist"
+    "dist",
+    "LICENCE",
+    "README.md"
   ]
 }