hermes-transform 0.7.0 → 0.8.0

package/dist/generated/TransformCloneSignatures.js.flow

@@ -33,12 +33,11 @@ import type {
   BreakStatement,
   CallExpression,
   CatchClause,
+  ChainExpression,
   ClassBody,
   ClassDeclaration,
   ClassExpression,
   ClassImplements,
-  ClassPrivateProperty,
-  ClassProperty,
   ConditionalExpression,
   ContinueStatement,
   DebuggerStatement,
@@ -69,7 +68,6 @@ import type {
   ExportAllDeclaration,
   ExportDefaultDeclaration,
   ExportNamedDeclaration,
-  ExportNamespaceSpecifier,
   ExportSpecifier,
   ExpressionStatement,
   ForInStatement,
@@ -131,11 +129,10 @@ import type {
   ObjectTypeProperty,
   ObjectTypeSpreadProperty,
   OpaqueType,
-  OptionalCallExpression,
   OptionalIndexedAccessType,
-  OptionalMemberExpression,
-  PrivateName,
+  PrivateIdentifier,
   Property,
+  PropertyDefinition,
   QualifiedTypeIdentifier,
   RegExpLiteral,
   RestElement,
@@ -194,12 +191,11 @@ import type {
   BreakStatementProps,
   CallExpressionProps,
   CatchClauseProps,
+  ChainExpressionProps,
   ClassBodyProps,
   ClassDeclarationProps,
   ClassExpressionProps,
   ClassImplementsProps,
-  ClassPrivatePropertyProps,
-  ClassPropertyProps,
   ConditionalExpressionProps,
   ContinueStatementProps,
   DebuggerStatementProps,
@@ -230,7 +226,6 @@ import type {
   ExportAllDeclarationProps,
   ExportDefaultDeclarationProps,
   ExportNamedDeclarationProps,
-  ExportNamespaceSpecifierProps,
   ExportSpecifierProps,
   ExpressionStatementProps,
   ForInStatementProps,
@@ -292,11 +287,10 @@ import type {
   ObjectTypePropertyProps,
   ObjectTypeSpreadPropertyProps,
   OpaqueTypeProps,
-  OptionalCallExpressionProps,
   OptionalIndexedAccessTypeProps,
-  OptionalMemberExpressionProps,
-  PrivateNameProps,
+  PrivateIdentifierProps,
   PropertyProps,
+  PropertyDefinitionProps,
   QualifiedTypeIdentifierProps,
   RegExpLiteralProps,
   RestElementProps,
@@ -482,6 +476,14 @@ type CatchClauseCloneSignature = ((
     node: ?CatchClause,
     newProps: $Partial<CatchClauseProps>,
   ) => DetachedNode<CatchClause> | null);
+type ChainExpressionCloneSignature = ((
+  node: ChainExpression,
+  newProps: $Partial<ChainExpressionProps>,
+) => DetachedNode<ChainExpression>) &
+  ((
+    node: ?ChainExpression,
+    newProps: $Partial<ChainExpressionProps>,
+  ) => DetachedNode<ChainExpression> | null);
 type ClassBodyCloneSignature = ((
   node: ClassBody,
   newProps: $Partial<ClassBodyProps>,
@@ -514,22 +516,6 @@ type ClassImplementsCloneSignature = ((
     node: ?ClassImplements,
     newProps: $Partial<ClassImplementsProps>,
   ) => DetachedNode<ClassImplements> | null);
-type ClassPrivatePropertyCloneSignature = ((
-  node: ClassPrivateProperty,
-  newProps: $Partial<ClassPrivatePropertyProps>,
-) => DetachedNode<ClassPrivateProperty>) &
-  ((
-    node: ?ClassPrivateProperty,
-    newProps: $Partial<ClassPrivatePropertyProps>,
-  ) => DetachedNode<ClassPrivateProperty> | null);
-type ClassPropertyCloneSignature = ((
-  node: ClassProperty,
-  newProps: $Partial<ClassPropertyProps>,
-) => DetachedNode<ClassProperty>) &
-  ((
-    node: ?ClassProperty,
-    newProps: $Partial<ClassPropertyProps>,
-  ) => DetachedNode<ClassProperty> | null);
 type ConditionalExpressionCloneSignature = ((
   node: ConditionalExpression,
   newProps: $Partial<ConditionalExpressionProps>,
@@ -770,14 +756,6 @@ type ExportNamedDeclarationCloneSignature = ((
     node: ?ExportNamedDeclaration,
     newProps: $Partial<ExportNamedDeclarationProps>,
   ) => DetachedNode<ExportNamedDeclaration> | null);
-type ExportNamespaceSpecifierCloneSignature = ((
-  node: ExportNamespaceSpecifier,
-  newProps: $Partial<ExportNamespaceSpecifierProps>,
-) => DetachedNode<ExportNamespaceSpecifier>) &
-  ((
-    node: ?ExportNamespaceSpecifier,
-    newProps: $Partial<ExportNamespaceSpecifierProps>,
-  ) => DetachedNode<ExportNamespaceSpecifier> | null);
 type ExportSpecifierCloneSignature = ((
   node: ExportSpecifier,
   newProps: $Partial<ExportSpecifierProps>,
@@ -1266,14 +1244,6 @@ type OpaqueTypeCloneSignature = ((
     node: ?OpaqueType,
     newProps: $Partial<OpaqueTypeProps>,
   ) => DetachedNode<OpaqueType> | null);
-type OptionalCallExpressionCloneSignature = ((
-  node: OptionalCallExpression,
-  newProps: $Partial<OptionalCallExpressionProps>,
-) => DetachedNode<OptionalCallExpression>) &
-  ((
-    node: ?OptionalCallExpression,
-    newProps: $Partial<OptionalCallExpressionProps>,
-  ) => DetachedNode<OptionalCallExpression> | null);
 type OptionalIndexedAccessTypeCloneSignature = ((
   node: OptionalIndexedAccessType,
   newProps: $Partial<OptionalIndexedAccessTypeProps>,
@@ -1282,22 +1252,14 @@ type OptionalIndexedAccessTypeCloneSignature = ((
     node: ?OptionalIndexedAccessType,
     newProps: $Partial<OptionalIndexedAccessTypeProps>,
   ) => DetachedNode<OptionalIndexedAccessType> | null);
-type OptionalMemberExpressionCloneSignature = ((
-  node: OptionalMemberExpression,
-  newProps: $Partial<OptionalMemberExpressionProps>,
-) => DetachedNode<OptionalMemberExpression>) &
-  ((
-    node: ?OptionalMemberExpression,
-    newProps: $Partial<OptionalMemberExpressionProps>,
-  ) => DetachedNode<OptionalMemberExpression> | null);
-type PrivateNameCloneSignature = ((
-  node: PrivateName,
-  newProps: $Partial<PrivateNameProps>,
-) => DetachedNode<PrivateName>) &
-  ((
-    node: ?PrivateName,
-    newProps: $Partial<PrivateNameProps>,
-  ) => DetachedNode<PrivateName> | null);
+type PrivateIdentifierCloneSignature = ((
+  node: PrivateIdentifier,
+  newProps: $Partial<PrivateIdentifierProps>,
+) => DetachedNode<PrivateIdentifier>) &
+  ((
+    node: ?PrivateIdentifier,
+    newProps: $Partial<PrivateIdentifierProps>,
+  ) => DetachedNode<PrivateIdentifier> | null);
 type PropertyCloneSignature = ((
   node: Property,
   newProps: $Partial<PropertyProps>,
@@ -1306,6 +1268,14 @@ type PropertyCloneSignature = ((
     node: ?Property,
     newProps: $Partial<PropertyProps>,
   ) => DetachedNode<Property> | null);
+type PropertyDefinitionCloneSignature = ((
+  node: PropertyDefinition,
+  newProps: $Partial<PropertyDefinitionProps>,
+) => DetachedNode<PropertyDefinition>) &
+  ((
+    node: ?PropertyDefinition,
+    newProps: $Partial<PropertyDefinitionProps>,
+  ) => DetachedNode<PropertyDefinition> | null);
 type QualifiedTypeIdentifierCloneSignature = ((
   node: QualifiedTypeIdentifier,
   newProps: $Partial<QualifiedTypeIdentifierProps>,
@@ -1628,12 +1598,11 @@ export type TransformCloneSignatures = AnyTypeAnnotationCloneSignature &
   BreakStatementCloneSignature &
   CallExpressionCloneSignature &
   CatchClauseCloneSignature &
+  ChainExpressionCloneSignature &
   ClassBodyCloneSignature &
   ClassDeclarationCloneSignature &
   ClassExpressionCloneSignature &
   ClassImplementsCloneSignature &
-  ClassPrivatePropertyCloneSignature &
-  ClassPropertyCloneSignature &
   ConditionalExpressionCloneSignature &
   ContinueStatementCloneSignature &
   DebuggerStatementCloneSignature &
@@ -1664,7 +1633,6 @@ export type TransformCloneSignatures = AnyTypeAnnotationCloneSignature &
   ExportAllDeclarationCloneSignature &
   ExportDefaultDeclarationCloneSignature &
   ExportNamedDeclarationCloneSignature &
-  ExportNamespaceSpecifierCloneSignature &
   ExportSpecifierCloneSignature &
   ExpressionStatementCloneSignature &
   ForInStatementCloneSignature &
@@ -1726,11 +1694,10 @@ export type TransformCloneSignatures = AnyTypeAnnotationCloneSignature &
   ObjectTypePropertyCloneSignature &
   ObjectTypeSpreadPropertyCloneSignature &
   OpaqueTypeCloneSignature &
-  OptionalCallExpressionCloneSignature &
   OptionalIndexedAccessTypeCloneSignature &
-  OptionalMemberExpressionCloneSignature &
-  PrivateNameCloneSignature &
+  PrivateIdentifierCloneSignature &
   PropertyCloneSignature &
+  PropertyDefinitionCloneSignature &
   QualifiedTypeIdentifierCloneSignature &
   RegExpLiteralCloneSignature &
   RestElementCloneSignature &

package/dist/generated/TransformReplaceSignatures.js.flow

@@ -31,12 +31,11 @@ import type {
   BreakStatement,
   CallExpression,
   CatchClause,
+  ChainExpression,
   ClassBody,
   ClassDeclaration,
   ClassExpression,
   ClassImplements,
-  ClassPrivateProperty,
-  ClassProperty,
   ConditionalExpression,
   ContinueStatement,
   DebuggerStatement,
@@ -67,7 +66,6 @@ import type {
   ExportAllDeclaration,
   ExportDefaultDeclaration,
   ExportNamedDeclaration,
-  ExportNamespaceSpecifier,
   ExportSpecifier,
   ExpressionStatement,
   ForInStatement,
@@ -127,12 +125,11 @@ import type {
   ObjectTypeProperty,
   ObjectTypeSpreadProperty,
   OpaqueType,
-  OptionalCallExpression,
   OptionalIndexedAccessType,
-  OptionalMemberExpression,
-  PrivateName,
+  PrivateIdentifier,
   Program,
   Property,
+  PropertyDefinition,
   QualifiedTypeIdentifier,
   RestElement,
   ReturnStatement,
@@ -253,6 +250,11 @@ type CatchClauseReplaceSignature = (
   nodeToReplaceWith: DetachedNode<CatchClause>,
   options?: $ReadOnly<{keepComments?: boolean}>,
 ) => void;
+type ChainExpressionReplaceSignature = (
+  target: ChainExpression,
+  nodeToReplaceWith: DetachedNode<ChainExpression>,
+  options?: $ReadOnly<{keepComments?: boolean}>,
+) => void;
 type ClassBodyReplaceSignature = (
   target: ClassBody,
   nodeToReplaceWith: DetachedNode<ClassBody>,
@@ -273,16 +275,6 @@ type ClassImplementsReplaceSignature = (
   nodeToReplaceWith: DetachedNode<ClassImplements>,
   options?: $ReadOnly<{keepComments?: boolean}>,
 ) => void;
-type ClassPrivatePropertyReplaceSignature = (
-  target: ClassPrivateProperty,
-  nodeToReplaceWith: DetachedNode<ClassPrivateProperty>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
-) => void;
-type ClassPropertyReplaceSignature = (
-  target: ClassProperty,
-  nodeToReplaceWith: DetachedNode<ClassProperty>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
-) => void;
 type ConditionalExpressionReplaceSignature = (
   target: ConditionalExpression,
   nodeToReplaceWith: DetachedNode<ConditionalExpression>,
@@ -433,11 +425,6 @@ type ExportNamedDeclarationReplaceSignature = (
   nodeToReplaceWith: DetachedNode<ExportNamedDeclaration>,
   options?: $ReadOnly<{keepComments?: boolean}>,
 ) => void;
-type ExportNamespaceSpecifierReplaceSignature = (
-  target: ExportNamespaceSpecifier,
-  nodeToReplaceWith: DetachedNode<ExportNamespaceSpecifier>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
-) => void;
 type ExportSpecifierReplaceSignature = (
   target: ExportSpecifier,
   nodeToReplaceWith: DetachedNode<ExportSpecifier>,
@@ -733,24 +720,14 @@ type OpaqueTypeReplaceSignature = (
   nodeToReplaceWith: DetachedNode<OpaqueType>,
   options?: $ReadOnly<{keepComments?: boolean}>,
 ) => void;
-type OptionalCallExpressionReplaceSignature = (
-  target: OptionalCallExpression,
-  nodeToReplaceWith: DetachedNode<OptionalCallExpression>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
-) => void;
 type OptionalIndexedAccessTypeReplaceSignature = (
   target: OptionalIndexedAccessType,
   nodeToReplaceWith: DetachedNode<OptionalIndexedAccessType>,
   options?: $ReadOnly<{keepComments?: boolean}>,
 ) => void;
-type OptionalMemberExpressionReplaceSignature = (
-  target: OptionalMemberExpression,
-  nodeToReplaceWith: DetachedNode<OptionalMemberExpression>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
-) => void;
-type PrivateNameReplaceSignature = (
-  target: PrivateName,
-  nodeToReplaceWith: DetachedNode<PrivateName>,
+type PrivateIdentifierReplaceSignature = (
+  target: PrivateIdentifier,
+  nodeToReplaceWith: DetachedNode<PrivateIdentifier>,
   options?: $ReadOnly<{keepComments?: boolean}>,
 ) => void;
 type ProgramReplaceSignature = (
@@ -763,6 +740,11 @@ type PropertyReplaceSignature = (
   nodeToReplaceWith: DetachedNode<Property>,
   options?: $ReadOnly<{keepComments?: boolean}>,
 ) => void;
+type PropertyDefinitionReplaceSignature = (
+  target: PropertyDefinition,
+  nodeToReplaceWith: DetachedNode<PropertyDefinition>,
+  options?: $ReadOnly<{keepComments?: boolean}>,
+) => void;
 type QualifiedTypeIdentifierReplaceSignature = (
   target: QualifiedTypeIdentifier,
   nodeToReplaceWith: DetachedNode<QualifiedTypeIdentifier>,
@@ -964,12 +946,11 @@ export type TransformReplaceSignatures = AnyTypeAnnotationReplaceSignature &
   BreakStatementReplaceSignature &
   CallExpressionReplaceSignature &
   CatchClauseReplaceSignature &
+  ChainExpressionReplaceSignature &
   ClassBodyReplaceSignature &
   ClassDeclarationReplaceSignature &
   ClassExpressionReplaceSignature &
   ClassImplementsReplaceSignature &
-  ClassPrivatePropertyReplaceSignature &
-  ClassPropertyReplaceSignature &
   ConditionalExpressionReplaceSignature &
   ContinueStatementReplaceSignature &
   DebuggerStatementReplaceSignature &
@@ -1000,7 +981,6 @@ export type TransformReplaceSignatures = AnyTypeAnnotationReplaceSignature &
   ExportAllDeclarationReplaceSignature &
   ExportDefaultDeclarationReplaceSignature &
   ExportNamedDeclarationReplaceSignature &
-  ExportNamespaceSpecifierReplaceSignature &
   ExportSpecifierReplaceSignature &
   ExpressionStatementReplaceSignature &
   ForInStatementReplaceSignature &
@@ -1060,12 +1040,11 @@ export type TransformReplaceSignatures = AnyTypeAnnotationReplaceSignature &
   ObjectTypePropertyReplaceSignature &
   ObjectTypeSpreadPropertyReplaceSignature &
   OpaqueTypeReplaceSignature &
-  OptionalCallExpressionReplaceSignature &
   OptionalIndexedAccessTypeReplaceSignature &
-  OptionalMemberExpressionReplaceSignature &
-  PrivateNameReplaceSignature &
+  PrivateIdentifierReplaceSignature &
   ProgramReplaceSignature &
   PropertyReplaceSignature &
+  PropertyDefinitionReplaceSignature &
   QualifiedTypeIdentifierReplaceSignature &
   RestElementReplaceSignature &
   ReturnStatementReplaceSignature &

package/dist/generated/node-types.js

@@ -33,12 +33,11 @@ var _exportNames = {
   BreakStatement: true,
   CallExpression: true,
   CatchClause: true,
+  ChainExpression: true,
   ClassBody: true,
   ClassDeclaration: true,
   ClassExpression: true,
   ClassImplements: true,
-  ClassPrivateProperty: true,
-  ClassProperty: true,
   ConditionalExpression: true,
   ContinueStatement: true,
   DebuggerStatement: true,
@@ -69,7 +68,6 @@ var _exportNames = {
   ExportAllDeclaration: true,
   ExportDefaultDeclaration: true,
   ExportNamedDeclaration: true,
-  ExportNamespaceSpecifier: true,
   ExportSpecifier: true,
   ExpressionStatement: true,
   ForInStatement: true,
@@ -128,11 +126,10 @@ var _exportNames = {
   ObjectTypeProperty: true,
   ObjectTypeSpreadProperty: true,
   OpaqueType: true,
-  OptionalCallExpression: true,
   OptionalIndexedAccessType: true,
-  OptionalMemberExpression: true,
-  PrivateName: true,
+  PrivateIdentifier: true,
   Property: true,
+  PropertyDefinition: true,
   QualifiedTypeIdentifier: true,
   RestElement: true,
   ReturnStatement: true,
@@ -184,12 +181,11 @@ exports.BooleanTypeAnnotation = BooleanTypeAnnotation;
 exports.BreakStatement = BreakStatement;
 exports.CallExpression = CallExpression;
 exports.CatchClause = CatchClause;
+exports.ChainExpression = ChainExpression;
 exports.ClassBody = ClassBody;
 exports.ClassDeclaration = ClassDeclaration;
 exports.ClassExpression = ClassExpression;
 exports.ClassImplements = ClassImplements;
-exports.ClassPrivateProperty = ClassPrivateProperty;
-exports.ClassProperty = ClassProperty;
 exports.ConditionalExpression = ConditionalExpression;
 exports.ContinueStatement = ContinueStatement;
 exports.DebuggerStatement = DebuggerStatement;
@@ -220,7 +216,6 @@ exports.ExistsTypeAnnotation = ExistsTypeAnnotation;
 exports.ExportAllDeclaration = ExportAllDeclaration;
 exports.ExportDefaultDeclaration = ExportDefaultDeclaration;
 exports.ExportNamedDeclaration = ExportNamedDeclaration;
-exports.ExportNamespaceSpecifier = ExportNamespaceSpecifier;
 exports.ExportSpecifier = ExportSpecifier;
 exports.ExpressionStatement = ExpressionStatement;
 exports.ForInStatement = ForInStatement;
@@ -279,11 +274,10 @@ exports.ObjectTypeInternalSlot = ObjectTypeInternalSlot;
 exports.ObjectTypeProperty = ObjectTypeProperty;
 exports.ObjectTypeSpreadProperty = ObjectTypeSpreadProperty;
 exports.OpaqueType = OpaqueType;
-exports.OptionalCallExpression = OptionalCallExpression;
 exports.OptionalIndexedAccessType = OptionalIndexedAccessType;
-exports.OptionalMemberExpression = OptionalMemberExpression;
-exports.PrivateName = PrivateName;
+exports.PrivateIdentifier = PrivateIdentifier;
 exports.Property = Property;
+exports.PropertyDefinition = PropertyDefinition;
 exports.QualifiedTypeIdentifier = QualifiedTypeIdentifier;
 exports.RestElement = RestElement;
 exports.ReturnStatement = ReturnStatement;
@@ -503,72 +497,60 @@ function CatchClause({
   return node;
 }
 
-function ClassBody({
+function ChainExpression({
   parent,
   ...props
 }) {
   const node = (0, _detachedNode.detachedProps)(parent, {
-    type: 'ClassBody',
+    type: 'ChainExpression',
     ...props
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function ClassDeclaration({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
-    type: 'ClassDeclaration',
-    ...props
-  });
-  (0, _detachedNode.setParentPointersInDirectChildren)(node);
-  return node;
-}
-
-function ClassExpression({
+function ClassBody({
   parent,
   ...props
 }) {
   const node = (0, _detachedNode.detachedProps)(parent, {
-    type: 'ClassExpression',
+    type: 'ClassBody',
     ...props
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function ClassImplements({
+function ClassDeclaration({
   parent,
   ...props
 }) {
   const node = (0, _detachedNode.detachedProps)(parent, {
-    type: 'ClassImplements',
+    type: 'ClassDeclaration',
     ...props
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function ClassPrivateProperty({
+function ClassExpression({
   parent,
   ...props
 }) {
   const node = (0, _detachedNode.detachedProps)(parent, {
-    type: 'ClassPrivateProperty',
+    type: 'ClassExpression',
     ...props
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function ClassProperty({
+function ClassImplements({
   parent,
   ...props
 }) {
   const node = (0, _detachedNode.detachedProps)(parent, {
-    type: 'ClassProperty',
+    type: 'ClassImplements',
     ...props
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
@@ -919,18 +901,6 @@ function ExportNamedDeclaration({
   return node;
 }
 
-function ExportNamespaceSpecifier({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
-    type: 'ExportNamespaceSpecifier',
-    ...props
-  });
-  (0, _detachedNode.setParentPointersInDirectChildren)(node);
-  return node;
-}
-
 function ExportSpecifier({
   parent,
   ...props
@@ -1599,18 +1569,6 @@ function OpaqueType({
   return node;
 }
 
-function OptionalCallExpression({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
-    type: 'OptionalCallExpression',
-    ...props
-  });
-  (0, _detachedNode.setParentPointersInDirectChildren)(node);
-  return node;
-}
-
 function OptionalIndexedAccessType({
   parent,
   ...props
@@ -1623,36 +1581,36 @@ function OptionalIndexedAccessType({
   return node;
 }
 
-function OptionalMemberExpression({
+function PrivateIdentifier({
   parent,
   ...props
 }) {
   const node = (0, _detachedNode.detachedProps)(parent, {
-    type: 'OptionalMemberExpression',
+    type: 'PrivateIdentifier',
     ...props
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function PrivateName({
+function Property({
   parent,
   ...props
 }) {
   const node = (0, _detachedNode.detachedProps)(parent, {
-    type: 'PrivateName',
+    type: 'Property',
     ...props
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function Property({
+function PropertyDefinition({
   parent,
   ...props
 }) {
   const node = (0, _detachedNode.detachedProps)(parent, {
-    type: 'Property',
+    type: 'PropertyDefinition',
     ...props
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);

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

@@ -31,12 +31,11 @@ import type {
   BreakStatement as BreakStatementType,
   CallExpression as CallExpressionType,
   CatchClause as CatchClauseType,
+  ChainExpression as ChainExpressionType,
   ClassBody as ClassBodyType,
   ClassDeclaration as ClassDeclarationType,
   ClassExpression as ClassExpressionType,
   ClassImplements as ClassImplementsType,
-  ClassPrivateProperty as ClassPrivatePropertyType,
-  ClassProperty as ClassPropertyType,
   ConditionalExpression as ConditionalExpressionType,
   ContinueStatement as ContinueStatementType,
   DebuggerStatement as DebuggerStatementType,
@@ -67,7 +66,6 @@ import type {
   ExportAllDeclaration as ExportAllDeclarationType,
   ExportDefaultDeclaration as ExportDefaultDeclarationType,
   ExportNamedDeclaration as ExportNamedDeclarationType,
-  ExportNamespaceSpecifier as ExportNamespaceSpecifierType,
   ExportSpecifier as ExportSpecifierType,
   ExpressionStatement as ExpressionStatementType,
   ForInStatement as ForInStatementType,
@@ -126,11 +124,10 @@ import type {
   ObjectTypeProperty as ObjectTypePropertyType,
   ObjectTypeSpreadProperty as ObjectTypeSpreadPropertyType,
   OpaqueType as OpaqueTypeType,
-  OptionalCallExpression as OptionalCallExpressionType,
   OptionalIndexedAccessType as OptionalIndexedAccessTypeType,
-  OptionalMemberExpression as OptionalMemberExpressionType,
-  PrivateName as PrivateNameType,
+  PrivateIdentifier as PrivateIdentifierType,
   Property as PropertyType,
+  PropertyDefinition as PropertyDefinitionType,
   QualifiedTypeIdentifier as QualifiedTypeIdentifierType,
   RestElement as RestElementType,
   ReturnStatement as ReturnStatementType,
@@ -245,6 +242,10 @@ export type CatchClauseProps = {
   +body: DetachedNode<CatchClauseType['body']>,
 };
 
+export type ChainExpressionProps = {
+  +expression: DetachedNode<ChainExpressionType['expression']>,
+};
+
 export type ClassBodyProps = {
   +body: $ReadOnlyArray<DetachedNode<ClassBodyType['body'][number]>>,
 };
@@ -286,27 +287,6 @@ export type ClassImplementsProps = {
   +typeParameters?: ?DetachedNode<ClassImplementsType['typeParameters']>,
 };
 
-export type ClassPrivatePropertyProps = {
-  +key: DetachedNode<ClassPrivatePropertyType['key']>,
-  +value?: ?DetachedNode<ClassPrivatePropertyType['value']>,
-  +static: ClassPrivatePropertyType['static'],
-  +declare: ClassPrivatePropertyType['declare'],
-  +optional: ClassPrivatePropertyType['optional'],
-  +variance?: ?DetachedNode<ClassPrivatePropertyType['variance']>,
-  +typeAnnotation?: ?DetachedNode<ClassPrivatePropertyType['typeAnnotation']>,
-};
-
-export type ClassPropertyProps = {
-  +key: DetachedNode<ClassPropertyType['key']>,
-  +value?: ?DetachedNode<ClassPropertyType['value']>,
-  +computed: ClassPropertyType['computed'],
-  +static: ClassPropertyType['static'],
-  +declare: ClassPropertyType['declare'],
-  +optional: ClassPropertyType['optional'],
-  +variance?: ?DetachedNode<ClassPropertyType['variance']>,
-  +typeAnnotation?: ?DetachedNode<ClassPropertyType['typeAnnotation']>,
-};
-
 export type ConditionalExpressionProps = {
   +test: DetachedNode<ConditionalExpressionType['test']>,
   +alternate: DetachedNode<ConditionalExpressionType['alternate']>,
@@ -449,6 +429,7 @@ export type EnumSymbolBodyProps = {
 export type ExistsTypeAnnotationProps = {};
 
 export type ExportAllDeclarationProps = {
+  +exported?: ?DetachedNode<ExportAllDeclarationType['exported']>,
   +source: DetachedNode<ExportAllDeclarationType['source']>,
   +exportKind: ExportAllDeclarationType['exportKind'],
 };
@@ -466,10 +447,6 @@ export type ExportNamedDeclarationProps = {
   +exportKind: ExportNamedDeclarationType['exportKind'],
 };
 
-export type ExportNamespaceSpecifierProps = {
-  +exported: DetachedNode<ExportNamespaceSpecifierType['exported']>,
-};
-
 export type ExportSpecifierProps = {
   +exported: DetachedNode<ExportSpecifierType['exported']>,
   +local: DetachedNode<ExportSpecifierType['local']>,
@@ -814,30 +791,14 @@ export type OpaqueTypeProps = {
   +supertype?: ?DetachedNode<OpaqueTypeType['supertype']>,
 };
 
-export type OptionalCallExpressionProps = {
-  +callee: DetachedNode<OptionalCallExpressionType['callee']>,
-  +typeArguments?: ?DetachedNode<OptionalCallExpressionType['typeArguments']>,
-  +arguments: $ReadOnlyArray<
-    DetachedNode<OptionalCallExpressionType['arguments'][number]>,
-  >,
-  +optional: OptionalCallExpressionType['optional'],
-};
-
 export type OptionalIndexedAccessTypeProps = {
   +objectType: DetachedNode<OptionalIndexedAccessTypeType['objectType']>,
   +indexType: DetachedNode<OptionalIndexedAccessTypeType['indexType']>,
   +optional: OptionalIndexedAccessTypeType['optional'],
 };
 
-export type OptionalMemberExpressionProps = {
-  +object: DetachedNode<OptionalMemberExpressionType['object']>,
-  +property: DetachedNode<OptionalMemberExpressionType['property']>,
-  +computed: OptionalMemberExpressionType['computed'],
-  +optional: OptionalMemberExpressionType['optional'],
-};
-
-export type PrivateNameProps = {
-  +id: DetachedNode<PrivateNameType['id']>,
+export type PrivateIdentifierProps = {
+  +name: PrivateIdentifierType['name'],
 };
 
 export type PropertyProps = {
@@ -849,6 +810,17 @@ export type PropertyProps = {
   +shorthand: PropertyType['shorthand'],
 };
 
+export type PropertyDefinitionProps = {
+  +key: DetachedNode<PropertyDefinitionType['key']>,
+  +value?: ?DetachedNode<PropertyDefinitionType['value']>,
+  +computed: PropertyDefinitionType['computed'],
+  +static: PropertyDefinitionType['static'],
+  +declare: PropertyDefinitionType['declare'],
+  +optional: PropertyDefinitionType['optional'],
+  +variance?: ?DetachedNode<PropertyDefinitionType['variance']>,
+  +typeAnnotation?: ?DetachedNode<PropertyDefinitionType['typeAnnotation']>,
+};
+
 export type QualifiedTypeIdentifierProps = {
   +qualification: DetachedNode<QualifiedTypeIdentifierType['qualification']>,
   +id: DetachedNode<QualifiedTypeIdentifierType['id']>,
@@ -1231,6 +1203,21 @@ export function CatchClause({
   return node;
 }
 
+export function ChainExpression({
+  parent,
+  ...props
+}: {
+  ...$ReadOnly<ChainExpressionProps>,
+  +parent?: ESNode,
+}): DetachedNode<ChainExpressionType> {
+  const node = detachedProps<ChainExpressionType>(parent, {
+    type: 'ChainExpression',
+    ...props,
+  });
+  setParentPointersInDirectChildren(node);
+  return node;
+}
+
 export function ClassBody({
   parent,
   ...props
@@ -1291,36 +1278,6 @@ export function ClassImplements({
   return node;
 }
 
-export function ClassPrivateProperty({
-  parent,
-  ...props
-}: {
-  ...$ReadOnly<ClassPrivatePropertyProps>,
-  +parent?: ESNode,
-}): DetachedNode<ClassPrivatePropertyType> {
-  const node = detachedProps<ClassPrivatePropertyType>(parent, {
-    type: 'ClassPrivateProperty',
-    ...props,
-  });
-  setParentPointersInDirectChildren(node);
-  return node;
-}
-
-export function ClassProperty({
-  parent,
-  ...props
-}: {
-  ...$ReadOnly<ClassPropertyProps>,
-  +parent?: ESNode,
-}): DetachedNode<ClassPropertyType> {
-  const node = detachedProps<ClassPropertyType>(parent, {
-    type: 'ClassProperty',
-    ...props,
-  });
-  setParentPointersInDirectChildren(node);
-  return node;
-}
-
 export function ConditionalExpression({
   parent,
   ...props
@@ -1751,21 +1708,6 @@ export function ExportNamedDeclaration({
   return node;
 }
 
-export function ExportNamespaceSpecifier({
-  parent,
-  ...props
-}: {
-  ...$ReadOnly<ExportNamespaceSpecifierProps>,
-  +parent?: ESNode,
-}): DetachedNode<ExportNamespaceSpecifierType> {
-  const node = detachedProps<ExportNamespaceSpecifierType>(parent, {
-    type: 'ExportNamespaceSpecifier',
-    ...props,
-  });
-  setParentPointersInDirectChildren(node);
-  return node;
-}
-
 export function ExportSpecifier({
   parent,
   ...props
@@ -2601,21 +2543,6 @@ export function OpaqueType({
   return node;
 }
 
-export function OptionalCallExpression({
-  parent,
-  ...props
-}: {
-  ...$ReadOnly<OptionalCallExpressionProps>,
-  +parent?: ESNode,
-}): DetachedNode<OptionalCallExpressionType> {
-  const node = detachedProps<OptionalCallExpressionType>(parent, {
-    type: 'OptionalCallExpression',
-    ...props,
-  });
-  setParentPointersInDirectChildren(node);
-  return node;
-}
-
 export function OptionalIndexedAccessType({
   parent,
   ...props
@@ -2631,45 +2558,45 @@ export function OptionalIndexedAccessType({
   return node;
 }
 
-export function OptionalMemberExpression({
+export function PrivateIdentifier({
   parent,
   ...props
 }: {
-  ...$ReadOnly<OptionalMemberExpressionProps>,
+  ...$ReadOnly<PrivateIdentifierProps>,
   +parent?: ESNode,
-}): DetachedNode<OptionalMemberExpressionType> {
-  const node = detachedProps<OptionalMemberExpressionType>(parent, {
-    type: 'OptionalMemberExpression',
+}): DetachedNode<PrivateIdentifierType> {
+  const node = detachedProps<PrivateIdentifierType>(parent, {
+    type: 'PrivateIdentifier',
     ...props,
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function PrivateName({
+export function Property({
   parent,
   ...props
 }: {
-  ...$ReadOnly<PrivateNameProps>,
+  ...$ReadOnly<PropertyProps>,
   +parent?: ESNode,
-}): DetachedNode<PrivateNameType> {
-  const node = detachedProps<PrivateNameType>(parent, {
-    type: 'PrivateName',
+}): DetachedNode<PropertyType> {
+  const node = detachedProps<PropertyType>(parent, {
+    type: 'Property',
     ...props,
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function Property({
+export function PropertyDefinition({
   parent,
   ...props
 }: {
-  ...$ReadOnly<PropertyProps>,
+  ...$ReadOnly<PropertyDefinitionProps>,
   +parent?: ESNode,
-}): DetachedNode<PropertyType> {
-  const node = detachedProps<PropertyType>(parent, {
-    type: 'Property',
+}): DetachedNode<PropertyDefinitionType> {
+  const node = detachedProps<PropertyDefinitionType>(parent, {
+    type: 'PropertyDefinition',
     ...props,
   });
   setParentPointersInDirectChildren(node);

package/dist/transform/mutations/InsertStatement.js

@@ -43,6 +43,7 @@ function createInsertStatementMutation(side, target, nodesToInsert) {
 }
 
 function performInsertStatementMutation(mutationContext, mutation) {
+  mutationContext.assertNotDeleted(mutation.target, `Attempted to insert ${mutation.side} a deleted ${mutation.target.type} node. This likely means that you attempted to mutate around the target after it was deleted/replaced.`);
   const insertionParent = (0, _getStatementParent.getStatementParent)(mutation.target); // enforce that if we are inserting module declarations - they are being inserted in a valid location
 
   if (!(0, _isValidModuleDeclarationParent.isValidModuleDeclarationParent)(insertionParent.parent, mutation.nodesToInsert)) {

package/dist/transform/mutations/InsertStatement.js.flow

@@ -46,6 +46,11 @@ export function performInsertStatementMutation(
   mutationContext: MutationContext,
   mutation: InsertStatementMutation,
 ): ESNode {
+  mutationContext.assertNotDeleted(
+    mutation.target,
+    `Attempted to insert ${mutation.side} a deleted ${mutation.target.type} node. This likely means that you attempted to mutate around the target after it was deleted/replaced.`,
+  );
+
   const insertionParent = getStatementParent(mutation.target);
 
   // enforce that if we are inserting module declarations - they are being inserted in a valid location

package/dist/transform/mutations/RemoveNode.js

@@ -46,8 +46,7 @@ function getRemovalParent(node) {
 
     switch (node.type) {
       // ClassMember
-      case 'ClassProperty':
-      case 'ClassPrivateProperty':
+      case 'PropertyDefinition':
       case 'MethodDefinition':
         assertParent('ClassBody');
         return 'body';
@@ -70,6 +69,14 @@ function getRemovalParent(node) {
         assertParent('FunctionTypeAnnotation');
         return 'params';
 
+      case 'JSXAttribute':
+        assertParent('JSXOpeningElement');
+        return 'attributes';
+
+      case 'ImportDeclaration':
+        assertParent('Program');
+        return 'body';
+
       case 'ObjectTypeCallProperty':
         assertParent('ObjectTypeAnnotation');
         return 'callProperties';
@@ -161,7 +168,7 @@ function getRemovalParent(node) {
     const idx = arr.indexOf(node);
 
     if (idx === -1) {
-      throw new _Errors.InvalidRemovalError(`Could not find target in array of \`${parent.type}.${key}\`.`);
+      throw new _Errors.InvalidRemovalError(`Could not find target in array of \`${node.parent.type}.${key}\`.`);
     }
 
     return idx;

package/dist/transform/mutations/RemoveNode.js.flow

@@ -17,6 +17,8 @@ import type {
   EnumStringMember,
   FunctionParameter,
   FunctionTypeParam,
+  JSXAttribute,
+  ImportDeclaration,
   ObjectTypeCallProperty,
   ObjectTypeIndexer,
   ObjectTypeInternalSlot,
@@ -41,6 +43,8 @@ export type RemoveNodeMutation = $ReadOnly<{
     | EnumStringMember
     | FunctionParameter
     | FunctionTypeParam
+    | JSXAttribute
+    | ImportDeclaration
     | ObjectTypeCallProperty
     | ObjectTypeIndexer
     | ObjectTypeInternalSlot
@@ -102,8 +106,7 @@ function getRemovalParent(node: RemoveNodeMutation['node']): $ReadOnly<{
 
     switch (node.type) {
       // ClassMember
-      case 'ClassProperty':
-      case 'ClassPrivateProperty':
+      case 'PropertyDefinition':
       case 'MethodDefinition':
         assertParent('ClassBody');
         return 'body';
@@ -126,6 +129,14 @@ function getRemovalParent(node: RemoveNodeMutation['node']): $ReadOnly<{
         assertParent('FunctionTypeAnnotation');
         return 'params';
 
+      case 'JSXAttribute':
+        assertParent('JSXOpeningElement');
+        return 'attributes';
+
+      case 'ImportDeclaration':
+        assertParent('Program');
+        return 'body';
+
       case 'ObjectTypeCallProperty':
         assertParent('ObjectTypeAnnotation');
         return 'callProperties';
@@ -244,7 +255,7 @@ function getRemovalParent(node: RemoveNodeMutation['node']): $ReadOnly<{
     const idx = arr.indexOf(node);
     if (idx === -1) {
       throw new InvalidRemovalError(
-        `Could not find target in array of \`${parent.type}.${key}\`.`,
+        `Could not find target in array of \`${node.parent.type}.${key}\`.`,
       );
     }
     return idx;

package/dist/transform/transform.js

@@ -33,16 +33,26 @@ function transform(originalCode, visitors, prettierOptions = {}) {
 
   if (!astWasMutated) {
     return originalCode;
-  } // prettier fully expects the parent pointers are NOT set and
-  // certain cases can crash due to prettier infinite-looping
-  // whilst naively traversing the parent property
-  // https://github.com/prettier/prettier/issues/11793
-
+  }
 
   _SimpleTraverser.SimpleTraverser.traverse(ast, {
     enter(node) {
+      // prettier fully expects the parent pointers are NOT set and
+      // certain cases can crash due to prettier infinite-looping
+      // whilst naively traversing the parent property
+      // https://github.com/prettier/prettier/issues/11793
       // $FlowExpectedError[cannot-write]
-      delete node.parent;
+      delete node.parent; // prettier currently relies on the AST being in the old-school, deprecated AST format for optional chaining
+      // so we have to apply their transform to our AST so it can actually format it.
+
+      if (node.type === 'ChainExpression') {
+        const newNode = transformChainExpression(node.expression); // $FlowExpectedError[cannot-write]
+
+        delete node.expression; // $FlowExpectedError[prop-missing]
+        // $FlowExpectedError[cannot-write]
+
+        Object.assign(node, newNode);
+      }
     },
 
     leave() {}
@@ -62,4 +72,26 @@ function transform(originalCode, visitors, prettierOptions = {}) {
     }
 
   });
+} // https://github.com/prettier/prettier/blob/d962466a828f8ef51435e3e8840178d90b7ec6cd/src/language-js/parse/postprocess/index.js#L161-L182
+
+
+function transformChainExpression(node) {
+  switch (node.type) {
+    case 'CallExpression':
+      // $FlowExpectedError[cannot-write]
+      node.type = 'OptionalCallExpression'; // $FlowExpectedError[cannot-write]
+
+      node.callee = transformChainExpression(node.callee);
+      break;
+
+    case 'MemberExpression':
+      // $FlowExpectedError[cannot-write]
+      node.type = 'OptionalMemberExpression'; // $FlowExpectedError[cannot-write]
+
+      node.object = transformChainExpression(node.object);
+      break;
+    // No default
+  }
+
+  return node;
 }

package/dist/transform/transform.js.flow

@@ -10,6 +10,7 @@
 
 'use strict';
 
+import type {ESNode} from 'hermes-estree';
 import type {Visitor} from '../traverse/traverse';
 import type {TransformContextAdditions} from './TransformContext';
 
@@ -33,14 +34,25 @@ export function transform(
     return originalCode;
   }
 
-  // prettier fully expects the parent pointers are NOT set and
-  // certain cases can crash due to prettier infinite-looping
-  // whilst naively traversing the parent property
-  // https://github.com/prettier/prettier/issues/11793
   SimpleTraverser.traverse(ast, {
     enter(node) {
+      // prettier fully expects the parent pointers are NOT set and
+      // certain cases can crash due to prettier infinite-looping
+      // whilst naively traversing the parent property
+      // https://github.com/prettier/prettier/issues/11793
       // $FlowExpectedError[cannot-write]
       delete node.parent;
+
+      // prettier currently relies on the AST being in the old-school, deprecated AST format for optional chaining
+      // so we have to apply their transform to our AST so it can actually format it.
+      if (node.type === 'ChainExpression') {
+        const newNode = transformChainExpression(node.expression);
+        // $FlowExpectedError[cannot-write]
+        delete node.expression;
+        // $FlowExpectedError[prop-missing]
+        // $FlowExpectedError[cannot-write]
+        Object.assign(node, newNode);
+      }
     },
     leave() {},
   });
@@ -62,3 +74,25 @@ export function transform(
     },
   );
 }
+
+// https://github.com/prettier/prettier/blob/d962466a828f8ef51435e3e8840178d90b7ec6cd/src/language-js/parse/postprocess/index.js#L161-L182
+function transformChainExpression(node: ESNode) {
+  switch (node.type) {
+    case 'CallExpression':
+      // $FlowExpectedError[cannot-write]
+      node.type = 'OptionalCallExpression';
+      // $FlowExpectedError[cannot-write]
+      node.callee = transformChainExpression(node.callee);
+      break;
+
+    case 'MemberExpression':
+      // $FlowExpectedError[cannot-write]
+      node.type = 'OptionalMemberExpression';
+      // $FlowExpectedError[cannot-write]
+      node.object = transformChainExpression(node.object);
+      break;
+    // No default
+  }
+
+  return node;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hermes-transform",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Tools built on top of Hermes-ESTree to enable codebase transformation",
   "main": "dist/index.js",
   "license": "MIT",
@@ -12,8 +12,8 @@
     "@babel/code-frame": "^7.16.0",
     "esquery": "^1.4.0",
     "flow-enums-runtime": "^0.0.6",
-    "hermes-eslint": "0.7.0",
-    "hermes-estree": "0.7.0"
+    "hermes-eslint": "0.8.0",
+    "hermes-estree": "0.8.0"
   },
   "peerDependencies": {
     "prettier": "^2.4.1"