hermes-transform 0.32.1 → 0.33.0

package/dist/generated/node-types.js

@@ -133,6 +133,8 @@ var _exportNames = {
   MatchExpression: true,
   MatchExpressionCase: true,
   MatchIdentifierPattern: true,
+  MatchInstanceObjectPattern: true,
+  MatchInstancePattern: true,
   MatchLiteralPattern: true,
   MatchMemberPattern: true,
   MatchObjectPattern: true,
@@ -146,6 +148,7 @@ var _exportNames = {
   MetaProperty: true,
   MethodDefinition: true,
   MixedTypeAnnotation: true,
+  NeverTypeAnnotation: true,
   NewExpression: true,
   NullableTypeAnnotation: true,
   NullLiteralTypeAnnotation: true,
@@ -166,6 +169,13 @@ var _exportNames = {
   PropertyDefinition: true,
   QualifiedTypeIdentifier: true,
   QualifiedTypeofIdentifier: true,
+  RecordDeclaration: true,
+  RecordDeclarationBody: true,
+  RecordDeclarationImplements: true,
+  RecordDeclarationProperty: true,
+  RecordDeclarationStaticProperty: true,
+  RecordExpression: true,
+  RecordExpressionProperties: true,
   RestElement: true,
   ReturnStatement: true,
   SequenceExpression: true,
@@ -196,7 +206,9 @@ var _exportNames = {
   TypeParameterInstantiation: true,
   TypePredicate: true,
   UnaryExpression: true,
+  UndefinedTypeAnnotation: true,
   UnionTypeAnnotation: true,
+  UnknownTypeAnnotation: true,
   UpdateExpression: true,
   VariableDeclaration: true,
   VariableDeclarator: true,
@@ -314,6 +326,8 @@ exports.MatchBindingPattern = MatchBindingPattern;
 exports.MatchExpression = MatchExpression;
 exports.MatchExpressionCase = MatchExpressionCase;
 exports.MatchIdentifierPattern = MatchIdentifierPattern;
+exports.MatchInstanceObjectPattern = MatchInstanceObjectPattern;
+exports.MatchInstancePattern = MatchInstancePattern;
 exports.MatchLiteralPattern = MatchLiteralPattern;
 exports.MatchMemberPattern = MatchMemberPattern;
 exports.MatchObjectPattern = MatchObjectPattern;
@@ -327,6 +341,7 @@ exports.MatchWildcardPattern = MatchWildcardPattern;
 exports.MetaProperty = MetaProperty;
 exports.MethodDefinition = MethodDefinition;
 exports.MixedTypeAnnotation = MixedTypeAnnotation;
+exports.NeverTypeAnnotation = NeverTypeAnnotation;
 exports.NewExpression = NewExpression;
 exports.NullLiteralTypeAnnotation = NullLiteralTypeAnnotation;
 exports.NullableTypeAnnotation = NullableTypeAnnotation;
@@ -347,6 +362,13 @@ exports.Property = Property;
 exports.PropertyDefinition = PropertyDefinition;
 exports.QualifiedTypeIdentifier = QualifiedTypeIdentifier;
 exports.QualifiedTypeofIdentifier = QualifiedTypeofIdentifier;
+exports.RecordDeclaration = RecordDeclaration;
+exports.RecordDeclarationBody = RecordDeclarationBody;
+exports.RecordDeclarationImplements = RecordDeclarationImplements;
+exports.RecordDeclarationProperty = RecordDeclarationProperty;
+exports.RecordDeclarationStaticProperty = RecordDeclarationStaticProperty;
+exports.RecordExpression = RecordExpression;
+exports.RecordExpressionProperties = RecordExpressionProperties;
 exports.RestElement = RestElement;
 exports.ReturnStatement = ReturnStatement;
 exports.SequenceExpression = SequenceExpression;
@@ -377,7 +399,9 @@ exports.TypeParameterInstantiation = TypeParameterInstantiation;
 exports.TypePredicate = TypePredicate;
 exports.TypeofTypeAnnotation = TypeofTypeAnnotation;
 exports.UnaryExpression = UnaryExpression;
+exports.UndefinedTypeAnnotation = UndefinedTypeAnnotation;
 exports.UnionTypeAnnotation = UnionTypeAnnotation;
+exports.UnknownTypeAnnotation = UnknownTypeAnnotation;
 exports.UpdateExpression = UpdateExpression;
 exports.VariableDeclaration = VariableDeclaration;
 exports.VariableDeclarator = VariableDeclarator;
@@ -581,7 +605,7 @@ function ClassExpression(props) {
     id: (0, _detachedNode.asDetachedNodeForCodeGen)(props.id),
     typeParameters: (0, _detachedNode.asDetachedNodeForCodeGen)(props.typeParameters),
     superClass: (0, _detachedNode.asDetachedNodeForCodeGen)(props.superClass),
-    superTypeParameters: (0, _detachedNode.asDetachedNodeForCodeGen)(props.superTypeParameters),
+    superTypeArguments: (0, _detachedNode.asDetachedNodeForCodeGen)(props.superTypeArguments),
     implements: props.implements.map(n => (0, _detachedNode.asDetachedNodeForCodeGen)(n)),
     decorators: props.decorators.map(n => (0, _detachedNode.asDetachedNodeForCodeGen)(n)),
     body: (0, _detachedNode.asDetachedNodeForCodeGen)(props.body)
@@ -1498,6 +1522,26 @@ function MatchIdentifierPattern(props) {
   return node;
 }
 
+function MatchInstanceObjectPattern(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'MatchInstanceObjectPattern',
+    properties: props.properties.map(n => (0, _detachedNode.asDetachedNodeForCodeGen)(n)),
+    rest: (0, _detachedNode.asDetachedNodeForCodeGen)(props.rest)
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+}
+
+function MatchInstancePattern(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'MatchInstancePattern',
+    targetConstructor: (0, _detachedNode.asDetachedNodeForCodeGen)(props.targetConstructor),
+    properties: (0, _detachedNode.asDetachedNodeForCodeGen)(props.properties)
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+}
+
 function MatchLiteralPattern(props) {
   const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'MatchLiteralPattern',
@@ -1624,6 +1668,13 @@ function MixedTypeAnnotation(props = { ...null
   });
 }
 
+function NeverTypeAnnotation(props = { ...null
+}) {
+  return (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'NeverTypeAnnotation'
+  });
+}
+
 function NewExpression(props) {
   const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'NewExpression',
@@ -1843,6 +1894,79 @@ function QualifiedTypeofIdentifier(props) {
   return node;
 }
 
+function RecordDeclaration(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'RecordDeclaration',
+    id: (0, _detachedNode.asDetachedNodeForCodeGen)(props.id),
+    typeParameters: (0, _detachedNode.asDetachedNodeForCodeGen)(props.typeParameters),
+    implements: props.implements.map(n => (0, _detachedNode.asDetachedNodeForCodeGen)(n)),
+    body: (0, _detachedNode.asDetachedNodeForCodeGen)(props.body)
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+}
+
+function RecordDeclarationBody(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'RecordDeclarationBody',
+    elements: props.elements.map(n => (0, _detachedNode.asDetachedNodeForCodeGen)(n))
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+}
+
+function RecordDeclarationImplements(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'RecordDeclarationImplements',
+    id: (0, _detachedNode.asDetachedNodeForCodeGen)(props.id),
+    typeArguments: (0, _detachedNode.asDetachedNodeForCodeGen)(props.typeArguments)
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+}
+
+function RecordDeclarationProperty(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'RecordDeclarationProperty',
+    key: (0, _detachedNode.asDetachedNodeForCodeGen)(props.key),
+    typeAnnotation: (0, _detachedNode.asDetachedNodeForCodeGen)(props.typeAnnotation),
+    defaultValue: (0, _detachedNode.asDetachedNodeForCodeGen)(props.defaultValue)
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+}
+
+function RecordDeclarationStaticProperty(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'RecordDeclarationStaticProperty',
+    key: (0, _detachedNode.asDetachedNodeForCodeGen)(props.key),
+    typeAnnotation: (0, _detachedNode.asDetachedNodeForCodeGen)(props.typeAnnotation),
+    value: (0, _detachedNode.asDetachedNodeForCodeGen)(props.value)
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+}
+
+function RecordExpression(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'RecordExpression',
+    recordConstructor: (0, _detachedNode.asDetachedNodeForCodeGen)(props.recordConstructor),
+    typeArguments: (0, _detachedNode.asDetachedNodeForCodeGen)(props.typeArguments),
+    properties: (0, _detachedNode.asDetachedNodeForCodeGen)(props.properties)
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+}
+
+function RecordExpressionProperties(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'RecordExpressionProperties',
+    properties: props.properties.map(n => (0, _detachedNode.asDetachedNodeForCodeGen)(n))
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+}
+
 function RestElement(props) {
   const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'RestElement',
@@ -1996,7 +2120,7 @@ function TryStatement(props) {
 function TupleTypeAnnotation(props) {
   const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'TupleTypeAnnotation',
-    types: props.types.map(n => (0, _detachedNode.asDetachedNodeForCodeGen)(n)),
+    elementTypes: props.elementTypes.map(n => (0, _detachedNode.asDetachedNodeForCodeGen)(n)),
     inexact: props.inexact
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
@@ -2129,6 +2253,13 @@ function UnaryExpression(props) {
   return node;
 }
 
+function UndefinedTypeAnnotation(props = { ...null
+}) {
+  return (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'UndefinedTypeAnnotation'
+  });
+}
+
 function UnionTypeAnnotation(props) {
   const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'UnionTypeAnnotation',
@@ -2138,6 +2269,13 @@ function UnionTypeAnnotation(props) {
   return node;
 }
 
+function UnknownTypeAnnotation(props = { ...null
+}) {
+  return (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'UnknownTypeAnnotation'
+  });
+}
+
 function UpdateExpression(props) {
   const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'UpdateExpression',

package/dist/generated/node-types.js.flow

@@ -131,6 +131,8 @@ import type {
   MatchExpression as MatchExpressionType,
   MatchExpressionCase as MatchExpressionCaseType,
   MatchIdentifierPattern as MatchIdentifierPatternType,
+  MatchInstanceObjectPattern as MatchInstanceObjectPatternType,
+  MatchInstancePattern as MatchInstancePatternType,
   MatchLiteralPattern as MatchLiteralPatternType,
   MatchMemberPattern as MatchMemberPatternType,
   MatchObjectPattern as MatchObjectPatternType,
@@ -144,6 +146,7 @@ import type {
   MetaProperty as MetaPropertyType,
   MethodDefinition as MethodDefinitionType,
   MixedTypeAnnotation as MixedTypeAnnotationType,
+  NeverTypeAnnotation as NeverTypeAnnotationType,
   NewExpression as NewExpressionType,
   NullableTypeAnnotation as NullableTypeAnnotationType,
   NullLiteralTypeAnnotation as NullLiteralTypeAnnotationType,
@@ -164,6 +167,13 @@ import type {
   PropertyDefinition as PropertyDefinitionType,
   QualifiedTypeIdentifier as QualifiedTypeIdentifierType,
   QualifiedTypeofIdentifier as QualifiedTypeofIdentifierType,
+  RecordDeclaration as RecordDeclarationType,
+  RecordDeclarationBody as RecordDeclarationBodyType,
+  RecordDeclarationImplements as RecordDeclarationImplementsType,
+  RecordDeclarationProperty as RecordDeclarationPropertyType,
+  RecordDeclarationStaticProperty as RecordDeclarationStaticPropertyType,
+  RecordExpression as RecordExpressionType,
+  RecordExpressionProperties as RecordExpressionPropertiesType,
   RestElement as RestElementType,
   ReturnStatement as ReturnStatementType,
   SequenceExpression as SequenceExpressionType,
@@ -194,7 +204,9 @@ import type {
   TypeParameterInstantiation as TypeParameterInstantiationType,
   TypePredicate as TypePredicateType,
   UnaryExpression as UnaryExpressionType,
+  UndefinedTypeAnnotation as UndefinedTypeAnnotationType,
   UnionTypeAnnotation as UnionTypeAnnotationType,
+  UnknownTypeAnnotation as UnknownTypeAnnotationType,
   UpdateExpression as UpdateExpressionType,
   VariableDeclaration as VariableDeclarationType,
   VariableDeclarator as VariableDeclaratorType,
@@ -304,8 +316,8 @@ export type ClassExpressionProps = {
   +id?: ?MaybeDetachedNode<ClassExpressionType['id']>,
   +typeParameters?: ?MaybeDetachedNode<ClassExpressionType['typeParameters']>,
   +superClass?: ?MaybeDetachedNode<ClassExpressionType['superClass']>,
-  +superTypeParameters?: ?MaybeDetachedNode<
-    ClassExpressionType['superTypeParameters'],
+  +superTypeArguments?: ?MaybeDetachedNode<
+    ClassExpressionType['superTypeArguments'],
   >,
   +implements: $ReadOnlyArray<
     MaybeDetachedNode<ClassExpressionType['implements'][number]>,
@@ -856,6 +868,20 @@ export type MatchIdentifierPatternProps = {
   +id: MaybeDetachedNode<MatchIdentifierPatternType['id']>,
 };
 
+export type MatchInstanceObjectPatternProps = {
+  +properties: $ReadOnlyArray<
+    MaybeDetachedNode<MatchInstanceObjectPatternType['properties'][number]>,
+  >,
+  +rest?: ?MaybeDetachedNode<MatchInstanceObjectPatternType['rest']>,
+};
+
+export type MatchInstancePatternProps = {
+  +targetConstructor: MaybeDetachedNode<
+    MatchInstancePatternType['targetConstructor'],
+  >,
+  +properties: MaybeDetachedNode<MatchInstancePatternType['properties']>,
+};
+
 export type MatchLiteralPatternProps = {
   +literal: MaybeDetachedNode<MatchLiteralPatternType['literal']>,
 };
@@ -923,6 +949,8 @@ export type MethodDefinitionProps = {
 
 export type MixedTypeAnnotationProps = {};
 
+export type NeverTypeAnnotationProps = {};
+
 export type NewExpressionProps = {
   +callee: MaybeDetachedNode<NewExpressionType['callee']>,
   +typeArguments?: ?MaybeDetachedNode<NewExpressionType['typeArguments']>,
@@ -1066,6 +1094,60 @@ export type QualifiedTypeofIdentifierProps = {
   +id: MaybeDetachedNode<QualifiedTypeofIdentifierType['id']>,
 };
 
+export type RecordDeclarationProps = {
+  +id: MaybeDetachedNode<RecordDeclarationType['id']>,
+  +typeParameters?: ?MaybeDetachedNode<RecordDeclarationType['typeParameters']>,
+  +implements: $ReadOnlyArray<
+    MaybeDetachedNode<RecordDeclarationType['implements'][number]>,
+  >,
+  +body: MaybeDetachedNode<RecordDeclarationType['body']>,
+};
+
+export type RecordDeclarationBodyProps = {
+  +elements: $ReadOnlyArray<
+    MaybeDetachedNode<RecordDeclarationBodyType['elements'][number]>,
+  >,
+};
+
+export type RecordDeclarationImplementsProps = {
+  +id: MaybeDetachedNode<RecordDeclarationImplementsType['id']>,
+  +typeArguments?: ?MaybeDetachedNode<
+    RecordDeclarationImplementsType['typeArguments'],
+  >,
+};
+
+export type RecordDeclarationPropertyProps = {
+  +key: MaybeDetachedNode<RecordDeclarationPropertyType['key']>,
+  +typeAnnotation: MaybeDetachedNode<
+    RecordDeclarationPropertyType['typeAnnotation'],
+  >,
+  +defaultValue?: ?MaybeDetachedNode<
+    RecordDeclarationPropertyType['defaultValue'],
+  >,
+};
+
+export type RecordDeclarationStaticPropertyProps = {
+  +key: MaybeDetachedNode<RecordDeclarationStaticPropertyType['key']>,
+  +typeAnnotation: MaybeDetachedNode<
+    RecordDeclarationStaticPropertyType['typeAnnotation'],
+  >,
+  +value: MaybeDetachedNode<RecordDeclarationStaticPropertyType['value']>,
+};
+
+export type RecordExpressionProps = {
+  +recordConstructor: MaybeDetachedNode<
+    RecordExpressionType['recordConstructor'],
+  >,
+  +typeArguments?: ?MaybeDetachedNode<RecordExpressionType['typeArguments']>,
+  +properties: MaybeDetachedNode<RecordExpressionType['properties']>,
+};
+
+export type RecordExpressionPropertiesProps = {
+  +properties: $ReadOnlyArray<
+    MaybeDetachedNode<RecordExpressionPropertiesType['properties'][number]>,
+  >,
+};
+
 export type RestElementProps = {
   +argument: MaybeDetachedNode<RestElementType['argument']>,
 };
@@ -1142,8 +1224,8 @@ export type TryStatementProps = {
 };
 
 export type TupleTypeAnnotationProps = {
-  +types: $ReadOnlyArray<
-    MaybeDetachedNode<TupleTypeAnnotationType['types'][number]>,
+  +elementTypes: $ReadOnlyArray<
+    MaybeDetachedNode<TupleTypeAnnotationType['elementTypes'][number]>,
   >,
   +inexact: TupleTypeAnnotationType['inexact'],
 };
@@ -1222,12 +1304,16 @@ export type UnaryExpressionProps = {
   +prefix: UnaryExpressionType['prefix'],
 };
 
+export type UndefinedTypeAnnotationProps = {};
+
 export type UnionTypeAnnotationProps = {
   +types: $ReadOnlyArray<
     MaybeDetachedNode<UnionTypeAnnotationType['types'][number]>,
   >,
 };
 
+export type UnknownTypeAnnotationProps = {};
+
 export type UpdateExpressionProps = {
   +operator: UpdateExpressionType['operator'],
   +argument: MaybeDetachedNode<UpdateExpressionType['argument']>,
@@ -1528,7 +1614,7 @@ export function ClassExpression(props: {
     id: asDetachedNodeForCodeGen(props.id),
     typeParameters: asDetachedNodeForCodeGen(props.typeParameters),
     superClass: asDetachedNodeForCodeGen(props.superClass),
-    superTypeParameters: asDetachedNodeForCodeGen(props.superTypeParameters),
+    superTypeArguments: asDetachedNodeForCodeGen(props.superTypeArguments),
     implements: props.implements.map(n => asDetachedNodeForCodeGen(n)),
     decorators: props.decorators.map(n => asDetachedNodeForCodeGen(n)),
     body: asDetachedNodeForCodeGen(props.body),
@@ -2833,6 +2919,38 @@ export function MatchIdentifierPattern(props: {
   return node;
 }
 
+export function MatchInstanceObjectPattern(props: {
+  ...MatchInstanceObjectPatternProps,
+  +parent?: ESNode,
+}): DetachedNode<MatchInstanceObjectPatternType> {
+  const node = detachedProps<MatchInstanceObjectPatternType>(
+    (props.parent: $FlowFixMe),
+    {
+      type: 'MatchInstanceObjectPattern',
+      properties: props.properties.map(n => asDetachedNodeForCodeGen(n)),
+      rest: asDetachedNodeForCodeGen(props.rest),
+    },
+  );
+  setParentPointersInDirectChildren((node: $FlowFixMe));
+  return node;
+}
+
+export function MatchInstancePattern(props: {
+  ...MatchInstancePatternProps,
+  +parent?: ESNode,
+}): DetachedNode<MatchInstancePatternType> {
+  const node = detachedProps<MatchInstancePatternType>(
+    (props.parent: $FlowFixMe),
+    {
+      type: 'MatchInstancePattern',
+      targetConstructor: asDetachedNodeForCodeGen(props.targetConstructor),
+      properties: asDetachedNodeForCodeGen(props.properties),
+    },
+  );
+  setParentPointersInDirectChildren((node: $FlowFixMe));
+  return node;
+}
+
 export function MatchLiteralPattern(props: {
   ...MatchLiteralPatternProps,
   +parent?: ESNode,
@@ -3016,6 +3134,16 @@ export function MixedTypeAnnotation(
   });
 }
 
+export function NeverTypeAnnotation(
+  props: {
+    +parent?: ESNode,
+  } = {...null},
+): DetachedNode<NeverTypeAnnotationType> {
+  return detachedProps<NeverTypeAnnotationType>((props.parent: $FlowFixMe), {
+    type: 'NeverTypeAnnotation',
+  });
+}
+
 export function NewExpression(props: {
   ...NewExpressionProps,
   +parent?: ESNode,
@@ -3339,6 +3467,118 @@ export function QualifiedTypeofIdentifier(props: {
   return node;
 }
 
+export function RecordDeclaration(props: {
+  ...RecordDeclarationProps,
+  +parent?: ESNode,
+}): DetachedNode<RecordDeclarationType> {
+  const node = detachedProps<RecordDeclarationType>(
+    (props.parent: $FlowFixMe),
+    {
+      type: 'RecordDeclaration',
+      id: asDetachedNodeForCodeGen(props.id),
+      typeParameters: asDetachedNodeForCodeGen(props.typeParameters),
+      implements: props.implements.map(n => asDetachedNodeForCodeGen(n)),
+      body: asDetachedNodeForCodeGen(props.body),
+    },
+  );
+  setParentPointersInDirectChildren((node: $FlowFixMe));
+  return node;
+}
+
+export function RecordDeclarationBody(props: {
+  ...RecordDeclarationBodyProps,
+  +parent?: ESNode,
+}): DetachedNode<RecordDeclarationBodyType> {
+  const node = detachedProps<RecordDeclarationBodyType>(
+    (props.parent: $FlowFixMe),
+    {
+      type: 'RecordDeclarationBody',
+      elements: props.elements.map(n => asDetachedNodeForCodeGen(n)),
+    },
+  );
+  setParentPointersInDirectChildren((node: $FlowFixMe));
+  return node;
+}
+
+export function RecordDeclarationImplements(props: {
+  ...RecordDeclarationImplementsProps,
+  +parent?: ESNode,
+}): DetachedNode<RecordDeclarationImplementsType> {
+  const node = detachedProps<RecordDeclarationImplementsType>(
+    (props.parent: $FlowFixMe),
+    {
+      type: 'RecordDeclarationImplements',
+      id: asDetachedNodeForCodeGen(props.id),
+      typeArguments: asDetachedNodeForCodeGen(props.typeArguments),
+    },
+  );
+  setParentPointersInDirectChildren((node: $FlowFixMe));
+  return node;
+}
+
+export function RecordDeclarationProperty(props: {
+  ...RecordDeclarationPropertyProps,
+  +parent?: ESNode,
+}): DetachedNode<RecordDeclarationPropertyType> {
+  const node = detachedProps<RecordDeclarationPropertyType>(
+    (props.parent: $FlowFixMe),
+    {
+      type: 'RecordDeclarationProperty',
+      key: asDetachedNodeForCodeGen(props.key),
+      typeAnnotation: asDetachedNodeForCodeGen(props.typeAnnotation),
+      defaultValue: asDetachedNodeForCodeGen(props.defaultValue),
+    },
+  );
+  setParentPointersInDirectChildren((node: $FlowFixMe));
+  return node;
+}
+
+export function RecordDeclarationStaticProperty(props: {
+  ...RecordDeclarationStaticPropertyProps,
+  +parent?: ESNode,
+}): DetachedNode<RecordDeclarationStaticPropertyType> {
+  const node = detachedProps<RecordDeclarationStaticPropertyType>(
+    (props.parent: $FlowFixMe),
+    {
+      type: 'RecordDeclarationStaticProperty',
+      key: asDetachedNodeForCodeGen(props.key),
+      typeAnnotation: asDetachedNodeForCodeGen(props.typeAnnotation),
+      value: asDetachedNodeForCodeGen(props.value),
+    },
+  );
+  setParentPointersInDirectChildren((node: $FlowFixMe));
+  return node;
+}
+
+export function RecordExpression(props: {
+  ...RecordExpressionProps,
+  +parent?: ESNode,
+}): DetachedNode<RecordExpressionType> {
+  const node = detachedProps<RecordExpressionType>((props.parent: $FlowFixMe), {
+    type: 'RecordExpression',
+    recordConstructor: asDetachedNodeForCodeGen(props.recordConstructor),
+    typeArguments: asDetachedNodeForCodeGen(props.typeArguments),
+    properties: asDetachedNodeForCodeGen(props.properties),
+  });
+  setParentPointersInDirectChildren((node: $FlowFixMe));
+  return node;
+}
+
+export function RecordExpressionProperties(props: {
+  ...RecordExpressionPropertiesProps,
+  +parent?: ESNode,
+}): DetachedNode<RecordExpressionPropertiesType> {
+  const node = detachedProps<RecordExpressionPropertiesType>(
+    (props.parent: $FlowFixMe),
+    {
+      type: 'RecordExpressionProperties',
+      properties: props.properties.map(n => asDetachedNodeForCodeGen(n)),
+    },
+  );
+  setParentPointersInDirectChildren((node: $FlowFixMe));
+  return node;
+}
+
 export function RestElement(props: {
   ...RestElementProps,
   +parent?: ESNode,
@@ -3557,7 +3797,7 @@ export function TupleTypeAnnotation(props: {
     (props.parent: $FlowFixMe),
     {
       type: 'TupleTypeAnnotation',
-      types: props.types.map(n => asDetachedNodeForCodeGen(n)),
+      elementTypes: props.elementTypes.map(n => asDetachedNodeForCodeGen(n)),
       inexact: props.inexact,
     },
   );
@@ -3745,6 +3985,19 @@ export function UnaryExpression(props: {
   return node;
 }
 
+export function UndefinedTypeAnnotation(
+  props: {
+    +parent?: ESNode,
+  } = {...null},
+): DetachedNode<UndefinedTypeAnnotationType> {
+  return detachedProps<UndefinedTypeAnnotationType>(
+    (props.parent: $FlowFixMe),
+    {
+      type: 'UndefinedTypeAnnotation',
+    },
+  );
+}
+
 export function UnionTypeAnnotation(props: {
   ...UnionTypeAnnotationProps,
   +parent?: ESNode,
@@ -3760,6 +4013,16 @@ export function UnionTypeAnnotation(props: {
   return node;
 }
 
+export function UnknownTypeAnnotation(
+  props: {
+    +parent?: ESNode,
+  } = {...null},
+): DetachedNode<UnknownTypeAnnotationType> {
+  return detachedProps<UnknownTypeAnnotationType>((props.parent: $FlowFixMe), {
+    type: 'UnknownTypeAnnotation',
+  });
+}
+
 export function UpdateExpression(props: {
   ...UpdateExpressionProps,
   +parent?: ESNode,

package/dist/generated/special-case-node-types/misc.js

@@ -55,7 +55,7 @@ function ClassDeclaration(props) {
     // $FlowFixMe[incompatible-type]
     superClass: (0, _detachedNode.asDetachedNode)(props.superClass),
     // $FlowFixMe[incompatible-type]
-    superTypeParameters: (0, _detachedNode.asDetachedNode)(props.superTypeParameters),
+    superTypeArguments: (0, _detachedNode.asDetachedNode)(props.superTypeArguments),
     decorators: ((_props$decorators = props.decorators) != null ? _props$decorators : []).map(n => (0, _detachedNode.asDetachedNode)(n)),
     implements: ((_props$implements = props.implements) != null ? _props$implements : []).map(n => (0, _detachedNode.asDetachedNode)(n)),
     body: (0, _detachedNode.asDetachedNode)(props.body)

package/dist/generated/special-case-node-types/misc.js.flow

@@ -81,8 +81,8 @@ export type ClassDeclarationProps = {
   +id?: ?MaybeDetachedNode<ClassDeclarationType['id']>,
   +typeParameters?: ?MaybeDetachedNode<ClassDeclarationType['typeParameters']>,
   +superClass?: ?MaybeDetachedNode<ClassDeclarationType['superClass']>,
-  +superTypeParameters?: ?MaybeDetachedNode<
-    ClassDeclarationType['superTypeParameters'],
+  +superTypeArguments?: ?MaybeDetachedNode<
+    ClassDeclarationType['superTypeArguments'],
   >,
   // make this optional as it's rarer that people would want to include them
   +implements?: $ReadOnlyArray<
@@ -107,7 +107,7 @@ export function ClassDeclaration(props: {
     // $FlowFixMe[incompatible-type]
     superClass: asDetachedNode(props.superClass),
     // $FlowFixMe[incompatible-type]
-    superTypeParameters: asDetachedNode(props.superTypeParameters),
+    superTypeArguments: asDetachedNode(props.superTypeArguments),
     decorators: (props.decorators ?? []).map(n => asDetachedNode(n)),
     implements: (props.implements ?? []).map(n => asDetachedNode(n)),
     body: asDetachedNode(props.body),