hphp/hack/src/parser/php/full_fidelity_editable.php

   1 <?hh // strict
   2 /**
   3  * Copyright (c) 2016, Facebook, Inc.
   4  * All rights reserved.
   5  *
   6  * This source code is licensed under the BSD-style license found in the
   7  * LICENSE file in the "hack" directory of this source tree. An additional
   8  * grant of patent rights can be found in the PATENTS file in the same
   9  * directory.
  10  *
  11  **
  12  *
  13  * THIS FILE IS @generated; DO NOT EDIT IT
  14  * To regenerate this file, run
  15  *
  16  *   buck run //hphp/hack/src:generate_full_fidelity
  17  *
  18  **
  19  *
  20  */
  21
  22 require_once 'full_fidelity_parser.php';
  23
  24 abstract class EditableSyntax implements ArrayAccess {
  25   private string $_syntax_kind;
  26   protected ?int $_width;
  27   public function __construct(string $syntax_kind) {
  28     $this->_syntax_kind = $syntax_kind;
  29   }
  30
  31   public function offsetExists (mixed $offset): bool {
  32     return $offset === 0;
  33   }
  34
  35   public function offsetGet (mixed $offset): mixed {
  36     return $this;
  37   }
  38
  39   public function offsetSet (mixed $offset, mixed $value): void {
  40   }
  41
  42   public function offsetUnset (mixed $offset): void {
  43   }
  44
  45   public function syntax_kind(): string {
  46     return $this->_syntax_kind;
  47   }
  48
  49   public abstract function children():
  50     Generator<string, EditableSyntax, void>;
  51
  52   public function preorder(): Continuation<EditableSyntax> {
  53     yield $this;
  54     foreach($this->children() as $name => $child)
  55       foreach($child->preorder() as $descendant)
  56         yield $descendant;
  57   }
  58
  59   private function _parented_preorder(array<EditableSyntax> $parents):
  60     Continuation<(EditableSyntax, array<EditableSyntax>)> {
  61     $new_parents = $parents;
  62     array_push($new_parents, $this);
  63     yield tuple($this, $parents);
  64     foreach($this->children() as $name => $child)
  65       foreach($child->_parented_preorder($new_parents) as $descendant)
  66         yield $descendant;
  67   }
  68
  69   public function parented_preorder():
  70     Continuation<(EditableSyntax, array<EditableSyntax>)> {
  71     return $this->_parented_preorder([]);
  72   }
  73
  74   public function postorder(): Continuation<EditableSyntax> {
  75     foreach($this->children() as $name => $child)
  76       foreach($child->preorder() as $descendant)
  77         yield $descendant;
  78     yield $this;
  79   }
  80
  81   public function is_token(): bool {
  82     return false;
  83   }
  84
  85   public function is_trivia(): bool {
  86     return false;
  87   }
  88
  89   public function is_list(): bool {
  90     return false;
  91   }
  92
  93   public function is_missing(): bool {
  94     return false;
  95   }
  96
  97   public function width(): int {
  98     if ($this->_width === null) {
  99       $width = 0;
 100       /* TODO: Make an accumulation sequence operator */
 101       foreach ($this->children() as $name => $node) {
 102         $width += $node->width();
 103       }
 104       $this->_width = $width;
 105       return $width;
 106     } else {
 107       return $this->_width;
 108     }
 109   }
 110
 111   public function full_text(): string {
 112     /* TODO: Make an accumulation sequence operator */
 113     $s = '';
 114     foreach ($this->children() as $name => $node) {
 115       $s .= $node->full_text();
 116     }
 117     return $s;
 118   }
 119
 120   public static function from_json(mixed $json, int $position, string $source) {
 121     switch($json->kind) {
 122     case 'token':
 123       return EditableToken::from_json($json->token, $position, $source);
 124     case 'list':
 125       return EditableList::from_json($json, $position, $source);
 126     case 'whitespace':
 127       return WhiteSpace::from_json($json, $position, $source);
 128     case 'end_of_line':
 129       return EndOfLine::from_json($json, $position, $source);
 130     case 'delimited_comment':
 131       return DelimitedComment::from_json($json, $position, $source);
 132     case 'single_line_comment':
 133       return SingleLineComment::from_json($json, $position, $source);
 134     case 'unsafe':
 135       return Unsafe::from_json($json, $position, $source);
 136     case 'unsafe_expression':
 137       return UnsafeExpression::from_json($json, $position, $source);
 138     case 'fix_me':
 139       return FixMe::from_json($json, $position, $source);
 140     case 'ignore_error':
 141       return IgnoreError::from_json($json, $position, $source);
 142     case 'fall_through':
 143       return FallThrough::from_json($json, $position, $source);
 144     case 'extra_token_error':
 145       return ExtraTokenError::from_json($json, $position, $source);
 146     case 'after_halt_compiler':
 147       return AfterHaltCompiler::from_json($json, $position, $source);
 148
 149     case 'missing':
 150       return Missing::missing();
 151     case 'end_of_file':
 152       return EndOfFile::from_json($json, $position, $source);
 153     case 'script':
 154       return Script::from_json($json, $position, $source);
 155     case 'simple_type_specifier':
 156       return SimpleTypeSpecifier::from_json($json, $position, $source);
 157     case 'literal':
 158       return LiteralExpression::from_json($json, $position, $source);
 159     case 'variable':
 160       return VariableExpression::from_json($json, $position, $source);
 161     case 'qualified_name':
 162       return QualifiedNameExpression::from_json($json, $position, $source);
 163     case 'pipe_variable':
 164       return PipeVariableExpression::from_json($json, $position, $source);
 165     case 'enum_declaration':
 166       return EnumDeclaration::from_json($json, $position, $source);
 167     case 'enumerator':
 168       return Enumerator::from_json($json, $position, $source);
 169     case 'alias_declaration':
 170       return AliasDeclaration::from_json($json, $position, $source);
 171     case 'property_declaration':
 172       return PropertyDeclaration::from_json($json, $position, $source);
 173     case 'property_declarator':
 174       return PropertyDeclarator::from_json($json, $position, $source);
 175     case 'namespace_declaration':
 176       return NamespaceDeclaration::from_json($json, $position, $source);
 177     case 'namespace_body':
 178       return NamespaceBody::from_json($json, $position, $source);
 179     case 'namespace_empty_body':
 180       return NamespaceEmptyBody::from_json($json, $position, $source);
 181     case 'namespace_use_declaration':
 182       return NamespaceUseDeclaration::from_json($json, $position, $source);
 183     case 'namespace_group_use_declaration':
 184       return NamespaceGroupUseDeclaration::from_json($json, $position, $source);
 185     case 'namespace_use_clause':
 186       return NamespaceUseClause::from_json($json, $position, $source);
 187     case 'function_declaration':
 188       return FunctionDeclaration::from_json($json, $position, $source);
 189     case 'function_declaration_header':
 190       return FunctionDeclarationHeader::from_json($json, $position, $source);
 191     case 'where_clause':
 192       return WhereClause::from_json($json, $position, $source);
 193     case 'where_constraint':
 194       return WhereConstraint::from_json($json, $position, $source);
 195     case 'methodish_declaration':
 196       return MethodishDeclaration::from_json($json, $position, $source);
 197     case 'classish_declaration':
 198       return ClassishDeclaration::from_json($json, $position, $source);
 199     case 'classish_body':
 200       return ClassishBody::from_json($json, $position, $source);
 201     case 'trait_use_precedence_item':
 202       return TraitUsePrecedenceItem::from_json($json, $position, $source);
 203     case 'trait_use_alias_item':
 204       return TraitUseAliasItem::from_json($json, $position, $source);
 205     case 'trait_use_conflict_resolution':
 206       return TraitUseConflictResolution::from_json($json, $position, $source);
 207     case 'trait_use':
 208       return TraitUse::from_json($json, $position, $source);
 209     case 'require_clause':
 210       return RequireClause::from_json($json, $position, $source);
 211     case 'const_declaration':
 212       return ConstDeclaration::from_json($json, $position, $source);
 213     case 'constant_declarator':
 214       return ConstantDeclarator::from_json($json, $position, $source);
 215     case 'type_const_declaration':
 216       return TypeConstDeclaration::from_json($json, $position, $source);
 217     case 'decorated_expression':
 218       return DecoratedExpression::from_json($json, $position, $source);
 219     case 'parameter_declaration':
 220       return ParameterDeclaration::from_json($json, $position, $source);
 221     case 'variadic_parameter':
 222       return VariadicParameter::from_json($json, $position, $source);
 223     case 'attribute_specification':
 224       return AttributeSpecification::from_json($json, $position, $source);
 225     case 'attribute':
 226       return Attribute::from_json($json, $position, $source);
 227     case 'inclusion_expression':
 228       return InclusionExpression::from_json($json, $position, $source);
 229     case 'inclusion_directive':
 230       return InclusionDirective::from_json($json, $position, $source);
 231     case 'compound_statement':
 232       return CompoundStatement::from_json($json, $position, $source);
 233     case 'expression_statement':
 234       return ExpressionStatement::from_json($json, $position, $source);
 235     case 'markup_section':
 236       return MarkupSection::from_json($json, $position, $source);
 237     case 'markup_suffix':
 238       return MarkupSuffix::from_json($json, $position, $source);
 239     case 'unset_statement':
 240       return UnsetStatement::from_json($json, $position, $source);
 241     case 'using_statement_block_scoped':
 242       return UsingStatementBlockScoped::from_json($json, $position, $source);
 243     case 'using_statement_function_scoped':
 244       return UsingStatementFunctionScoped::from_json($json, $position, $source);
 245     case 'declare_directive_statement':
 246       return DeclareDirectiveStatement::from_json($json, $position, $source);
 247     case 'declare_block_statement':
 248       return DeclareBlockStatement::from_json($json, $position, $source);
 249     case 'while_statement':
 250       return WhileStatement::from_json($json, $position, $source);
 251     case 'if_statement':
 252       return IfStatement::from_json($json, $position, $source);
 253     case 'elseif_clause':
 254       return ElseifClause::from_json($json, $position, $source);
 255     case 'else_clause':
 256       return ElseClause::from_json($json, $position, $source);
 257     case 'if_endif_statement':
 258       return IfEndIfStatement::from_json($json, $position, $source);
 259     case 'elseif_colon_clause':
 260       return ElseifColonClause::from_json($json, $position, $source);
 261     case 'else_colon_clause':
 262       return ElseColonClause::from_json($json, $position, $source);
 263     case 'try_statement':
 264       return TryStatement::from_json($json, $position, $source);
 265     case 'catch_clause':
 266       return CatchClause::from_json($json, $position, $source);
 267     case 'finally_clause':
 268       return FinallyClause::from_json($json, $position, $source);
 269     case 'do_statement':
 270       return DoStatement::from_json($json, $position, $source);
 271     case 'for_statement':
 272       return ForStatement::from_json($json, $position, $source);
 273     case 'foreach_statement':
 274       return ForeachStatement::from_json($json, $position, $source);
 275     case 'switch_statement':
 276       return SwitchStatement::from_json($json, $position, $source);
 277     case 'switch_section':
 278       return SwitchSection::from_json($json, $position, $source);
 279     case 'switch_fallthrough':
 280       return SwitchFallthrough::from_json($json, $position, $source);
 281     case 'case_label':
 282       return CaseLabel::from_json($json, $position, $source);
 283     case 'default_label':
 284       return DefaultLabel::from_json($json, $position, $source);
 285     case 'return_statement':
 286       return ReturnStatement::from_json($json, $position, $source);
 287     case 'goto_label':
 288       return GotoLabel::from_json($json, $position, $source);
 289     case 'goto_statement':
 290       return GotoStatement::from_json($json, $position, $source);
 291     case 'throw_statement':
 292       return ThrowStatement::from_json($json, $position, $source);
 293     case 'break_statement':
 294       return BreakStatement::from_json($json, $position, $source);
 295     case 'continue_statement':
 296       return ContinueStatement::from_json($json, $position, $source);
 297     case 'function_static_statement':
 298       return FunctionStaticStatement::from_json($json, $position, $source);
 299     case 'static_declarator':
 300       return StaticDeclarator::from_json($json, $position, $source);
 301     case 'echo_statement':
 302       return EchoStatement::from_json($json, $position, $source);
 303     case 'global_statement':
 304       return GlobalStatement::from_json($json, $position, $source);
 305     case 'simple_initializer':
 306       return SimpleInitializer::from_json($json, $position, $source);
 307     case 'anonymous_class':
 308       return AnonymousClass::from_json($json, $position, $source);
 309     case 'anonymous_function':
 310       return AnonymousFunction::from_json($json, $position, $source);
 311     case 'php7_anonymous_function':
 312       return Php7AnonymousFunction::from_json($json, $position, $source);
 313     case 'anonymous_function_use_clause':
 314       return AnonymousFunctionUseClause::from_json($json, $position, $source);
 315     case 'lambda_expression':
 316       return LambdaExpression::from_json($json, $position, $source);
 317     case 'lambda_signature':
 318       return LambdaSignature::from_json($json, $position, $source);
 319     case 'cast_expression':
 320       return CastExpression::from_json($json, $position, $source);
 321     case 'scope_resolution_expression':
 322       return ScopeResolutionExpression::from_json($json, $position, $source);
 323     case 'member_selection_expression':
 324       return MemberSelectionExpression::from_json($json, $position, $source);
 325     case 'safe_member_selection_expression':
 326       return SafeMemberSelectionExpression::from_json($json, $position, $source);
 327     case 'embedded_member_selection_expression':
 328       return EmbeddedMemberSelectionExpression::from_json($json, $position, $source);
 329     case 'yield_expression':
 330       return YieldExpression::from_json($json, $position, $source);
 331     case 'yield_from_expression':
 332       return YieldFromExpression::from_json($json, $position, $source);
 333     case 'prefix_unary_expression':
 334       return PrefixUnaryExpression::from_json($json, $position, $source);
 335     case 'postfix_unary_expression':
 336       return PostfixUnaryExpression::from_json($json, $position, $source);
 337     case 'binary_expression':
 338       return BinaryExpression::from_json($json, $position, $source);
 339     case 'instanceof_expression':
 340       return InstanceofExpression::from_json($json, $position, $source);
 341     case 'is_expression':
 342       return IsExpression::from_json($json, $position, $source);
 343     case 'conditional_expression':
 344       return ConditionalExpression::from_json($json, $position, $source);
 345     case 'eval_expression':
 346       return EvalExpression::from_json($json, $position, $source);
 347     case 'empty_expression':
 348       return EmptyExpression::from_json($json, $position, $source);
 349     case 'define_expression':
 350       return DefineExpression::from_json($json, $position, $source);
 351     case 'halt_compiler_expression':
 352       return HaltCompilerExpression::from_json($json, $position, $source);
 353     case 'isset_expression':
 354       return IssetExpression::from_json($json, $position, $source);
 355     case 'function_call_expression':
 356       return FunctionCallExpression::from_json($json, $position, $source);
 357     case 'function_call_with_type_arguments_expression':
 358       return FunctionCallWithTypeArgumentsExpression::from_json($json, $position, $source);
 359     case 'parenthesized_expression':
 360       return ParenthesizedExpression::from_json($json, $position, $source);
 361     case 'braced_expression':
 362       return BracedExpression::from_json($json, $position, $source);
 363     case 'embedded_braced_expression':
 364       return EmbeddedBracedExpression::from_json($json, $position, $source);
 365     case 'list_expression':
 366       return ListExpression::from_json($json, $position, $source);
 367     case 'collection_literal_expression':
 368       return CollectionLiteralExpression::from_json($json, $position, $source);
 369     case 'object_creation_expression':
 370       return ObjectCreationExpression::from_json($json, $position, $source);
 371     case 'constructor_call':
 372       return ConstructorCall::from_json($json, $position, $source);
 373     case 'array_creation_expression':
 374       return ArrayCreationExpression::from_json($json, $position, $source);
 375     case 'array_intrinsic_expression':
 376       return ArrayIntrinsicExpression::from_json($json, $position, $source);
 377     case 'darray_intrinsic_expression':
 378       return DarrayIntrinsicExpression::from_json($json, $position, $source);
 379     case 'dictionary_intrinsic_expression':
 380       return DictionaryIntrinsicExpression::from_json($json, $position, $source);
 381     case 'keyset_intrinsic_expression':
 382       return KeysetIntrinsicExpression::from_json($json, $position, $source);
 383     case 'varray_intrinsic_expression':
 384       return VarrayIntrinsicExpression::from_json($json, $position, $source);
 385     case 'vector_intrinsic_expression':
 386       return VectorIntrinsicExpression::from_json($json, $position, $source);
 387     case 'element_initializer':
 388       return ElementInitializer::from_json($json, $position, $source);
 389     case 'subscript_expression':
 390       return SubscriptExpression::from_json($json, $position, $source);
 391     case 'embedded_subscript_expression':
 392       return EmbeddedSubscriptExpression::from_json($json, $position, $source);
 393     case 'awaitable_creation_expression':
 394       return AwaitableCreationExpression::from_json($json, $position, $source);
 395     case 'xhp_children_declaration':
 396       return XHPChildrenDeclaration::from_json($json, $position, $source);
 397     case 'xhp_children_parenthesized_list':
 398       return XHPChildrenParenthesizedList::from_json($json, $position, $source);
 399     case 'xhp_category_declaration':
 400       return XHPCategoryDeclaration::from_json($json, $position, $source);
 401     case 'xhp_enum_type':
 402       return XHPEnumType::from_json($json, $position, $source);
 403     case 'xhp_required':
 404       return XHPRequired::from_json($json, $position, $source);
 405     case 'xhp_class_attribute_declaration':
 406       return XHPClassAttributeDeclaration::from_json($json, $position, $source);
 407     case 'xhp_class_attribute':
 408       return XHPClassAttribute::from_json($json, $position, $source);
 409     case 'xhp_simple_class_attribute':
 410       return XHPSimpleClassAttribute::from_json($json, $position, $source);
 411     case 'xhp_simple_attribute':
 412       return XHPSimpleAttribute::from_json($json, $position, $source);
 413     case 'xhp_spread_attribute':
 414       return XHPSpreadAttribute::from_json($json, $position, $source);
 415     case 'xhp_open':
 416       return XHPOpen::from_json($json, $position, $source);
 417     case 'xhp_expression':
 418       return XHPExpression::from_json($json, $position, $source);
 419     case 'xhp_close':
 420       return XHPClose::from_json($json, $position, $source);
 421     case 'type_constant':
 422       return TypeConstant::from_json($json, $position, $source);
 423     case 'vector_type_specifier':
 424       return VectorTypeSpecifier::from_json($json, $position, $source);
 425     case 'keyset_type_specifier':
 426       return KeysetTypeSpecifier::from_json($json, $position, $source);
 427     case 'tuple_type_explicit_specifier':
 428       return TupleTypeExplicitSpecifier::from_json($json, $position, $source);
 429     case 'varray_type_specifier':
 430       return VarrayTypeSpecifier::from_json($json, $position, $source);
 431     case 'vector_array_type_specifier':
 432       return VectorArrayTypeSpecifier::from_json($json, $position, $source);
 433     case 'type_parameter':
 434       return TypeParameter::from_json($json, $position, $source);
 435     case 'type_constraint':
 436       return TypeConstraint::from_json($json, $position, $source);
 437     case 'darray_type_specifier':
 438       return DarrayTypeSpecifier::from_json($json, $position, $source);
 439     case 'map_array_type_specifier':
 440       return MapArrayTypeSpecifier::from_json($json, $position, $source);
 441     case 'dictionary_type_specifier':
 442       return DictionaryTypeSpecifier::from_json($json, $position, $source);
 443     case 'closure_type_specifier':
 444       return ClosureTypeSpecifier::from_json($json, $position, $source);
 445     case 'closure_parameter_type_specifier':
 446       return ClosureParameterTypeSpecifier::from_json($json, $position, $source);
 447     case 'classname_type_specifier':
 448       return ClassnameTypeSpecifier::from_json($json, $position, $source);
 449     case 'field_specifier':
 450       return FieldSpecifier::from_json($json, $position, $source);
 451     case 'field_initializer':
 452       return FieldInitializer::from_json($json, $position, $source);
 453     case 'shape_type_specifier':
 454       return ShapeTypeSpecifier::from_json($json, $position, $source);
 455     case 'shape_expression':
 456       return ShapeExpression::from_json($json, $position, $source);
 457     case 'tuple_expression':
 458       return TupleExpression::from_json($json, $position, $source);
 459     case 'generic_type_specifier':
 460       return GenericTypeSpecifier::from_json($json, $position, $source);
 461     case 'nullable_type_specifier':
 462       return NullableTypeSpecifier::from_json($json, $position, $source);
 463     case 'soft_type_specifier':
 464       return SoftTypeSpecifier::from_json($json, $position, $source);
 465     case 'type_arguments':
 466       return TypeArguments::from_json($json, $position, $source);
 467     case 'type_parameters':
 468       return TypeParameters::from_json($json, $position, $source);
 469     case 'tuple_type_specifier':
 470       return TupleTypeSpecifier::from_json($json, $position, $source);
 471     case 'error':
 472       return ErrorSyntax::from_json($json, $position, $source);
 473     case 'list_item':
 474       return ListItem::from_json($json, $position, $source);
 475
 476     default:
 477       throw new Exception('unexpected json kind: ' . $json->kind);
 478       // TODO: Better exception
 479     }
 480   }
 481
 482   public function to_array(): array<EditableSyntax> {
 483     return [$this];
 484   }
 485
 486   public function reduce<TAccumulator>(
 487     (function
 488       ( EditableSyntax,
 489         TAccumulator,
 490         array<EditableSyntax>): TAccumulator) $reducer,
 491     TAccumulator $accumulator,
 492     ?array<EditableSyntax> $parents = null): TAccumulator {
 493     $new_parents = $parents ?? [];
 494     array_push($new_parents, $this);
 495     foreach($this->children() as $child) {
 496       $accumulator = $child->reduce($reducer, $accumulator, $new_parents);
 497     }
 498     return $reducer($this, $accumulator, $parents ?? []);
 499   }
 500
 501   // Returns all the parents (and the node itself) of the first node
 502   // that matches a predicate, or [] if there is no such node.
 503   public function find_with_parents(
 504     (function(EditableSyntax):bool) $predicate,
 505     ?array<EditableSyntax> $parents = null): array<EditableSyntax> {
 506     $new_parents = $parents ?? [];
 507     array_push($new_parents, $this);
 508     if ($predicate($this))
 509       return $new_parents;
 510     foreach($this->children() as $child) {
 511       $result = $child->find_with_parents($predicate, $new_parents);
 512       if (count($result) != 0)
 513         return $result;
 514     }
 515     return [];
 516   }
 517
 518   // Returns a list of nodes that match a predicate.
 519   public function filter(
 520     (function(EditableSyntax, ?array<EditableSyntax>):bool) $predicate):
 521       array<EditableSyntax> {
 522     $reducer = ($node, $acc, $parents) ==> {
 523       if ($predicate($node, $parents))
 524         array_push($acc, $node);
 525       return $acc;
 526     };
 527     return $this->reduce($reducer, []);
 528   }
 529
 530   public function of_syntax_kind(string $kind): Continuation<EditableSyntax> {
 531     foreach($this->preorder() as $child)
 532       if ($child->syntax_kind() === $kind)
 533         yield $child;
 534   }
 535
 536   public function remove_where(
 537     (function(EditableSyntax, ?array<EditableSyntax>):bool) $predicate):
 538       array<EditableSyntax> {
 539     return $this->rewrite(
 540       ($node, $parents) ==>
 541         $predicate($node, $parents) ? Missing::missing() : $node);
 542   }
 543
 544   public function without(EditableSyntax $target): EditableSyntax {
 545     return $this->remove_where(($node, $parents) ==> $node === $target);
 546   }
 547
 548   public function replace(
 549     EditableSyntax $new_node,
 550     EditableSyntax $target): EditableSyntax {
 551     return $this->rewrite(
 552       ($node, $parents) ==> $node === $target ? $new_node : $node);
 553   }
 554
 555   public function leftmost_token(): ?EditableSyntax {
 556     if ($this->is_token())
 557       return $this;
 558     foreach($this->children() as $child)
 559     {
 560       if (!$child->is_missing())
 561         return $child->leftmost_token();
 562     }
 563     return null;
 564   }
 565
 566   public function rightmost_token(): ?EditableSyntax {
 567     if ($this->is_token())
 568       return $this;
 569
 570     // TODO: Better way to reverse a sequence?
 571     foreach (array_reverse(iterator_to_array($this->children())) as $child) {
 572       if (!$child->is_missing())
 573         return $child->rightmost_token();
 574     }
 575     return null;
 576   }
 577
 578   public function insert_before(
 579     EditableSyntax $new_node,
 580     EditableSyntax $target): EditableSyntax {
 581     // Inserting before missing is an error.
 582     if ($target->is_missing())
 583       throw new Exception('Target must not be missing in insert_before.');
 584
 585     // Inserting missing is a no-op
 586     if ($new_node->is_missing())
 587       return $this;
 588
 589     if ($new_node->is_trivia() && !$target->is_trivia()) {
 590       $token = $target->is_token() ? $target : $target->leftmost_token();
 591       if ($token === null)
 592         throw new Exception('Unable to find token to insert trivia.');
 593
 594       // Inserting trivia before token is inserting to the right end of
 595       // the leading trivia.
 596       $new_leading = EditableList::concatenate_lists(
 597         $token->leading(), $new_node);
 598       $new_token = $token->with_leading($new_leading);
 599       return $this->replace($new_token, $token);
 600     }
 601
 602     return $this->replace(
 603       EditableList::concatenate_lists($new_node, $target), $target);
 604   }
 605
 606   public function insert_after(
 607     EditableSyntax $new_node,
 608     EditableSyntax $target): EditableSyntax {
 609
 610     // Inserting after missing is an error.
 611     if ($target->is_missing())
 612       throw new Exception('Target must not be missing in insert_after.');
 613
 614     // Inserting missing is a no-op
 615     if ($new_node->is_missing())
 616       return $this;
 617
 618     if ($new_node->is_trivia() && !$target->is_trivia()) {
 619       $token = $target->is_token() ? $target : $target->rightmost_token();
 620       if ($token === null)
 621         throw new Exception('Unable to find token to insert trivia.');
 622
 623       // Inserting trivia after token is inserting to the left end of
 624       // the trailing trivia.
 625       $new_trailing = EditableList::concatenate_lists(
 626         $new_node, $token->trailing());
 627       $new_token = $token->with_trailing($new_trailing);
 628       return $this->replace($new_token, $token);
 629     }
 630
 631     return $this->replace(
 632       EditableSyntax::concatenate_lists($target, $new_node), $target);
 633   }
 634 }
 635
 636 final class EditableList extends EditableSyntax implements ArrayAccess {
 637   private array<EditableSyntax> $_children;
 638   public function __construct(array<EditableSyntax> $children) {
 639     parent::__construct('list');
 640     $this->_children = $children;
 641   }
 642
 643   public function offsetExists(mixed $offset): bool {
 644     return array_key_exists($offset, $this->_children);
 645   }
 646
 647   public function offsetGet(mixed $offset): mixed {
 648     return $this->_children[$offset];
 649   }
 650
 651   public function offsetSet(mixed $offset, mixed $value): void {
 652   }
 653
 654   public function offsetUnset(mixed $offset): void {
 655   }
 656
 657   public function is_list(): bool {
 658     return true;
 659   }
 660
 661   public function to_array(): array<EditableSyntax> {
 662     return $this->_children;
 663   }
 664
 665   public function children(): Generator<string, EditableSyntax, void> {
 666     foreach($this->_children as $key => $node)
 667       yield $key => $node;
 668   }
 669
 670   /* TODO: Getter by index? */
 671
 672   public static function to_list(
 673     array<EditableSyntax> $syntax_list): EditableSyntax {
 674     if (count($syntax_list) === 0)
 675       return Missing::missing();
 676     else
 677       return new EditableList($syntax_list);
 678   }
 679
 680   public static function concatenate_lists(
 681     EditableSyntax $left,
 682     EditableSyntax $right): EditableSyntax {
 683     if ($left->is_missing())
 684       return $right;
 685     if ($right->is_missing())
 686       return $left;
 687     return new EditableList(
 688       array_merge($left->to_array(), $right->to_array()));
 689   }
 690
 691   public static function from_json(mixed $json, int $position, string $source) {
 692     // TODO Implement array map
 693     $children = [];
 694     $current_position = $position;
 695     foreach($json->elements as $element)
 696     {
 697       $child = EditableSyntax::from_json($element, $current_position, $source);
 698       array_push($children, $child);
 699       $current_position += $child->width();
 700     }
 701     return new EditableList($children);
 702   }
 703
 704   public function rewrite(
 705     ( function
 706       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
 707     ?array<EditableSyntax> $parents = null): EditableSyntax {
 708     $dirty = false;
 709     $new_children = [];
 710     $new_parents = $parents ?? [];
 711     array_push($new_parents, $this);
 712     foreach ($this->children() as $child)
 713     {
 714       $new_child = $child->rewrite($rewriter, $new_parents);
 715       if ($new_child != $child)
 716         $dirty = true;
 717       if ($new_child != null)
 718       {
 719         if ($new_child->is_list())
 720         {
 721           foreach($new_child->children() as $n)
 722             array_push($new_children, $n);
 723         }
 724         else
 725           array_push($new_children, $new_child);
 726       }
 727     }
 728     $result = $this;
 729     if ($dirty) {
 730       if (count($new_children) === 0)
 731         $result = Missing::missing();
 732       else if (count($new_children) === 1)
 733         $result = $new_children[0];
 734       else
 735         $result = new EditableList($new_children);
 736     }
 737     return $rewriter($result, $parents ?? []);
 738   }
 739 }
 740
 741 abstract class EditableToken extends EditableSyntax {
 742   private string $_token_kind;
 743   private EditableSyntax $_leading;
 744   private EditableSyntax $_trailing;
 745
 746   public function __construct(
 747     string $token_kind,
 748     EditableSyntax $leading,
 749     EditableSyntax $trailing,
 750     string $text) {
 751     parent::__construct('token');
 752     $this->_token_kind = $token_kind;
 753     $this->_text = $text;
 754     $this->_leading = $leading;
 755     $this->_trailing = $trailing;
 756     $this->_width = strlen($text) +
 757       $leading->width() + $trailing->width();
 758   }
 759
 760   public function token_kind(): string {
 761     return $this->_token_kind;
 762   }
 763
 764   public function text(): string {
 765     return $this->_text;
 766   }
 767
 768   public function leading(): EditableSyntax {
 769     return $this->_leading;
 770   }
 771
 772   public function trailing(): EditableSyntax {
 773     return $this->_trailing;
 774   }
 775
 776   public function children(): Generator<string, EditableSyntax, void> {
 777     yield 'leading' => $this->leading();
 778     yield 'trailing' => $this->trailing();
 779   }
 780
 781   public function is_token(): bool {
 782     return true;
 783   }
 784
 785   public function full_text(): string {
 786     return $this->leading()->full_text() .
 787       $this->text() .
 788       $this->trailing()->full_text();
 789   }
 790
 791   public abstract function with_leading(
 792     EditableSyntax $leading): EditableToken;
 793
 794   public abstract function with_trailing(
 795     EditableSyntax $trailing): EditableToken;
 796
 797   private static function factory(
 798     string $token_kind,
 799     EditableSyntax $leading,
 800     EditableSyntax $trailing,
 801     string $token_text) {
 802     switch($token_kind) {
 803     case 'end_of_file':
 804        return new EndOfFileToken($leading, $trailing);
 805
 806     case 'abstract':
 807        return new AbstractToken($leading, $trailing);
 808     case 'and':
 809        return new AndToken($leading, $trailing);
 810     case 'array':
 811        return new ArrayToken($leading, $trailing);
 812     case 'arraykey':
 813        return new ArraykeyToken($leading, $trailing);
 814     case 'as':
 815        return new AsToken($leading, $trailing);
 816     case 'async':
 817        return new AsyncToken($leading, $trailing);
 818     case 'attribute':
 819        return new AttributeToken($leading, $trailing);
 820     case 'await':
 821        return new AwaitToken($leading, $trailing);
 822     case 'bool':
 823        return new BoolToken($leading, $trailing);
 824     case 'break':
 825        return new BreakToken($leading, $trailing);
 826     case 'case':
 827        return new CaseToken($leading, $trailing);
 828     case 'catch':
 829        return new CatchToken($leading, $trailing);
 830     case 'category':
 831        return new CategoryToken($leading, $trailing);
 832     case 'children':
 833        return new ChildrenToken($leading, $trailing);
 834     case 'class':
 835        return new ClassToken($leading, $trailing);
 836     case 'classname':
 837        return new ClassnameToken($leading, $trailing);
 838     case 'clone':
 839        return new CloneToken($leading, $trailing);
 840     case 'const':
 841        return new ConstToken($leading, $trailing);
 842     case '__construct':
 843        return new ConstructToken($leading, $trailing);
 844     case 'continue':
 845        return new ContinueToken($leading, $trailing);
 846     case 'coroutine':
 847        return new CoroutineToken($leading, $trailing);
 848     case 'darray':
 849        return new DarrayToken($leading, $trailing);
 850     case 'declare':
 851        return new DeclareToken($leading, $trailing);
 852     case 'default':
 853        return new DefaultToken($leading, $trailing);
 854     case 'define':
 855        return new DefineToken($leading, $trailing);
 856     case '__destruct':
 857        return new DestructToken($leading, $trailing);
 858     case 'dict':
 859        return new DictToken($leading, $trailing);
 860     case 'do':
 861        return new DoToken($leading, $trailing);
 862     case 'double':
 863        return new DoubleToken($leading, $trailing);
 864     case 'echo':
 865        return new EchoToken($leading, $trailing);
 866     case 'else':
 867        return new ElseToken($leading, $trailing);
 868     case 'elseif':
 869        return new ElseifToken($leading, $trailing);
 870     case 'empty':
 871        return new EmptyToken($leading, $trailing);
 872     case 'endif':
 873        return new EndifToken($leading, $trailing);
 874     case 'enum':
 875        return new EnumToken($leading, $trailing);
 876     case 'eval':
 877        return new EvalToken($leading, $trailing);
 878     case 'extends':
 879        return new ExtendsToken($leading, $trailing);
 880     case 'fallthrough':
 881        return new FallthroughToken($leading, $trailing);
 882     case 'float':
 883        return new FloatToken($leading, $trailing);
 884     case 'final':
 885        return new FinalToken($leading, $trailing);
 886     case 'finally':
 887        return new FinallyToken($leading, $trailing);
 888     case 'for':
 889        return new ForToken($leading, $trailing);
 890     case 'foreach':
 891        return new ForeachToken($leading, $trailing);
 892     case 'from':
 893        return new FromToken($leading, $trailing);
 894     case 'function':
 895        return new FunctionToken($leading, $trailing);
 896     case 'global':
 897        return new GlobalToken($leading, $trailing);
 898     case 'goto':
 899        return new GotoToken($leading, $trailing);
 900     case 'if':
 901        return new IfToken($leading, $trailing);
 902     case 'implements':
 903        return new ImplementsToken($leading, $trailing);
 904     case 'include':
 905        return new IncludeToken($leading, $trailing);
 906     case 'include_once':
 907        return new Include_onceToken($leading, $trailing);
 908     case 'inout':
 909        return new InoutToken($leading, $trailing);
 910     case 'instanceof':
 911        return new InstanceofToken($leading, $trailing);
 912     case 'insteadof':
 913        return new InsteadofToken($leading, $trailing);
 914     case 'int':
 915        return new IntToken($leading, $trailing);
 916     case 'interface':
 917        return new InterfaceToken($leading, $trailing);
 918     case 'is':
 919        return new IsToken($leading, $trailing);
 920     case 'isset':
 921        return new IssetToken($leading, $trailing);
 922     case 'keyset':
 923        return new KeysetToken($leading, $trailing);
 924     case 'list':
 925        return new ListToken($leading, $trailing);
 926     case 'mixed':
 927        return new MixedToken($leading, $trailing);
 928     case 'namespace':
 929        return new NamespaceToken($leading, $trailing);
 930     case 'new':
 931        return new NewToken($leading, $trailing);
 932     case 'newtype':
 933        return new NewtypeToken($leading, $trailing);
 934     case 'noreturn':
 935        return new NoreturnToken($leading, $trailing);
 936     case 'num':
 937        return new NumToken($leading, $trailing);
 938     case 'object':
 939        return new ObjectToken($leading, $trailing);
 940     case 'or':
 941        return new OrToken($leading, $trailing);
 942     case 'parent':
 943        return new ParentToken($leading, $trailing);
 944     case 'print':
 945        return new PrintToken($leading, $trailing);
 946     case 'private':
 947        return new PrivateToken($leading, $trailing);
 948     case 'protected':
 949        return new ProtectedToken($leading, $trailing);
 950     case 'public':
 951        return new PublicToken($leading, $trailing);
 952     case 'require':
 953        return new RequireToken($leading, $trailing);
 954     case 'require_once':
 955        return new Require_onceToken($leading, $trailing);
 956     case 'required':
 957        return new RequiredToken($leading, $trailing);
 958     case 'resource':
 959        return new ResourceToken($leading, $trailing);
 960     case 'return':
 961        return new ReturnToken($leading, $trailing);
 962     case 'self':
 963        return new SelfToken($leading, $trailing);
 964     case 'shape':
 965        return new ShapeToken($leading, $trailing);
 966     case 'static':
 967        return new StaticToken($leading, $trailing);
 968     case 'string':
 969        return new StringToken($leading, $trailing);
 970     case 'super':
 971        return new SuperToken($leading, $trailing);
 972     case 'suspend':
 973        return new SuspendToken($leading, $trailing);
 974     case 'switch':
 975        return new SwitchToken($leading, $trailing);
 976     case 'this':
 977        return new ThisToken($leading, $trailing);
 978     case 'throw':
 979        return new ThrowToken($leading, $trailing);
 980     case 'trait':
 981        return new TraitToken($leading, $trailing);
 982     case 'try':
 983        return new TryToken($leading, $trailing);
 984     case 'tuple':
 985        return new TupleToken($leading, $trailing);
 986     case 'type':
 987        return new TypeToken($leading, $trailing);
 988     case 'unset':
 989        return new UnsetToken($leading, $trailing);
 990     case 'use':
 991        return new UseToken($leading, $trailing);
 992     case 'using':
 993        return new UsingToken($leading, $trailing);
 994     case 'var':
 995        return new VarToken($leading, $trailing);
 996     case 'varray':
 997        return new VarrayToken($leading, $trailing);
 998     case 'vec':
 999        return new VecToken($leading, $trailing);
1000     case 'void':
1001        return new VoidToken($leading, $trailing);
1002     case 'where':
1003        return new WhereToken($leading, $trailing);
1004     case 'while':
1005        return new WhileToken($leading, $trailing);
1006     case 'xor':
1007        return new XorToken($leading, $trailing);
1008     case 'yield':
1009        return new YieldToken($leading, $trailing);
1010     case '[':
1011        return new LeftBracketToken($leading, $trailing);
1012     case ']':
1013        return new RightBracketToken($leading, $trailing);
1014     case '(':
1015        return new LeftParenToken($leading, $trailing);
1016     case ')':
1017        return new RightParenToken($leading, $trailing);
1018     case '{':
1019        return new LeftBraceToken($leading, $trailing);
1020     case '}':
1021        return new RightBraceToken($leading, $trailing);
1022     case '.':
1023        return new DotToken($leading, $trailing);
1024     case '->':
1025        return new MinusGreaterThanToken($leading, $trailing);
1026     case '++':
1027        return new PlusPlusToken($leading, $trailing);
1028     case '--':
1029        return new MinusMinusToken($leading, $trailing);
1030     case '**':
1031        return new StarStarToken($leading, $trailing);
1032     case '*':
1033        return new StarToken($leading, $trailing);
1034     case '+':
1035        return new PlusToken($leading, $trailing);
1036     case '-':
1037        return new MinusToken($leading, $trailing);
1038     case '~':
1039        return new TildeToken($leading, $trailing);
1040     case '!':
1041        return new ExclamationToken($leading, $trailing);
1042     case '$':
1043        return new DollarToken($leading, $trailing);
1044     case '/':
1045        return new SlashToken($leading, $trailing);
1046     case '%':
1047        return new PercentToken($leading, $trailing);
1048     case '<>':
1049        return new LessThanGreaterThanToken($leading, $trailing);
1050     case '<=>':
1051        return new LessThanEqualGreaterThanToken($leading, $trailing);
1052     case '<<':
1053        return new LessThanLessThanToken($leading, $trailing);
1054     case '>>':
1055        return new GreaterThanGreaterThanToken($leading, $trailing);
1056     case '<':
1057        return new LessThanToken($leading, $trailing);
1058     case '>':
1059        return new GreaterThanToken($leading, $trailing);
1060     case '<=':
1061        return new LessThanEqualToken($leading, $trailing);
1062     case '>=':
1063        return new GreaterThanEqualToken($leading, $trailing);
1064     case '==':
1065        return new EqualEqualToken($leading, $trailing);
1066     case '===':
1067        return new EqualEqualEqualToken($leading, $trailing);
1068     case '!=':
1069        return new ExclamationEqualToken($leading, $trailing);
1070     case '!==':
1071        return new ExclamationEqualEqualToken($leading, $trailing);
1072     case '^':
1073        return new CaratToken($leading, $trailing);
1074     case '|':
1075        return new BarToken($leading, $trailing);
1076     case '&':
1077        return new AmpersandToken($leading, $trailing);
1078     case '&&':
1079        return new AmpersandAmpersandToken($leading, $trailing);
1080     case '||':
1081        return new BarBarToken($leading, $trailing);
1082     case '?':
1083        return new QuestionToken($leading, $trailing);
1084     case '?:':
1085        return new QuestionColonToken($leading, $trailing);
1086     case '??':
1087        return new QuestionQuestionToken($leading, $trailing);
1088     case ':':
1089        return new ColonToken($leading, $trailing);
1090     case ';':
1091        return new SemicolonToken($leading, $trailing);
1092     case '=':
1093        return new EqualToken($leading, $trailing);
1094     case '**=':
1095        return new StarStarEqualToken($leading, $trailing);
1096     case '*=':
1097        return new StarEqualToken($leading, $trailing);
1098     case '/=':
1099        return new SlashEqualToken($leading, $trailing);
1100     case '%=':
1101        return new PercentEqualToken($leading, $trailing);
1102     case '+=':
1103        return new PlusEqualToken($leading, $trailing);
1104     case '-=':
1105        return new MinusEqualToken($leading, $trailing);
1106     case '.=':
1107        return new DotEqualToken($leading, $trailing);
1108     case '<<=':
1109        return new LessThanLessThanEqualToken($leading, $trailing);
1110     case '>>=':
1111        return new GreaterThanGreaterThanEqualToken($leading, $trailing);
1112     case '&=':
1113        return new AmpersandEqualToken($leading, $trailing);
1114     case '^=':
1115        return new CaratEqualToken($leading, $trailing);
1116     case '|=':
1117        return new BarEqualToken($leading, $trailing);
1118     case ',':
1119        return new CommaToken($leading, $trailing);
1120     case '@':
1121        return new AtToken($leading, $trailing);
1122     case '::':
1123        return new ColonColonToken($leading, $trailing);
1124     case '=>':
1125        return new EqualGreaterThanToken($leading, $trailing);
1126     case '==>':
1127        return new EqualEqualGreaterThanToken($leading, $trailing);
1128     case '?->':
1129        return new QuestionMinusGreaterThanToken($leading, $trailing);
1130     case '...':
1131        return new DotDotDotToken($leading, $trailing);
1132     case '$$':
1133        return new DollarDollarToken($leading, $trailing);
1134     case '|>':
1135        return new BarGreaterThanToken($leading, $trailing);
1136     case 'null':
1137        return new NullLiteralToken($leading, $trailing);
1138     case '/>':
1139        return new SlashGreaterThanToken($leading, $trailing);
1140     case '</':
1141        return new LessThanSlashToken($leading, $trailing);
1142     case '<?':
1143        return new LessThanQuestionToken($leading, $trailing);
1144     case '?>':
1145        return new QuestionGreaterThanToken($leading, $trailing);
1146     case '__halt_compiler':
1147        return new HaltCompilerToken($leading, $trailing);
1148
1149     case 'error_token':
1150        return new ErrorTokenToken($leading, $trailing, $token_text);
1151     case 'name':
1152        return new NameToken($leading, $trailing, $token_text);
1153     case 'qualified_name':
1154        return new QualifiedNameToken($leading, $trailing, $token_text);
1155     case 'variable':
1156        return new VariableToken($leading, $trailing, $token_text);
1157     case 'namespace_prefix':
1158        return new NamespacePrefixToken($leading, $trailing, $token_text);
1159     case 'decimal_literal':
1160        return new DecimalLiteralToken($leading, $trailing, $token_text);
1161     case 'octal_literal':
1162        return new OctalLiteralToken($leading, $trailing, $token_text);
1163     case 'hexadecimal_literal':
1164        return new HexadecimalLiteralToken($leading, $trailing, $token_text);
1165     case 'binary_literal':
1166        return new BinaryLiteralToken($leading, $trailing, $token_text);
1167     case 'floating_literal':
1168        return new FloatingLiteralToken($leading, $trailing, $token_text);
1169     case 'execution_string_literal':
1170        return new ExecutionStringLiteralToken($leading, $trailing, $token_text);
1171     case 'execution_string_literal_head':
1172        return new ExecutionStringLiteralHeadToken($leading, $trailing, $token_text);
1173     case 'execution_string_literal_tail':
1174        return new ExecutionStringLiteralTailToken($leading, $trailing, $token_text);
1175     case 'single_quoted_string_literal':
1176        return new SingleQuotedStringLiteralToken($leading, $trailing, $token_text);
1177     case 'double_quoted_string_literal':
1178        return new DoubleQuotedStringLiteralToken($leading, $trailing, $token_text);
1179     case 'double_quoted_string_literal_head':
1180        return new DoubleQuotedStringLiteralHeadToken($leading, $trailing, $token_text);
1181     case 'string_literal_body':
1182        return new StringLiteralBodyToken($leading, $trailing, $token_text);
1183     case 'double_quoted_string_literal_tail':
1184        return new DoubleQuotedStringLiteralTailToken($leading, $trailing, $token_text);
1185     case 'heredoc_string_literal':
1186        return new HeredocStringLiteralToken($leading, $trailing, $token_text);
1187     case 'heredoc_string_literal_head':
1188        return new HeredocStringLiteralHeadToken($leading, $trailing, $token_text);
1189     case 'heredoc_string_literal_tail':
1190        return new HeredocStringLiteralTailToken($leading, $trailing, $token_text);
1191     case 'nowdoc_string_literal':
1192        return new NowdocStringLiteralToken($leading, $trailing, $token_text);
1193     case 'boolean_literal':
1194        return new BooleanLiteralToken($leading, $trailing, $token_text);
1195     case 'XHP_category_name':
1196        return new XHPCategoryNameToken($leading, $trailing, $token_text);
1197     case 'XHP_element_name':
1198        return new XHPElementNameToken($leading, $trailing, $token_text);
1199     case 'XHP_class_name':
1200        return new XHPClassNameToken($leading, $trailing, $token_text);
1201     case 'XHP_string_literal':
1202        return new XHPStringLiteralToken($leading, $trailing, $token_text);
1203     case 'XHP_body':
1204        return new XHPBodyToken($leading, $trailing, $token_text);
1205     case 'XHP_comment':
1206        return new XHPCommentToken($leading, $trailing, $token_text);
1207     case 'markup':
1208        return new MarkupToken($leading, $trailing, $token_text);
1209
1210       default:
1211         throw new Exception('unexpected token kind: ' . $token_kind);
1212         // TODO: Better error
1213     }
1214   }
1215
1216   public function rewrite(
1217     ( function
1218       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
1219     ?array<EditableSyntax> $parents = null): EditableSyntax {
1220     $new_parents = $parents ?? [];
1221     array_push($new_parents, $this);
1222     $leading = $this->leading()->rewrite($rewriter, $new_parents);
1223     $trailing = $this->trailing()->rewrite($rewriter, $new_parents);
1224     if ($leading === $this->leading() && $trailing === $this->trailing())
1225       return $rewriter($this, $parents ?? []);
1226     else
1227       return $rewriter(EditableToken::factory(
1228         $this->token_kind(), $leading, $trailing,
1229         $this->text()), $parents ?? []);
1230   }
1231
1232   public function reduce<TAccumulator>(
1233     (function
1234       ( EditableSyntax,
1235         TAccumulator,
1236         array<EditableSyntax>): TAccumulator) $reducer,
1237     TAccumulator $accumulator,
1238     ?array<EditableSyntax> $parents = null): TAccumulator {
1239     $accumulator = $this->leading()->reduce($reducer, $accumulator);
1240     $accumulator = $reducer($this, $accumulator, $parents ?? []);
1241     $accumulator = $this->trailing()->reduce($reducer, $accumulator);
1242     return $accumulator;
1243   }
1244
1245   public static function from_json(
1246     mixed $json,
1247     int $position,
1248     string $source): EditableToken {
1249     $leading_list = fold_map(
1250       $json->leading,
1251       ($j, $p) ==> EditableSyntax::from_json($j, $p, $source),
1252       ($j, $p) ==> $j->width + $p,
1253       $position);
1254
1255     $leading = EditableList::to_list($leading_list);
1256     $token_position = $position + $leading->width();
1257     $token_width = $json->width;
1258     $token_text = substr($source, $token_position, $token_width);
1259     $trailing_position = $token_position + $token_width;
1260     $trailing_list = fold_map(
1261       $json->trailing,
1262       ($j, $p) ==> EditableSyntax::from_json($j, $p, $source),
1263       ($j, $p) ==> $j->width + $p,
1264       $trailing_position);
1265     $trailing = EditableList::to_list($trailing_list);
1266     return EditableToken::factory(
1267       $json->kind, $leading, $trailing, $token_text);
1268   }
1269 }
1270
1271 final class EndOfFileToken extends EditableToken {
1272   public function __construct(
1273     EditableSyntax $leading,
1274     EditableSyntax $trailing) {
1275     parent::__construct('end_of_file', $leading, $trailing, '');
1276   }
1277
1278   public function with_leading(EditableSyntax $leading): EndOfFileToken {
1279     return new EndOfFileToken($leading, $this->trailing());
1280   }
1281
1282   public function with_trailing(EditableSyntax $trailing): EndOfFileToken {
1283     return new EndOfFileToken($this->leading(), $trailing);
1284   }
1285 }
1286
1287 final class AbstractToken extends EditableToken {
1288   public function __construct(
1289     EditableSyntax $leading,
1290     EditableSyntax $trailing) {
1291     parent::__construct('abstract', $leading, $trailing, 'abstract');
1292   }
1293
1294   public function with_leading(EditableSyntax $leading): AbstractToken {
1295     return new AbstractToken($leading, $this->trailing());
1296   }
1297
1298   public function with_trailing(EditableSyntax $trailing): AbstractToken {
1299     return new AbstractToken($this->leading(), $trailing);
1300   }
1301 }
1302 final class AndToken extends EditableToken {
1303   public function __construct(
1304     EditableSyntax $leading,
1305     EditableSyntax $trailing) {
1306     parent::__construct('and', $leading, $trailing, 'and');
1307   }
1308
1309   public function with_leading(EditableSyntax $leading): AndToken {
1310     return new AndToken($leading, $this->trailing());
1311   }
1312
1313   public function with_trailing(EditableSyntax $trailing): AndToken {
1314     return new AndToken($this->leading(), $trailing);
1315   }
1316 }
1317 final class ArrayToken extends EditableToken {
1318   public function __construct(
1319     EditableSyntax $leading,
1320     EditableSyntax $trailing) {
1321     parent::__construct('array', $leading, $trailing, 'array');
1322   }
1323
1324   public function with_leading(EditableSyntax $leading): ArrayToken {
1325     return new ArrayToken($leading, $this->trailing());
1326   }
1327
1328   public function with_trailing(EditableSyntax $trailing): ArrayToken {
1329     return new ArrayToken($this->leading(), $trailing);
1330   }
1331 }
1332 final class ArraykeyToken extends EditableToken {
1333   public function __construct(
1334     EditableSyntax $leading,
1335     EditableSyntax $trailing) {
1336     parent::__construct('arraykey', $leading, $trailing, 'arraykey');
1337   }
1338
1339   public function with_leading(EditableSyntax $leading): ArraykeyToken {
1340     return new ArraykeyToken($leading, $this->trailing());
1341   }
1342
1343   public function with_trailing(EditableSyntax $trailing): ArraykeyToken {
1344     return new ArraykeyToken($this->leading(), $trailing);
1345   }
1346 }
1347 final class AsToken extends EditableToken {
1348   public function __construct(
1349     EditableSyntax $leading,
1350     EditableSyntax $trailing) {
1351     parent::__construct('as', $leading, $trailing, 'as');
1352   }
1353
1354   public function with_leading(EditableSyntax $leading): AsToken {
1355     return new AsToken($leading, $this->trailing());
1356   }
1357
1358   public function with_trailing(EditableSyntax $trailing): AsToken {
1359     return new AsToken($this->leading(), $trailing);
1360   }
1361 }
1362 final class AsyncToken extends EditableToken {
1363   public function __construct(
1364     EditableSyntax $leading,
1365     EditableSyntax $trailing) {
1366     parent::__construct('async', $leading, $trailing, 'async');
1367   }
1368
1369   public function with_leading(EditableSyntax $leading): AsyncToken {
1370     return new AsyncToken($leading, $this->trailing());
1371   }
1372
1373   public function with_trailing(EditableSyntax $trailing): AsyncToken {
1374     return new AsyncToken($this->leading(), $trailing);
1375   }
1376 }
1377 final class AttributeToken extends EditableToken {
1378   public function __construct(
1379     EditableSyntax $leading,
1380     EditableSyntax $trailing) {
1381     parent::__construct('attribute', $leading, $trailing, 'attribute');
1382   }
1383
1384   public function with_leading(EditableSyntax $leading): AttributeToken {
1385     return new AttributeToken($leading, $this->trailing());
1386   }
1387
1388   public function with_trailing(EditableSyntax $trailing): AttributeToken {
1389     return new AttributeToken($this->leading(), $trailing);
1390   }
1391 }
1392 final class AwaitToken extends EditableToken {
1393   public function __construct(
1394     EditableSyntax $leading,
1395     EditableSyntax $trailing) {
1396     parent::__construct('await', $leading, $trailing, 'await');
1397   }
1398
1399   public function with_leading(EditableSyntax $leading): AwaitToken {
1400     return new AwaitToken($leading, $this->trailing());
1401   }
1402
1403   public function with_trailing(EditableSyntax $trailing): AwaitToken {
1404     return new AwaitToken($this->leading(), $trailing);
1405   }
1406 }
1407 final class BoolToken extends EditableToken {
1408   public function __construct(
1409     EditableSyntax $leading,
1410     EditableSyntax $trailing) {
1411     parent::__construct('bool', $leading, $trailing, 'bool');
1412   }
1413
1414   public function with_leading(EditableSyntax $leading): BoolToken {
1415     return new BoolToken($leading, $this->trailing());
1416   }
1417
1418   public function with_trailing(EditableSyntax $trailing): BoolToken {
1419     return new BoolToken($this->leading(), $trailing);
1420   }
1421 }
1422 final class BreakToken extends EditableToken {
1423   public function __construct(
1424     EditableSyntax $leading,
1425     EditableSyntax $trailing) {
1426     parent::__construct('break', $leading, $trailing, 'break');
1427   }
1428
1429   public function with_leading(EditableSyntax $leading): BreakToken {
1430     return new BreakToken($leading, $this->trailing());
1431   }
1432
1433   public function with_trailing(EditableSyntax $trailing): BreakToken {
1434     return new BreakToken($this->leading(), $trailing);
1435   }
1436 }
1437 final class CaseToken extends EditableToken {
1438   public function __construct(
1439     EditableSyntax $leading,
1440     EditableSyntax $trailing) {
1441     parent::__construct('case', $leading, $trailing, 'case');
1442   }
1443
1444   public function with_leading(EditableSyntax $leading): CaseToken {
1445     return new CaseToken($leading, $this->trailing());
1446   }
1447
1448   public function with_trailing(EditableSyntax $trailing): CaseToken {
1449     return new CaseToken($this->leading(), $trailing);
1450   }
1451 }
1452 final class CatchToken extends EditableToken {
1453   public function __construct(
1454     EditableSyntax $leading,
1455     EditableSyntax $trailing) {
1456     parent::__construct('catch', $leading, $trailing, 'catch');
1457   }
1458
1459   public function with_leading(EditableSyntax $leading): CatchToken {
1460     return new CatchToken($leading, $this->trailing());
1461   }
1462
1463   public function with_trailing(EditableSyntax $trailing): CatchToken {
1464     return new CatchToken($this->leading(), $trailing);
1465   }
1466 }
1467 final class CategoryToken extends EditableToken {
1468   public function __construct(
1469     EditableSyntax $leading,
1470     EditableSyntax $trailing) {
1471     parent::__construct('category', $leading, $trailing, 'category');
1472   }
1473
1474   public function with_leading(EditableSyntax $leading): CategoryToken {
1475     return new CategoryToken($leading, $this->trailing());
1476   }
1477
1478   public function with_trailing(EditableSyntax $trailing): CategoryToken {
1479     return new CategoryToken($this->leading(), $trailing);
1480   }
1481 }
1482 final class ChildrenToken extends EditableToken {
1483   public function __construct(
1484     EditableSyntax $leading,
1485     EditableSyntax $trailing) {
1486     parent::__construct('children', $leading, $trailing, 'children');
1487   }
1488
1489   public function with_leading(EditableSyntax $leading): ChildrenToken {
1490     return new ChildrenToken($leading, $this->trailing());
1491   }
1492
1493   public function with_trailing(EditableSyntax $trailing): ChildrenToken {
1494     return new ChildrenToken($this->leading(), $trailing);
1495   }
1496 }
1497 final class ClassToken extends EditableToken {
1498   public function __construct(
1499     EditableSyntax $leading,
1500     EditableSyntax $trailing) {
1501     parent::__construct('class', $leading, $trailing, 'class');
1502   }
1503
1504   public function with_leading(EditableSyntax $leading): ClassToken {
1505     return new ClassToken($leading, $this->trailing());
1506   }
1507
1508   public function with_trailing(EditableSyntax $trailing): ClassToken {
1509     return new ClassToken($this->leading(), $trailing);
1510   }
1511 }
1512 final class ClassnameToken extends EditableToken {
1513   public function __construct(
1514     EditableSyntax $leading,
1515     EditableSyntax $trailing) {
1516     parent::__construct('classname', $leading, $trailing, 'classname');
1517   }
1518
1519   public function with_leading(EditableSyntax $leading): ClassnameToken {
1520     return new ClassnameToken($leading, $this->trailing());
1521   }
1522
1523   public function with_trailing(EditableSyntax $trailing): ClassnameToken {
1524     return new ClassnameToken($this->leading(), $trailing);
1525   }
1526 }
1527 final class CloneToken extends EditableToken {
1528   public function __construct(
1529     EditableSyntax $leading,
1530     EditableSyntax $trailing) {
1531     parent::__construct('clone', $leading, $trailing, 'clone');
1532   }
1533
1534   public function with_leading(EditableSyntax $leading): CloneToken {
1535     return new CloneToken($leading, $this->trailing());
1536   }
1537
1538   public function with_trailing(EditableSyntax $trailing): CloneToken {
1539     return new CloneToken($this->leading(), $trailing);
1540   }
1541 }
1542 final class ConstToken extends EditableToken {
1543   public function __construct(
1544     EditableSyntax $leading,
1545     EditableSyntax $trailing) {
1546     parent::__construct('const', $leading, $trailing, 'const');
1547   }
1548
1549   public function with_leading(EditableSyntax $leading): ConstToken {
1550     return new ConstToken($leading, $this->trailing());
1551   }
1552
1553   public function with_trailing(EditableSyntax $trailing): ConstToken {
1554     return new ConstToken($this->leading(), $trailing);
1555   }
1556 }
1557 final class ConstructToken extends EditableToken {
1558   public function __construct(
1559     EditableSyntax $leading,
1560     EditableSyntax $trailing) {
1561     parent::__construct('__construct', $leading, $trailing, '__construct');
1562   }
1563
1564   public function with_leading(EditableSyntax $leading): ConstructToken {
1565     return new ConstructToken($leading, $this->trailing());
1566   }
1567
1568   public function with_trailing(EditableSyntax $trailing): ConstructToken {
1569     return new ConstructToken($this->leading(), $trailing);
1570   }
1571 }
1572 final class ContinueToken extends EditableToken {
1573   public function __construct(
1574     EditableSyntax $leading,
1575     EditableSyntax $trailing) {
1576     parent::__construct('continue', $leading, $trailing, 'continue');
1577   }
1578
1579   public function with_leading(EditableSyntax $leading): ContinueToken {
1580     return new ContinueToken($leading, $this->trailing());
1581   }
1582
1583   public function with_trailing(EditableSyntax $trailing): ContinueToken {
1584     return new ContinueToken($this->leading(), $trailing);
1585   }
1586 }
1587 final class CoroutineToken extends EditableToken {
1588   public function __construct(
1589     EditableSyntax $leading,
1590     EditableSyntax $trailing) {
1591     parent::__construct('coroutine', $leading, $trailing, 'coroutine');
1592   }
1593
1594   public function with_leading(EditableSyntax $leading): CoroutineToken {
1595     return new CoroutineToken($leading, $this->trailing());
1596   }
1597
1598   public function with_trailing(EditableSyntax $trailing): CoroutineToken {
1599     return new CoroutineToken($this->leading(), $trailing);
1600   }
1601 }
1602 final class DarrayToken extends EditableToken {
1603   public function __construct(
1604     EditableSyntax $leading,
1605     EditableSyntax $trailing) {
1606     parent::__construct('darray', $leading, $trailing, 'darray');
1607   }
1608
1609   public function with_leading(EditableSyntax $leading): DarrayToken {
1610     return new DarrayToken($leading, $this->trailing());
1611   }
1612
1613   public function with_trailing(EditableSyntax $trailing): DarrayToken {
1614     return new DarrayToken($this->leading(), $trailing);
1615   }
1616 }
1617 final class DeclareToken extends EditableToken {
1618   public function __construct(
1619     EditableSyntax $leading,
1620     EditableSyntax $trailing) {
1621     parent::__construct('declare', $leading, $trailing, 'declare');
1622   }
1623
1624   public function with_leading(EditableSyntax $leading): DeclareToken {
1625     return new DeclareToken($leading, $this->trailing());
1626   }
1627
1628   public function with_trailing(EditableSyntax $trailing): DeclareToken {
1629     return new DeclareToken($this->leading(), $trailing);
1630   }
1631 }
1632 final class DefaultToken extends EditableToken {
1633   public function __construct(
1634     EditableSyntax $leading,
1635     EditableSyntax $trailing) {
1636     parent::__construct('default', $leading, $trailing, 'default');
1637   }
1638
1639   public function with_leading(EditableSyntax $leading): DefaultToken {
1640     return new DefaultToken($leading, $this->trailing());
1641   }
1642
1643   public function with_trailing(EditableSyntax $trailing): DefaultToken {
1644     return new DefaultToken($this->leading(), $trailing);
1645   }
1646 }
1647 final class DefineToken extends EditableToken {
1648   public function __construct(
1649     EditableSyntax $leading,
1650     EditableSyntax $trailing) {
1651     parent::__construct('define', $leading, $trailing, 'define');
1652   }
1653
1654   public function with_leading(EditableSyntax $leading): DefineToken {
1655     return new DefineToken($leading, $this->trailing());
1656   }
1657
1658   public function with_trailing(EditableSyntax $trailing): DefineToken {
1659     return new DefineToken($this->leading(), $trailing);
1660   }
1661 }
1662 final class DestructToken extends EditableToken {
1663   public function __construct(
1664     EditableSyntax $leading,
1665     EditableSyntax $trailing) {
1666     parent::__construct('__destruct', $leading, $trailing, '__destruct');
1667   }
1668
1669   public function with_leading(EditableSyntax $leading): DestructToken {
1670     return new DestructToken($leading, $this->trailing());
1671   }
1672
1673   public function with_trailing(EditableSyntax $trailing): DestructToken {
1674     return new DestructToken($this->leading(), $trailing);
1675   }
1676 }
1677 final class DictToken extends EditableToken {
1678   public function __construct(
1679     EditableSyntax $leading,
1680     EditableSyntax $trailing) {
1681     parent::__construct('dict', $leading, $trailing, 'dict');
1682   }
1683
1684   public function with_leading(EditableSyntax $leading): DictToken {
1685     return new DictToken($leading, $this->trailing());
1686   }
1687
1688   public function with_trailing(EditableSyntax $trailing): DictToken {
1689     return new DictToken($this->leading(), $trailing);
1690   }
1691 }
1692 final class DoToken extends EditableToken {
1693   public function __construct(
1694     EditableSyntax $leading,
1695     EditableSyntax $trailing) {
1696     parent::__construct('do', $leading, $trailing, 'do');
1697   }
1698
1699   public function with_leading(EditableSyntax $leading): DoToken {
1700     return new DoToken($leading, $this->trailing());
1701   }
1702
1703   public function with_trailing(EditableSyntax $trailing): DoToken {
1704     return new DoToken($this->leading(), $trailing);
1705   }
1706 }
1707 final class DoubleToken extends EditableToken {
1708   public function __construct(
1709     EditableSyntax $leading,
1710     EditableSyntax $trailing) {
1711     parent::__construct('double', $leading, $trailing, 'double');
1712   }
1713
1714   public function with_leading(EditableSyntax $leading): DoubleToken {
1715     return new DoubleToken($leading, $this->trailing());
1716   }
1717
1718   public function with_trailing(EditableSyntax $trailing): DoubleToken {
1719     return new DoubleToken($this->leading(), $trailing);
1720   }
1721 }
1722 final class EchoToken extends EditableToken {
1723   public function __construct(
1724     EditableSyntax $leading,
1725     EditableSyntax $trailing) {
1726     parent::__construct('echo', $leading, $trailing, 'echo');
1727   }
1728
1729   public function with_leading(EditableSyntax $leading): EchoToken {
1730     return new EchoToken($leading, $this->trailing());
1731   }
1732
1733   public function with_trailing(EditableSyntax $trailing): EchoToken {
1734     return new EchoToken($this->leading(), $trailing);
1735   }
1736 }
1737 final class ElseToken extends EditableToken {
1738   public function __construct(
1739     EditableSyntax $leading,
1740     EditableSyntax $trailing) {
1741     parent::__construct('else', $leading, $trailing, 'else');
1742   }
1743
1744   public function with_leading(EditableSyntax $leading): ElseToken {
1745     return new ElseToken($leading, $this->trailing());
1746   }
1747
1748   public function with_trailing(EditableSyntax $trailing): ElseToken {
1749     return new ElseToken($this->leading(), $trailing);
1750   }
1751 }
1752 final class ElseifToken extends EditableToken {
1753   public function __construct(
1754     EditableSyntax $leading,
1755     EditableSyntax $trailing) {
1756     parent::__construct('elseif', $leading, $trailing, 'elseif');
1757   }
1758
1759   public function with_leading(EditableSyntax $leading): ElseifToken {
1760     return new ElseifToken($leading, $this->trailing());
1761   }
1762
1763   public function with_trailing(EditableSyntax $trailing): ElseifToken {
1764     return new ElseifToken($this->leading(), $trailing);
1765   }
1766 }
1767 final class EmptyToken extends EditableToken {
1768   public function __construct(
1769     EditableSyntax $leading,
1770     EditableSyntax $trailing) {
1771     parent::__construct('empty', $leading, $trailing, 'empty');
1772   }
1773
1774   public function with_leading(EditableSyntax $leading): EmptyToken {
1775     return new EmptyToken($leading, $this->trailing());
1776   }
1777
1778   public function with_trailing(EditableSyntax $trailing): EmptyToken {
1779     return new EmptyToken($this->leading(), $trailing);
1780   }
1781 }
1782 final class EndifToken extends EditableToken {
1783   public function __construct(
1784     EditableSyntax $leading,
1785     EditableSyntax $trailing) {
1786     parent::__construct('endif', $leading, $trailing, 'endif');
1787   }
1788
1789   public function with_leading(EditableSyntax $leading): EndifToken {
1790     return new EndifToken($leading, $this->trailing());
1791   }
1792
1793   public function with_trailing(EditableSyntax $trailing): EndifToken {
1794     return new EndifToken($this->leading(), $trailing);
1795   }
1796 }
1797 final class EnumToken extends EditableToken {
1798   public function __construct(
1799     EditableSyntax $leading,
1800     EditableSyntax $trailing) {
1801     parent::__construct('enum', $leading, $trailing, 'enum');
1802   }
1803
1804   public function with_leading(EditableSyntax $leading): EnumToken {
1805     return new EnumToken($leading, $this->trailing());
1806   }
1807
1808   public function with_trailing(EditableSyntax $trailing): EnumToken {
1809     return new EnumToken($this->leading(), $trailing);
1810   }
1811 }
1812 final class EvalToken extends EditableToken {
1813   public function __construct(
1814     EditableSyntax $leading,
1815     EditableSyntax $trailing) {
1816     parent::__construct('eval', $leading, $trailing, 'eval');
1817   }
1818
1819   public function with_leading(EditableSyntax $leading): EvalToken {
1820     return new EvalToken($leading, $this->trailing());
1821   }
1822
1823   public function with_trailing(EditableSyntax $trailing): EvalToken {
1824     return new EvalToken($this->leading(), $trailing);
1825   }
1826 }
1827 final class ExtendsToken extends EditableToken {
1828   public function __construct(
1829     EditableSyntax $leading,
1830     EditableSyntax $trailing) {
1831     parent::__construct('extends', $leading, $trailing, 'extends');
1832   }
1833
1834   public function with_leading(EditableSyntax $leading): ExtendsToken {
1835     return new ExtendsToken($leading, $this->trailing());
1836   }
1837
1838   public function with_trailing(EditableSyntax $trailing): ExtendsToken {
1839     return new ExtendsToken($this->leading(), $trailing);
1840   }
1841 }
1842 final class FallthroughToken extends EditableToken {
1843   public function __construct(
1844     EditableSyntax $leading,
1845     EditableSyntax $trailing) {
1846     parent::__construct('fallthrough', $leading, $trailing, 'fallthrough');
1847   }
1848
1849   public function with_leading(EditableSyntax $leading): FallthroughToken {
1850     return new FallthroughToken($leading, $this->trailing());
1851   }
1852
1853   public function with_trailing(EditableSyntax $trailing): FallthroughToken {
1854     return new FallthroughToken($this->leading(), $trailing);
1855   }
1856 }
1857 final class FloatToken extends EditableToken {
1858   public function __construct(
1859     EditableSyntax $leading,
1860     EditableSyntax $trailing) {
1861     parent::__construct('float', $leading, $trailing, 'float');
1862   }
1863
1864   public function with_leading(EditableSyntax $leading): FloatToken {
1865     return new FloatToken($leading, $this->trailing());
1866   }
1867
1868   public function with_trailing(EditableSyntax $trailing): FloatToken {
1869     return new FloatToken($this->leading(), $trailing);
1870   }
1871 }
1872 final class FinalToken extends EditableToken {
1873   public function __construct(
1874     EditableSyntax $leading,
1875     EditableSyntax $trailing) {
1876     parent::__construct('final', $leading, $trailing, 'final');
1877   }
1878
1879   public function with_leading(EditableSyntax $leading): FinalToken {
1880     return new FinalToken($leading, $this->trailing());
1881   }
1882
1883   public function with_trailing(EditableSyntax $trailing): FinalToken {
1884     return new FinalToken($this->leading(), $trailing);
1885   }
1886 }
1887 final class FinallyToken extends EditableToken {
1888   public function __construct(
1889     EditableSyntax $leading,
1890     EditableSyntax $trailing) {
1891     parent::__construct('finally', $leading, $trailing, 'finally');
1892   }
1893
1894   public function with_leading(EditableSyntax $leading): FinallyToken {
1895     return new FinallyToken($leading, $this->trailing());
1896   }
1897
1898   public function with_trailing(EditableSyntax $trailing): FinallyToken {
1899     return new FinallyToken($this->leading(), $trailing);
1900   }
1901 }
1902 final class ForToken extends EditableToken {
1903   public function __construct(
1904     EditableSyntax $leading,
1905     EditableSyntax $trailing) {
1906     parent::__construct('for', $leading, $trailing, 'for');
1907   }
1908
1909   public function with_leading(EditableSyntax $leading): ForToken {
1910     return new ForToken($leading, $this->trailing());
1911   }
1912
1913   public function with_trailing(EditableSyntax $trailing): ForToken {
1914     return new ForToken($this->leading(), $trailing);
1915   }
1916 }
1917 final class ForeachToken extends EditableToken {
1918   public function __construct(
1919     EditableSyntax $leading,
1920     EditableSyntax $trailing) {
1921     parent::__construct('foreach', $leading, $trailing, 'foreach');
1922   }
1923
1924   public function with_leading(EditableSyntax $leading): ForeachToken {
1925     return new ForeachToken($leading, $this->trailing());
1926   }
1927
1928   public function with_trailing(EditableSyntax $trailing): ForeachToken {
1929     return new ForeachToken($this->leading(), $trailing);
1930   }
1931 }
1932 final class FromToken extends EditableToken {
1933   public function __construct(
1934     EditableSyntax $leading,
1935     EditableSyntax $trailing) {
1936     parent::__construct('from', $leading, $trailing, 'from');
1937   }
1938
1939   public function with_leading(EditableSyntax $leading): FromToken {
1940     return new FromToken($leading, $this->trailing());
1941   }
1942
1943   public function with_trailing(EditableSyntax $trailing): FromToken {
1944     return new FromToken($this->leading(), $trailing);
1945   }
1946 }
1947 final class FunctionToken extends EditableToken {
1948   public function __construct(
1949     EditableSyntax $leading,
1950     EditableSyntax $trailing) {
1951     parent::__construct('function', $leading, $trailing, 'function');
1952   }
1953
1954   public function with_leading(EditableSyntax $leading): FunctionToken {
1955     return new FunctionToken($leading, $this->trailing());
1956   }
1957
1958   public function with_trailing(EditableSyntax $trailing): FunctionToken {
1959     return new FunctionToken($this->leading(), $trailing);
1960   }
1961 }
1962 final class GlobalToken extends EditableToken {
1963   public function __construct(
1964     EditableSyntax $leading,
1965     EditableSyntax $trailing) {
1966     parent::__construct('global', $leading, $trailing, 'global');
1967   }
1968
1969   public function with_leading(EditableSyntax $leading): GlobalToken {
1970     return new GlobalToken($leading, $this->trailing());
1971   }
1972
1973   public function with_trailing(EditableSyntax $trailing): GlobalToken {
1974     return new GlobalToken($this->leading(), $trailing);
1975   }
1976 }
1977 final class GotoToken extends EditableToken {
1978   public function __construct(
1979     EditableSyntax $leading,
1980     EditableSyntax $trailing) {
1981     parent::__construct('goto', $leading, $trailing, 'goto');
1982   }
1983
1984   public function with_leading(EditableSyntax $leading): GotoToken {
1985     return new GotoToken($leading, $this->trailing());
1986   }
1987
1988   public function with_trailing(EditableSyntax $trailing): GotoToken {
1989     return new GotoToken($this->leading(), $trailing);
1990   }
1991 }
1992 final class IfToken extends EditableToken {
1993   public function __construct(
1994     EditableSyntax $leading,
1995     EditableSyntax $trailing) {
1996     parent::__construct('if', $leading, $trailing, 'if');
1997   }
1998
1999   public function with_leading(EditableSyntax $leading): IfToken {
2000     return new IfToken($leading, $this->trailing());
2001   }
2002
2003   public function with_trailing(EditableSyntax $trailing): IfToken {
2004     return new IfToken($this->leading(), $trailing);
2005   }
2006 }
2007 final class ImplementsToken extends EditableToken {
2008   public function __construct(
2009     EditableSyntax $leading,
2010     EditableSyntax $trailing) {
2011     parent::__construct('implements', $leading, $trailing, 'implements');
2012   }
2013
2014   public function with_leading(EditableSyntax $leading): ImplementsToken {
2015     return new ImplementsToken($leading, $this->trailing());
2016   }
2017
2018   public function with_trailing(EditableSyntax $trailing): ImplementsToken {
2019     return new ImplementsToken($this->leading(), $trailing);
2020   }
2021 }
2022 final class IncludeToken extends EditableToken {
2023   public function __construct(
2024     EditableSyntax $leading,
2025     EditableSyntax $trailing) {
2026     parent::__construct('include', $leading, $trailing, 'include');
2027   }
2028
2029   public function with_leading(EditableSyntax $leading): IncludeToken {
2030     return new IncludeToken($leading, $this->trailing());
2031   }
2032
2033   public function with_trailing(EditableSyntax $trailing): IncludeToken {
2034     return new IncludeToken($this->leading(), $trailing);
2035   }
2036 }
2037 final class Include_onceToken extends EditableToken {
2038   public function __construct(
2039     EditableSyntax $leading,
2040     EditableSyntax $trailing) {
2041     parent::__construct('include_once', $leading, $trailing, 'include_once');
2042   }
2043
2044   public function with_leading(EditableSyntax $leading): Include_onceToken {
2045     return new Include_onceToken($leading, $this->trailing());
2046   }
2047
2048   public function with_trailing(EditableSyntax $trailing): Include_onceToken {
2049     return new Include_onceToken($this->leading(), $trailing);
2050   }
2051 }
2052 final class InoutToken extends EditableToken {
2053   public function __construct(
2054     EditableSyntax $leading,
2055     EditableSyntax $trailing) {
2056     parent::__construct('inout', $leading, $trailing, 'inout');
2057   }
2058
2059   public function with_leading(EditableSyntax $leading): InoutToken {
2060     return new InoutToken($leading, $this->trailing());
2061   }
2062
2063   public function with_trailing(EditableSyntax $trailing): InoutToken {
2064     return new InoutToken($this->leading(), $trailing);
2065   }
2066 }
2067 final class InstanceofToken extends EditableToken {
2068   public function __construct(
2069     EditableSyntax $leading,
2070     EditableSyntax $trailing) {
2071     parent::__construct('instanceof', $leading, $trailing, 'instanceof');
2072   }
2073
2074   public function with_leading(EditableSyntax $leading): InstanceofToken {
2075     return new InstanceofToken($leading, $this->trailing());
2076   }
2077
2078   public function with_trailing(EditableSyntax $trailing): InstanceofToken {
2079     return new InstanceofToken($this->leading(), $trailing);
2080   }
2081 }
2082 final class InsteadofToken extends EditableToken {
2083   public function __construct(
2084     EditableSyntax $leading,
2085     EditableSyntax $trailing) {
2086     parent::__construct('insteadof', $leading, $trailing, 'insteadof');
2087   }
2088
2089   public function with_leading(EditableSyntax $leading): InsteadofToken {
2090     return new InsteadofToken($leading, $this->trailing());
2091   }
2092
2093   public function with_trailing(EditableSyntax $trailing): InsteadofToken {
2094     return new InsteadofToken($this->leading(), $trailing);
2095   }
2096 }
2097 final class IntToken extends EditableToken {
2098   public function __construct(
2099     EditableSyntax $leading,
2100     EditableSyntax $trailing) {
2101     parent::__construct('int', $leading, $trailing, 'int');
2102   }
2103
2104   public function with_leading(EditableSyntax $leading): IntToken {
2105     return new IntToken($leading, $this->trailing());
2106   }
2107
2108   public function with_trailing(EditableSyntax $trailing): IntToken {
2109     return new IntToken($this->leading(), $trailing);
2110   }
2111 }
2112 final class InterfaceToken extends EditableToken {
2113   public function __construct(
2114     EditableSyntax $leading,
2115     EditableSyntax $trailing) {
2116     parent::__construct('interface', $leading, $trailing, 'interface');
2117   }
2118
2119   public function with_leading(EditableSyntax $leading): InterfaceToken {
2120     return new InterfaceToken($leading, $this->trailing());
2121   }
2122
2123   public function with_trailing(EditableSyntax $trailing): InterfaceToken {
2124     return new InterfaceToken($this->leading(), $trailing);
2125   }
2126 }
2127 final class IsToken extends EditableToken {
2128   public function __construct(
2129     EditableSyntax $leading,
2130     EditableSyntax $trailing) {
2131     parent::__construct('is', $leading, $trailing, 'is');
2132   }
2133
2134   public function with_leading(EditableSyntax $leading): IsToken {
2135     return new IsToken($leading, $this->trailing());
2136   }
2137
2138   public function with_trailing(EditableSyntax $trailing): IsToken {
2139     return new IsToken($this->leading(), $trailing);
2140   }
2141 }
2142 final class IssetToken extends EditableToken {
2143   public function __construct(
2144     EditableSyntax $leading,
2145     EditableSyntax $trailing) {
2146     parent::__construct('isset', $leading, $trailing, 'isset');
2147   }
2148
2149   public function with_leading(EditableSyntax $leading): IssetToken {
2150     return new IssetToken($leading, $this->trailing());
2151   }
2152
2153   public function with_trailing(EditableSyntax $trailing): IssetToken {
2154     return new IssetToken($this->leading(), $trailing);
2155   }
2156 }
2157 final class KeysetToken extends EditableToken {
2158   public function __construct(
2159     EditableSyntax $leading,
2160     EditableSyntax $trailing) {
2161     parent::__construct('keyset', $leading, $trailing, 'keyset');
2162   }
2163
2164   public function with_leading(EditableSyntax $leading): KeysetToken {
2165     return new KeysetToken($leading, $this->trailing());
2166   }
2167
2168   public function with_trailing(EditableSyntax $trailing): KeysetToken {
2169     return new KeysetToken($this->leading(), $trailing);
2170   }
2171 }
2172 final class ListToken extends EditableToken {
2173   public function __construct(
2174     EditableSyntax $leading,
2175     EditableSyntax $trailing) {
2176     parent::__construct('list', $leading, $trailing, 'list');
2177   }
2178
2179   public function with_leading(EditableSyntax $leading): ListToken {
2180     return new ListToken($leading, $this->trailing());
2181   }
2182
2183   public function with_trailing(EditableSyntax $trailing): ListToken {
2184     return new ListToken($this->leading(), $trailing);
2185   }
2186 }
2187 final class MixedToken extends EditableToken {
2188   public function __construct(
2189     EditableSyntax $leading,
2190     EditableSyntax $trailing) {
2191     parent::__construct('mixed', $leading, $trailing, 'mixed');
2192   }
2193
2194   public function with_leading(EditableSyntax $leading): MixedToken {
2195     return new MixedToken($leading, $this->trailing());
2196   }
2197
2198   public function with_trailing(EditableSyntax $trailing): MixedToken {
2199     return new MixedToken($this->leading(), $trailing);
2200   }
2201 }
2202 final class NamespaceToken extends EditableToken {
2203   public function __construct(
2204     EditableSyntax $leading,
2205     EditableSyntax $trailing) {
2206     parent::__construct('namespace', $leading, $trailing, 'namespace');
2207   }
2208
2209   public function with_leading(EditableSyntax $leading): NamespaceToken {
2210     return new NamespaceToken($leading, $this->trailing());
2211   }
2212
2213   public function with_trailing(EditableSyntax $trailing): NamespaceToken {
2214     return new NamespaceToken($this->leading(), $trailing);
2215   }
2216 }
2217 final class NewToken extends EditableToken {
2218   public function __construct(
2219     EditableSyntax $leading,
2220     EditableSyntax $trailing) {
2221     parent::__construct('new', $leading, $trailing, 'new');
2222   }
2223
2224   public function with_leading(EditableSyntax $leading): NewToken {
2225     return new NewToken($leading, $this->trailing());
2226   }
2227
2228   public function with_trailing(EditableSyntax $trailing): NewToken {
2229     return new NewToken($this->leading(), $trailing);
2230   }
2231 }
2232 final class NewtypeToken extends EditableToken {
2233   public function __construct(
2234     EditableSyntax $leading,
2235     EditableSyntax $trailing) {
2236     parent::__construct('newtype', $leading, $trailing, 'newtype');
2237   }
2238
2239   public function with_leading(EditableSyntax $leading): NewtypeToken {
2240     return new NewtypeToken($leading, $this->trailing());
2241   }
2242
2243   public function with_trailing(EditableSyntax $trailing): NewtypeToken {
2244     return new NewtypeToken($this->leading(), $trailing);
2245   }
2246 }
2247 final class NoreturnToken extends EditableToken {
2248   public function __construct(
2249     EditableSyntax $leading,
2250     EditableSyntax $trailing) {
2251     parent::__construct('noreturn', $leading, $trailing, 'noreturn');
2252   }
2253
2254   public function with_leading(EditableSyntax $leading): NoreturnToken {
2255     return new NoreturnToken($leading, $this->trailing());
2256   }
2257
2258   public function with_trailing(EditableSyntax $trailing): NoreturnToken {
2259     return new NoreturnToken($this->leading(), $trailing);
2260   }
2261 }
2262 final class NumToken extends EditableToken {
2263   public function __construct(
2264     EditableSyntax $leading,
2265     EditableSyntax $trailing) {
2266     parent::__construct('num', $leading, $trailing, 'num');
2267   }
2268
2269   public function with_leading(EditableSyntax $leading): NumToken {
2270     return new NumToken($leading, $this->trailing());
2271   }
2272
2273   public function with_trailing(EditableSyntax $trailing): NumToken {
2274     return new NumToken($this->leading(), $trailing);
2275   }
2276 }
2277 final class ObjectToken extends EditableToken {
2278   public function __construct(
2279     EditableSyntax $leading,
2280     EditableSyntax $trailing) {
2281     parent::__construct('object', $leading, $trailing, 'object');
2282   }
2283
2284   public function with_leading(EditableSyntax $leading): ObjectToken {
2285     return new ObjectToken($leading, $this->trailing());
2286   }
2287
2288   public function with_trailing(EditableSyntax $trailing): ObjectToken {
2289     return new ObjectToken($this->leading(), $trailing);
2290   }
2291 }
2292 final class OrToken extends EditableToken {
2293   public function __construct(
2294     EditableSyntax $leading,
2295     EditableSyntax $trailing) {
2296     parent::__construct('or', $leading, $trailing, 'or');
2297   }
2298
2299   public function with_leading(EditableSyntax $leading): OrToken {
2300     return new OrToken($leading, $this->trailing());
2301   }
2302
2303   public function with_trailing(EditableSyntax $trailing): OrToken {
2304     return new OrToken($this->leading(), $trailing);
2305   }
2306 }
2307 final class ParentToken extends EditableToken {
2308   public function __construct(
2309     EditableSyntax $leading,
2310     EditableSyntax $trailing) {
2311     parent::__construct('parent', $leading, $trailing, 'parent');
2312   }
2313
2314   public function with_leading(EditableSyntax $leading): ParentToken {
2315     return new ParentToken($leading, $this->trailing());
2316   }
2317
2318   public function with_trailing(EditableSyntax $trailing): ParentToken {
2319     return new ParentToken($this->leading(), $trailing);
2320   }
2321 }
2322 final class PrintToken extends EditableToken {
2323   public function __construct(
2324     EditableSyntax $leading,
2325     EditableSyntax $trailing) {
2326     parent::__construct('print', $leading, $trailing, 'print');
2327   }
2328
2329   public function with_leading(EditableSyntax $leading): PrintToken {
2330     return new PrintToken($leading, $this->trailing());
2331   }
2332
2333   public function with_trailing(EditableSyntax $trailing): PrintToken {
2334     return new PrintToken($this->leading(), $trailing);
2335   }
2336 }
2337 final class PrivateToken extends EditableToken {
2338   public function __construct(
2339     EditableSyntax $leading,
2340     EditableSyntax $trailing) {
2341     parent::__construct('private', $leading, $trailing, 'private');
2342   }
2343
2344   public function with_leading(EditableSyntax $leading): PrivateToken {
2345     return new PrivateToken($leading, $this->trailing());
2346   }
2347
2348   public function with_trailing(EditableSyntax $trailing): PrivateToken {
2349     return new PrivateToken($this->leading(), $trailing);
2350   }
2351 }
2352 final class ProtectedToken extends EditableToken {
2353   public function __construct(
2354     EditableSyntax $leading,
2355     EditableSyntax $trailing) {
2356     parent::__construct('protected', $leading, $trailing, 'protected');
2357   }
2358
2359   public function with_leading(EditableSyntax $leading): ProtectedToken {
2360     return new ProtectedToken($leading, $this->trailing());
2361   }
2362
2363   public function with_trailing(EditableSyntax $trailing): ProtectedToken {
2364     return new ProtectedToken($this->leading(), $trailing);
2365   }
2366 }
2367 final class PublicToken extends EditableToken {
2368   public function __construct(
2369     EditableSyntax $leading,
2370     EditableSyntax $trailing) {
2371     parent::__construct('public', $leading, $trailing, 'public');
2372   }
2373
2374   public function with_leading(EditableSyntax $leading): PublicToken {
2375     return new PublicToken($leading, $this->trailing());
2376   }
2377
2378   public function with_trailing(EditableSyntax $trailing): PublicToken {
2379     return new PublicToken($this->leading(), $trailing);
2380   }
2381 }
2382 final class RequireToken extends EditableToken {
2383   public function __construct(
2384     EditableSyntax $leading,
2385     EditableSyntax $trailing) {
2386     parent::__construct('require', $leading, $trailing, 'require');
2387   }
2388
2389   public function with_leading(EditableSyntax $leading): RequireToken {
2390     return new RequireToken($leading, $this->trailing());
2391   }
2392
2393   public function with_trailing(EditableSyntax $trailing): RequireToken {
2394     return new RequireToken($this->leading(), $trailing);
2395   }
2396 }
2397 final class Require_onceToken extends EditableToken {
2398   public function __construct(
2399     EditableSyntax $leading,
2400     EditableSyntax $trailing) {
2401     parent::__construct('require_once', $leading, $trailing, 'require_once');
2402   }
2403
2404   public function with_leading(EditableSyntax $leading): Require_onceToken {
2405     return new Require_onceToken($leading, $this->trailing());
2406   }
2407
2408   public function with_trailing(EditableSyntax $trailing): Require_onceToken {
2409     return new Require_onceToken($this->leading(), $trailing);
2410   }
2411 }
2412 final class RequiredToken extends EditableToken {
2413   public function __construct(
2414     EditableSyntax $leading,
2415     EditableSyntax $trailing) {
2416     parent::__construct('required', $leading, $trailing, 'required');
2417   }
2418
2419   public function with_leading(EditableSyntax $leading): RequiredToken {
2420     return new RequiredToken($leading, $this->trailing());
2421   }
2422
2423   public function with_trailing(EditableSyntax $trailing): RequiredToken {
2424     return new RequiredToken($this->leading(), $trailing);
2425   }
2426 }
2427 final class ResourceToken extends EditableToken {
2428   public function __construct(
2429     EditableSyntax $leading,
2430     EditableSyntax $trailing) {
2431     parent::__construct('resource', $leading, $trailing, 'resource');
2432   }
2433
2434   public function with_leading(EditableSyntax $leading): ResourceToken {
2435     return new ResourceToken($leading, $this->trailing());
2436   }
2437
2438   public function with_trailing(EditableSyntax $trailing): ResourceToken {
2439     return new ResourceToken($this->leading(), $trailing);
2440   }
2441 }
2442 final class ReturnToken extends EditableToken {
2443   public function __construct(
2444     EditableSyntax $leading,
2445     EditableSyntax $trailing) {
2446     parent::__construct('return', $leading, $trailing, 'return');
2447   }
2448
2449   public function with_leading(EditableSyntax $leading): ReturnToken {
2450     return new ReturnToken($leading, $this->trailing());
2451   }
2452
2453   public function with_trailing(EditableSyntax $trailing): ReturnToken {
2454     return new ReturnToken($this->leading(), $trailing);
2455   }
2456 }
2457 final class SelfToken extends EditableToken {
2458   public function __construct(
2459     EditableSyntax $leading,
2460     EditableSyntax $trailing) {
2461     parent::__construct('self', $leading, $trailing, 'self');
2462   }
2463
2464   public function with_leading(EditableSyntax $leading): SelfToken {
2465     return new SelfToken($leading, $this->trailing());
2466   }
2467
2468   public function with_trailing(EditableSyntax $trailing): SelfToken {
2469     return new SelfToken($this->leading(), $trailing);
2470   }
2471 }
2472 final class ShapeToken extends EditableToken {
2473   public function __construct(
2474     EditableSyntax $leading,
2475     EditableSyntax $trailing) {
2476     parent::__construct('shape', $leading, $trailing, 'shape');
2477   }
2478
2479   public function with_leading(EditableSyntax $leading): ShapeToken {
2480     return new ShapeToken($leading, $this->trailing());
2481   }
2482
2483   public function with_trailing(EditableSyntax $trailing): ShapeToken {
2484     return new ShapeToken($this->leading(), $trailing);
2485   }
2486 }
2487 final class StaticToken extends EditableToken {
2488   public function __construct(
2489     EditableSyntax $leading,
2490     EditableSyntax $trailing) {
2491     parent::__construct('static', $leading, $trailing, 'static');
2492   }
2493
2494   public function with_leading(EditableSyntax $leading): StaticToken {
2495     return new StaticToken($leading, $this->trailing());
2496   }
2497
2498   public function with_trailing(EditableSyntax $trailing): StaticToken {
2499     return new StaticToken($this->leading(), $trailing);
2500   }
2501 }
2502 final class StringToken extends EditableToken {
2503   public function __construct(
2504     EditableSyntax $leading,
2505     EditableSyntax $trailing) {
2506     parent::__construct('string', $leading, $trailing, 'string');
2507   }
2508
2509   public function with_leading(EditableSyntax $leading): StringToken {
2510     return new StringToken($leading, $this->trailing());
2511   }
2512
2513   public function with_trailing(EditableSyntax $trailing): StringToken {
2514     return new StringToken($this->leading(), $trailing);
2515   }
2516 }
2517 final class SuperToken extends EditableToken {
2518   public function __construct(
2519     EditableSyntax $leading,
2520     EditableSyntax $trailing) {
2521     parent::__construct('super', $leading, $trailing, 'super');
2522   }
2523
2524   public function with_leading(EditableSyntax $leading): SuperToken {
2525     return new SuperToken($leading, $this->trailing());
2526   }
2527
2528   public function with_trailing(EditableSyntax $trailing): SuperToken {
2529     return new SuperToken($this->leading(), $trailing);
2530   }
2531 }
2532 final class SuspendToken extends EditableToken {
2533   public function __construct(
2534     EditableSyntax $leading,
2535     EditableSyntax $trailing) {
2536     parent::__construct('suspend', $leading, $trailing, 'suspend');
2537   }
2538
2539   public function with_leading(EditableSyntax $leading): SuspendToken {
2540     return new SuspendToken($leading, $this->trailing());
2541   }
2542
2543   public function with_trailing(EditableSyntax $trailing): SuspendToken {
2544     return new SuspendToken($this->leading(), $trailing);
2545   }
2546 }
2547 final class SwitchToken extends EditableToken {
2548   public function __construct(
2549     EditableSyntax $leading,
2550     EditableSyntax $trailing) {
2551     parent::__construct('switch', $leading, $trailing, 'switch');
2552   }
2553
2554   public function with_leading(EditableSyntax $leading): SwitchToken {
2555     return new SwitchToken($leading, $this->trailing());
2556   }
2557
2558   public function with_trailing(EditableSyntax $trailing): SwitchToken {
2559     return new SwitchToken($this->leading(), $trailing);
2560   }
2561 }
2562 final class ThisToken extends EditableToken {
2563   public function __construct(
2564     EditableSyntax $leading,
2565     EditableSyntax $trailing) {
2566     parent::__construct('this', $leading, $trailing, 'this');
2567   }
2568
2569   public function with_leading(EditableSyntax $leading): ThisToken {
2570     return new ThisToken($leading, $this->trailing());
2571   }
2572
2573   public function with_trailing(EditableSyntax $trailing): ThisToken {
2574     return new ThisToken($this->leading(), $trailing);
2575   }
2576 }
2577 final class ThrowToken extends EditableToken {
2578   public function __construct(
2579     EditableSyntax $leading,
2580     EditableSyntax $trailing) {
2581     parent::__construct('throw', $leading, $trailing, 'throw');
2582   }
2583
2584   public function with_leading(EditableSyntax $leading): ThrowToken {
2585     return new ThrowToken($leading, $this->trailing());
2586   }
2587
2588   public function with_trailing(EditableSyntax $trailing): ThrowToken {
2589     return new ThrowToken($this->leading(), $trailing);
2590   }
2591 }
2592 final class TraitToken extends EditableToken {
2593   public function __construct(
2594     EditableSyntax $leading,
2595     EditableSyntax $trailing) {
2596     parent::__construct('trait', $leading, $trailing, 'trait');
2597   }
2598
2599   public function with_leading(EditableSyntax $leading): TraitToken {
2600     return new TraitToken($leading, $this->trailing());
2601   }
2602
2603   public function with_trailing(EditableSyntax $trailing): TraitToken {
2604     return new TraitToken($this->leading(), $trailing);
2605   }
2606 }
2607 final class TryToken extends EditableToken {
2608   public function __construct(
2609     EditableSyntax $leading,
2610     EditableSyntax $trailing) {
2611     parent::__construct('try', $leading, $trailing, 'try');
2612   }
2613
2614   public function with_leading(EditableSyntax $leading): TryToken {
2615     return new TryToken($leading, $this->trailing());
2616   }
2617
2618   public function with_trailing(EditableSyntax $trailing): TryToken {
2619     return new TryToken($this->leading(), $trailing);
2620   }
2621 }
2622 final class TupleToken extends EditableToken {
2623   public function __construct(
2624     EditableSyntax $leading,
2625     EditableSyntax $trailing) {
2626     parent::__construct('tuple', $leading, $trailing, 'tuple');
2627   }
2628
2629   public function with_leading(EditableSyntax $leading): TupleToken {
2630     return new TupleToken($leading, $this->trailing());
2631   }
2632
2633   public function with_trailing(EditableSyntax $trailing): TupleToken {
2634     return new TupleToken($this->leading(), $trailing);
2635   }
2636 }
2637 final class TypeToken extends EditableToken {
2638   public function __construct(
2639     EditableSyntax $leading,
2640     EditableSyntax $trailing) {
2641     parent::__construct('type', $leading, $trailing, 'type');
2642   }
2643
2644   public function with_leading(EditableSyntax $leading): TypeToken {
2645     return new TypeToken($leading, $this->trailing());
2646   }
2647
2648   public function with_trailing(EditableSyntax $trailing): TypeToken {
2649     return new TypeToken($this->leading(), $trailing);
2650   }
2651 }
2652 final class UnsetToken extends EditableToken {
2653   public function __construct(
2654     EditableSyntax $leading,
2655     EditableSyntax $trailing) {
2656     parent::__construct('unset', $leading, $trailing, 'unset');
2657   }
2658
2659   public function with_leading(EditableSyntax $leading): UnsetToken {
2660     return new UnsetToken($leading, $this->trailing());
2661   }
2662
2663   public function with_trailing(EditableSyntax $trailing): UnsetToken {
2664     return new UnsetToken($this->leading(), $trailing);
2665   }
2666 }
2667 final class UseToken extends EditableToken {
2668   public function __construct(
2669     EditableSyntax $leading,
2670     EditableSyntax $trailing) {
2671     parent::__construct('use', $leading, $trailing, 'use');
2672   }
2673
2674   public function with_leading(EditableSyntax $leading): UseToken {
2675     return new UseToken($leading, $this->trailing());
2676   }
2677
2678   public function with_trailing(EditableSyntax $trailing): UseToken {
2679     return new UseToken($this->leading(), $trailing);
2680   }
2681 }
2682 final class UsingToken extends EditableToken {
2683   public function __construct(
2684     EditableSyntax $leading,
2685     EditableSyntax $trailing) {
2686     parent::__construct('using', $leading, $trailing, 'using');
2687   }
2688
2689   public function with_leading(EditableSyntax $leading): UsingToken {
2690     return new UsingToken($leading, $this->trailing());
2691   }
2692
2693   public function with_trailing(EditableSyntax $trailing): UsingToken {
2694     return new UsingToken($this->leading(), $trailing);
2695   }
2696 }
2697 final class VarToken extends EditableToken {
2698   public function __construct(
2699     EditableSyntax $leading,
2700     EditableSyntax $trailing) {
2701     parent::__construct('var', $leading, $trailing, 'var');
2702   }
2703
2704   public function with_leading(EditableSyntax $leading): VarToken {
2705     return new VarToken($leading, $this->trailing());
2706   }
2707
2708   public function with_trailing(EditableSyntax $trailing): VarToken {
2709     return new VarToken($this->leading(), $trailing);
2710   }
2711 }
2712 final class VarrayToken extends EditableToken {
2713   public function __construct(
2714     EditableSyntax $leading,
2715     EditableSyntax $trailing) {
2716     parent::__construct('varray', $leading, $trailing, 'varray');
2717   }
2718
2719   public function with_leading(EditableSyntax $leading): VarrayToken {
2720     return new VarrayToken($leading, $this->trailing());
2721   }
2722
2723   public function with_trailing(EditableSyntax $trailing): VarrayToken {
2724     return new VarrayToken($this->leading(), $trailing);
2725   }
2726 }
2727 final class VecToken extends EditableToken {
2728   public function __construct(
2729     EditableSyntax $leading,
2730     EditableSyntax $trailing) {
2731     parent::__construct('vec', $leading, $trailing, 'vec');
2732   }
2733
2734   public function with_leading(EditableSyntax $leading): VecToken {
2735     return new VecToken($leading, $this->trailing());
2736   }
2737
2738   public function with_trailing(EditableSyntax $trailing): VecToken {
2739     return new VecToken($this->leading(), $trailing);
2740   }
2741 }
2742 final class VoidToken extends EditableToken {
2743   public function __construct(
2744     EditableSyntax $leading,
2745     EditableSyntax $trailing) {
2746     parent::__construct('void', $leading, $trailing, 'void');
2747   }
2748
2749   public function with_leading(EditableSyntax $leading): VoidToken {
2750     return new VoidToken($leading, $this->trailing());
2751   }
2752
2753   public function with_trailing(EditableSyntax $trailing): VoidToken {
2754     return new VoidToken($this->leading(), $trailing);
2755   }
2756 }
2757 final class WhereToken extends EditableToken {
2758   public function __construct(
2759     EditableSyntax $leading,
2760     EditableSyntax $trailing) {
2761     parent::__construct('where', $leading, $trailing, 'where');
2762   }
2763
2764   public function with_leading(EditableSyntax $leading): WhereToken {
2765     return new WhereToken($leading, $this->trailing());
2766   }
2767
2768   public function with_trailing(EditableSyntax $trailing): WhereToken {
2769     return new WhereToken($this->leading(), $trailing);
2770   }
2771 }
2772 final class WhileToken extends EditableToken {
2773   public function __construct(
2774     EditableSyntax $leading,
2775     EditableSyntax $trailing) {
2776     parent::__construct('while', $leading, $trailing, 'while');
2777   }
2778
2779   public function with_leading(EditableSyntax $leading): WhileToken {
2780     return new WhileToken($leading, $this->trailing());
2781   }
2782
2783   public function with_trailing(EditableSyntax $trailing): WhileToken {
2784     return new WhileToken($this->leading(), $trailing);
2785   }
2786 }
2787 final class XorToken extends EditableToken {
2788   public function __construct(
2789     EditableSyntax $leading,
2790     EditableSyntax $trailing) {
2791     parent::__construct('xor', $leading, $trailing, 'xor');
2792   }
2793
2794   public function with_leading(EditableSyntax $leading): XorToken {
2795     return new XorToken($leading, $this->trailing());
2796   }
2797
2798   public function with_trailing(EditableSyntax $trailing): XorToken {
2799     return new XorToken($this->leading(), $trailing);
2800   }
2801 }
2802 final class YieldToken extends EditableToken {
2803   public function __construct(
2804     EditableSyntax $leading,
2805     EditableSyntax $trailing) {
2806     parent::__construct('yield', $leading, $trailing, 'yield');
2807   }
2808
2809   public function with_leading(EditableSyntax $leading): YieldToken {
2810     return new YieldToken($leading, $this->trailing());
2811   }
2812
2813   public function with_trailing(EditableSyntax $trailing): YieldToken {
2814     return new YieldToken($this->leading(), $trailing);
2815   }
2816 }
2817 final class LeftBracketToken extends EditableToken {
2818   public function __construct(
2819     EditableSyntax $leading,
2820     EditableSyntax $trailing) {
2821     parent::__construct('[', $leading, $trailing, '[');
2822   }
2823
2824   public function with_leading(EditableSyntax $leading): LeftBracketToken {
2825     return new LeftBracketToken($leading, $this->trailing());
2826   }
2827
2828   public function with_trailing(EditableSyntax $trailing): LeftBracketToken {
2829     return new LeftBracketToken($this->leading(), $trailing);
2830   }
2831 }
2832 final class RightBracketToken extends EditableToken {
2833   public function __construct(
2834     EditableSyntax $leading,
2835     EditableSyntax $trailing) {
2836     parent::__construct(']', $leading, $trailing, ']');
2837   }
2838
2839   public function with_leading(EditableSyntax $leading): RightBracketToken {
2840     return new RightBracketToken($leading, $this->trailing());
2841   }
2842
2843   public function with_trailing(EditableSyntax $trailing): RightBracketToken {
2844     return new RightBracketToken($this->leading(), $trailing);
2845   }
2846 }
2847 final class LeftParenToken extends EditableToken {
2848   public function __construct(
2849     EditableSyntax $leading,
2850     EditableSyntax $trailing) {
2851     parent::__construct('(', $leading, $trailing, '(');
2852   }
2853
2854   public function with_leading(EditableSyntax $leading): LeftParenToken {
2855     return new LeftParenToken($leading, $this->trailing());
2856   }
2857
2858   public function with_trailing(EditableSyntax $trailing): LeftParenToken {
2859     return new LeftParenToken($this->leading(), $trailing);
2860   }
2861 }
2862 final class RightParenToken extends EditableToken {
2863   public function __construct(
2864     EditableSyntax $leading,
2865     EditableSyntax $trailing) {
2866     parent::__construct(')', $leading, $trailing, ')');
2867   }
2868
2869   public function with_leading(EditableSyntax $leading): RightParenToken {
2870     return new RightParenToken($leading, $this->trailing());
2871   }
2872
2873   public function with_trailing(EditableSyntax $trailing): RightParenToken {
2874     return new RightParenToken($this->leading(), $trailing);
2875   }
2876 }
2877 final class LeftBraceToken extends EditableToken {
2878   public function __construct(
2879     EditableSyntax $leading,
2880     EditableSyntax $trailing) {
2881     parent::__construct('{', $leading, $trailing, '{');
2882   }
2883
2884   public function with_leading(EditableSyntax $leading): LeftBraceToken {
2885     return new LeftBraceToken($leading, $this->trailing());
2886   }
2887
2888   public function with_trailing(EditableSyntax $trailing): LeftBraceToken {
2889     return new LeftBraceToken($this->leading(), $trailing);
2890   }
2891 }
2892 final class RightBraceToken extends EditableToken {
2893   public function __construct(
2894     EditableSyntax $leading,
2895     EditableSyntax $trailing) {
2896     parent::__construct('}', $leading, $trailing, '}');
2897   }
2898
2899   public function with_leading(EditableSyntax $leading): RightBraceToken {
2900     return new RightBraceToken($leading, $this->trailing());
2901   }
2902
2903   public function with_trailing(EditableSyntax $trailing): RightBraceToken {
2904     return new RightBraceToken($this->leading(), $trailing);
2905   }
2906 }
2907 final class DotToken extends EditableToken {
2908   public function __construct(
2909     EditableSyntax $leading,
2910     EditableSyntax $trailing) {
2911     parent::__construct('.', $leading, $trailing, '.');
2912   }
2913
2914   public function with_leading(EditableSyntax $leading): DotToken {
2915     return new DotToken($leading, $this->trailing());
2916   }
2917
2918   public function with_trailing(EditableSyntax $trailing): DotToken {
2919     return new DotToken($this->leading(), $trailing);
2920   }
2921 }
2922 final class MinusGreaterThanToken extends EditableToken {
2923   public function __construct(
2924     EditableSyntax $leading,
2925     EditableSyntax $trailing) {
2926     parent::__construct('->', $leading, $trailing, '->');
2927   }
2928
2929   public function with_leading(EditableSyntax $leading): MinusGreaterThanToken {
2930     return new MinusGreaterThanToken($leading, $this->trailing());
2931   }
2932
2933   public function with_trailing(EditableSyntax $trailing): MinusGreaterThanToken {
2934     return new MinusGreaterThanToken($this->leading(), $trailing);
2935   }
2936 }
2937 final class PlusPlusToken extends EditableToken {
2938   public function __construct(
2939     EditableSyntax $leading,
2940     EditableSyntax $trailing) {
2941     parent::__construct('++', $leading, $trailing, '++');
2942   }
2943
2944   public function with_leading(EditableSyntax $leading): PlusPlusToken {
2945     return new PlusPlusToken($leading, $this->trailing());
2946   }
2947
2948   public function with_trailing(EditableSyntax $trailing): PlusPlusToken {
2949     return new PlusPlusToken($this->leading(), $trailing);
2950   }
2951 }
2952 final class MinusMinusToken extends EditableToken {
2953   public function __construct(
2954     EditableSyntax $leading,
2955     EditableSyntax $trailing) {
2956     parent::__construct('--', $leading, $trailing, '--');
2957   }
2958
2959   public function with_leading(EditableSyntax $leading): MinusMinusToken {
2960     return new MinusMinusToken($leading, $this->trailing());
2961   }
2962
2963   public function with_trailing(EditableSyntax $trailing): MinusMinusToken {
2964     return new MinusMinusToken($this->leading(), $trailing);
2965   }
2966 }
2967 final class StarStarToken extends EditableToken {
2968   public function __construct(
2969     EditableSyntax $leading,
2970     EditableSyntax $trailing) {
2971     parent::__construct('**', $leading, $trailing, '**');
2972   }
2973
2974   public function with_leading(EditableSyntax $leading): StarStarToken {
2975     return new StarStarToken($leading, $this->trailing());
2976   }
2977
2978   public function with_trailing(EditableSyntax $trailing): StarStarToken {
2979     return new StarStarToken($this->leading(), $trailing);
2980   }
2981 }
2982 final class StarToken extends EditableToken {
2983   public function __construct(
2984     EditableSyntax $leading,
2985     EditableSyntax $trailing) {
2986     parent::__construct('*', $leading, $trailing, '*');
2987   }
2988
2989   public function with_leading(EditableSyntax $leading): StarToken {
2990     return new StarToken($leading, $this->trailing());
2991   }
2992
2993   public function with_trailing(EditableSyntax $trailing): StarToken {
2994     return new StarToken($this->leading(), $trailing);
2995   }
2996 }
2997 final class PlusToken extends EditableToken {
2998   public function __construct(
2999     EditableSyntax $leading,
3000     EditableSyntax $trailing) {
3001     parent::__construct('+', $leading, $trailing, '+');
3002   }
3003
3004   public function with_leading(EditableSyntax $leading): PlusToken {
3005     return new PlusToken($leading, $this->trailing());
3006   }
3007
3008   public function with_trailing(EditableSyntax $trailing): PlusToken {
3009     return new PlusToken($this->leading(), $trailing);
3010   }
3011 }
3012 final class MinusToken extends EditableToken {
3013   public function __construct(
3014     EditableSyntax $leading,
3015     EditableSyntax $trailing) {
3016     parent::__construct('-', $leading, $trailing, '-');
3017   }
3018
3019   public function with_leading(EditableSyntax $leading): MinusToken {
3020     return new MinusToken($leading, $this->trailing());
3021   }
3022
3023   public function with_trailing(EditableSyntax $trailing): MinusToken {
3024     return new MinusToken($this->leading(), $trailing);
3025   }
3026 }
3027 final class TildeToken extends EditableToken {
3028   public function __construct(
3029     EditableSyntax $leading,
3030     EditableSyntax $trailing) {
3031     parent::__construct('~', $leading, $trailing, '~');
3032   }
3033
3034   public function with_leading(EditableSyntax $leading): TildeToken {
3035     return new TildeToken($leading, $this->trailing());
3036   }
3037
3038   public function with_trailing(EditableSyntax $trailing): TildeToken {
3039     return new TildeToken($this->leading(), $trailing);
3040   }
3041 }
3042 final class ExclamationToken extends EditableToken {
3043   public function __construct(
3044     EditableSyntax $leading,
3045     EditableSyntax $trailing) {
3046     parent::__construct('!', $leading, $trailing, '!');
3047   }
3048
3049   public function with_leading(EditableSyntax $leading): ExclamationToken {
3050     return new ExclamationToken($leading, $this->trailing());
3051   }
3052
3053   public function with_trailing(EditableSyntax $trailing): ExclamationToken {
3054     return new ExclamationToken($this->leading(), $trailing);
3055   }
3056 }
3057 final class DollarToken extends EditableToken {
3058   public function __construct(
3059     EditableSyntax $leading,
3060     EditableSyntax $trailing) {
3061     parent::__construct('$', $leading, $trailing, '$');
3062   }
3063
3064   public function with_leading(EditableSyntax $leading): DollarToken {
3065     return new DollarToken($leading, $this->trailing());
3066   }
3067
3068   public function with_trailing(EditableSyntax $trailing): DollarToken {
3069     return new DollarToken($this->leading(), $trailing);
3070   }
3071 }
3072 final class SlashToken extends EditableToken {
3073   public function __construct(
3074     EditableSyntax $leading,
3075     EditableSyntax $trailing) {
3076     parent::__construct('/', $leading, $trailing, '/');
3077   }
3078
3079   public function with_leading(EditableSyntax $leading): SlashToken {
3080     return new SlashToken($leading, $this->trailing());
3081   }
3082
3083   public function with_trailing(EditableSyntax $trailing): SlashToken {
3084     return new SlashToken($this->leading(), $trailing);
3085   }
3086 }
3087 final class PercentToken extends EditableToken {
3088   public function __construct(
3089     EditableSyntax $leading,
3090     EditableSyntax $trailing) {
3091     parent::__construct('%', $leading, $trailing, '%');
3092   }
3093
3094   public function with_leading(EditableSyntax $leading): PercentToken {
3095     return new PercentToken($leading, $this->trailing());
3096   }
3097
3098   public function with_trailing(EditableSyntax $trailing): PercentToken {
3099     return new PercentToken($this->leading(), $trailing);
3100   }
3101 }
3102 final class LessThanGreaterThanToken extends EditableToken {
3103   public function __construct(
3104     EditableSyntax $leading,
3105     EditableSyntax $trailing) {
3106     parent::__construct('<>', $leading, $trailing, '<>');
3107   }
3108
3109   public function with_leading(EditableSyntax $leading): LessThanGreaterThanToken {
3110     return new LessThanGreaterThanToken($leading, $this->trailing());
3111   }
3112
3113   public function with_trailing(EditableSyntax $trailing): LessThanGreaterThanToken {
3114     return new LessThanGreaterThanToken($this->leading(), $trailing);
3115   }
3116 }
3117 final class LessThanEqualGreaterThanToken extends EditableToken {
3118   public function __construct(
3119     EditableSyntax $leading,
3120     EditableSyntax $trailing) {
3121     parent::__construct('<=>', $leading, $trailing, '<=>');
3122   }
3123
3124   public function with_leading(EditableSyntax $leading): LessThanEqualGreaterThanToken {
3125     return new LessThanEqualGreaterThanToken($leading, $this->trailing());
3126   }
3127
3128   public function with_trailing(EditableSyntax $trailing): LessThanEqualGreaterThanToken {
3129     return new LessThanEqualGreaterThanToken($this->leading(), $trailing);
3130   }
3131 }
3132 final class LessThanLessThanToken extends EditableToken {
3133   public function __construct(
3134     EditableSyntax $leading,
3135     EditableSyntax $trailing) {
3136     parent::__construct('<<', $leading, $trailing, '<<');
3137   }
3138
3139   public function with_leading(EditableSyntax $leading): LessThanLessThanToken {
3140     return new LessThanLessThanToken($leading, $this->trailing());
3141   }
3142
3143   public function with_trailing(EditableSyntax $trailing): LessThanLessThanToken {
3144     return new LessThanLessThanToken($this->leading(), $trailing);
3145   }
3146 }
3147 final class GreaterThanGreaterThanToken extends EditableToken {
3148   public function __construct(
3149     EditableSyntax $leading,
3150     EditableSyntax $trailing) {
3151     parent::__construct('>>', $leading, $trailing, '>>');
3152   }
3153
3154   public function with_leading(EditableSyntax $leading): GreaterThanGreaterThanToken {
3155     return new GreaterThanGreaterThanToken($leading, $this->trailing());
3156   }
3157
3158   public function with_trailing(EditableSyntax $trailing): GreaterThanGreaterThanToken {
3159     return new GreaterThanGreaterThanToken($this->leading(), $trailing);
3160   }
3161 }
3162 final class LessThanToken extends EditableToken {
3163   public function __construct(
3164     EditableSyntax $leading,
3165     EditableSyntax $trailing) {
3166     parent::__construct('<', $leading, $trailing, '<');
3167   }
3168
3169   public function with_leading(EditableSyntax $leading): LessThanToken {
3170     return new LessThanToken($leading, $this->trailing());
3171   }
3172
3173   public function with_trailing(EditableSyntax $trailing): LessThanToken {
3174     return new LessThanToken($this->leading(), $trailing);
3175   }
3176 }
3177 final class GreaterThanToken extends EditableToken {
3178   public function __construct(
3179     EditableSyntax $leading,
3180     EditableSyntax $trailing) {
3181     parent::__construct('>', $leading, $trailing, '>');
3182   }
3183
3184   public function with_leading(EditableSyntax $leading): GreaterThanToken {
3185     return new GreaterThanToken($leading, $this->trailing());
3186   }
3187
3188   public function with_trailing(EditableSyntax $trailing): GreaterThanToken {
3189     return new GreaterThanToken($this->leading(), $trailing);
3190   }
3191 }
3192 final class LessThanEqualToken extends EditableToken {
3193   public function __construct(
3194     EditableSyntax $leading,
3195     EditableSyntax $trailing) {
3196     parent::__construct('<=', $leading, $trailing, '<=');
3197   }
3198
3199   public function with_leading(EditableSyntax $leading): LessThanEqualToken {
3200     return new LessThanEqualToken($leading, $this->trailing());
3201   }
3202
3203   public function with_trailing(EditableSyntax $trailing): LessThanEqualToken {
3204     return new LessThanEqualToken($this->leading(), $trailing);
3205   }
3206 }
3207 final class GreaterThanEqualToken extends EditableToken {
3208   public function __construct(
3209     EditableSyntax $leading,
3210     EditableSyntax $trailing) {
3211     parent::__construct('>=', $leading, $trailing, '>=');
3212   }
3213
3214   public function with_leading(EditableSyntax $leading): GreaterThanEqualToken {
3215     return new GreaterThanEqualToken($leading, $this->trailing());
3216   }
3217
3218   public function with_trailing(EditableSyntax $trailing): GreaterThanEqualToken {
3219     return new GreaterThanEqualToken($this->leading(), $trailing);
3220   }
3221 }
3222 final class EqualEqualToken extends EditableToken {
3223   public function __construct(
3224     EditableSyntax $leading,
3225     EditableSyntax $trailing) {
3226     parent::__construct('==', $leading, $trailing, '==');
3227   }
3228
3229   public function with_leading(EditableSyntax $leading): EqualEqualToken {
3230     return new EqualEqualToken($leading, $this->trailing());
3231   }
3232
3233   public function with_trailing(EditableSyntax $trailing): EqualEqualToken {
3234     return new EqualEqualToken($this->leading(), $trailing);
3235   }
3236 }
3237 final class EqualEqualEqualToken extends EditableToken {
3238   public function __construct(
3239     EditableSyntax $leading,
3240     EditableSyntax $trailing) {
3241     parent::__construct('===', $leading, $trailing, '===');
3242   }
3243
3244   public function with_leading(EditableSyntax $leading): EqualEqualEqualToken {
3245     return new EqualEqualEqualToken($leading, $this->trailing());
3246   }
3247
3248   public function with_trailing(EditableSyntax $trailing): EqualEqualEqualToken {
3249     return new EqualEqualEqualToken($this->leading(), $trailing);
3250   }
3251 }
3252 final class ExclamationEqualToken extends EditableToken {
3253   public function __construct(
3254     EditableSyntax $leading,
3255     EditableSyntax $trailing) {
3256     parent::__construct('!=', $leading, $trailing, '!=');
3257   }
3258
3259   public function with_leading(EditableSyntax $leading): ExclamationEqualToken {
3260     return new ExclamationEqualToken($leading, $this->trailing());
3261   }
3262
3263   public function with_trailing(EditableSyntax $trailing): ExclamationEqualToken {
3264     return new ExclamationEqualToken($this->leading(), $trailing);
3265   }
3266 }
3267 final class ExclamationEqualEqualToken extends EditableToken {
3268   public function __construct(
3269     EditableSyntax $leading,
3270     EditableSyntax $trailing) {
3271     parent::__construct('!==', $leading, $trailing, '!==');
3272   }
3273
3274   public function with_leading(EditableSyntax $leading): ExclamationEqualEqualToken {
3275     return new ExclamationEqualEqualToken($leading, $this->trailing());
3276   }
3277
3278   public function with_trailing(EditableSyntax $trailing): ExclamationEqualEqualToken {
3279     return new ExclamationEqualEqualToken($this->leading(), $trailing);
3280   }
3281 }
3282 final class CaratToken extends EditableToken {
3283   public function __construct(
3284     EditableSyntax $leading,
3285     EditableSyntax $trailing) {
3286     parent::__construct('^', $leading, $trailing, '^');
3287   }
3288
3289   public function with_leading(EditableSyntax $leading): CaratToken {
3290     return new CaratToken($leading, $this->trailing());
3291   }
3292
3293   public function with_trailing(EditableSyntax $trailing): CaratToken {
3294     return new CaratToken($this->leading(), $trailing);
3295   }
3296 }
3297 final class BarToken extends EditableToken {
3298   public function __construct(
3299     EditableSyntax $leading,
3300     EditableSyntax $trailing) {
3301     parent::__construct('|', $leading, $trailing, '|');
3302   }
3303
3304   public function with_leading(EditableSyntax $leading): BarToken {
3305     return new BarToken($leading, $this->trailing());
3306   }
3307
3308   public function with_trailing(EditableSyntax $trailing): BarToken {
3309     return new BarToken($this->leading(), $trailing);
3310   }
3311 }
3312 final class AmpersandToken extends EditableToken {
3313   public function __construct(
3314     EditableSyntax $leading,
3315     EditableSyntax $trailing) {
3316     parent::__construct('&', $leading, $trailing, '&');
3317   }
3318
3319   public function with_leading(EditableSyntax $leading): AmpersandToken {
3320     return new AmpersandToken($leading, $this->trailing());
3321   }
3322
3323   public function with_trailing(EditableSyntax $trailing): AmpersandToken {
3324     return new AmpersandToken($this->leading(), $trailing);
3325   }
3326 }
3327 final class AmpersandAmpersandToken extends EditableToken {
3328   public function __construct(
3329     EditableSyntax $leading,
3330     EditableSyntax $trailing) {
3331     parent::__construct('&&', $leading, $trailing, '&&');
3332   }
3333
3334   public function with_leading(EditableSyntax $leading): AmpersandAmpersandToken {
3335     return new AmpersandAmpersandToken($leading, $this->trailing());
3336   }
3337
3338   public function with_trailing(EditableSyntax $trailing): AmpersandAmpersandToken {
3339     return new AmpersandAmpersandToken($this->leading(), $trailing);
3340   }
3341 }
3342 final class BarBarToken extends EditableToken {
3343   public function __construct(
3344     EditableSyntax $leading,
3345     EditableSyntax $trailing) {
3346     parent::__construct('||', $leading, $trailing, '||');
3347   }
3348
3349   public function with_leading(EditableSyntax $leading): BarBarToken {
3350     return new BarBarToken($leading, $this->trailing());
3351   }
3352
3353   public function with_trailing(EditableSyntax $trailing): BarBarToken {
3354     return new BarBarToken($this->leading(), $trailing);
3355   }
3356 }
3357 final class QuestionToken extends EditableToken {
3358   public function __construct(
3359     EditableSyntax $leading,
3360     EditableSyntax $trailing) {
3361     parent::__construct('?', $leading, $trailing, '?');
3362   }
3363
3364   public function with_leading(EditableSyntax $leading): QuestionToken {
3365     return new QuestionToken($leading, $this->trailing());
3366   }
3367
3368   public function with_trailing(EditableSyntax $trailing): QuestionToken {
3369     return new QuestionToken($this->leading(), $trailing);
3370   }
3371 }
3372 final class QuestionColonToken extends EditableToken {
3373   public function __construct(
3374     EditableSyntax $leading,
3375     EditableSyntax $trailing) {
3376     parent::__construct('?:', $leading, $trailing, '?:');
3377   }
3378
3379   public function with_leading(EditableSyntax $leading): QuestionColonToken {
3380     return new QuestionColonToken($leading, $this->trailing());
3381   }
3382
3383   public function with_trailing(EditableSyntax $trailing): QuestionColonToken {
3384     return new QuestionColonToken($this->leading(), $trailing);
3385   }
3386 }
3387 final class QuestionQuestionToken extends EditableToken {
3388   public function __construct(
3389     EditableSyntax $leading,
3390     EditableSyntax $trailing) {
3391     parent::__construct('??', $leading, $trailing, '??');
3392   }
3393
3394   public function with_leading(EditableSyntax $leading): QuestionQuestionToken {
3395     return new QuestionQuestionToken($leading, $this->trailing());
3396   }
3397
3398   public function with_trailing(EditableSyntax $trailing): QuestionQuestionToken {
3399     return new QuestionQuestionToken($this->leading(), $trailing);
3400   }
3401 }
3402 final class ColonToken extends EditableToken {
3403   public function __construct(
3404     EditableSyntax $leading,
3405     EditableSyntax $trailing) {
3406     parent::__construct(':', $leading, $trailing, ':');
3407   }
3408
3409   public function with_leading(EditableSyntax $leading): ColonToken {
3410     return new ColonToken($leading, $this->trailing());
3411   }
3412
3413   public function with_trailing(EditableSyntax $trailing): ColonToken {
3414     return new ColonToken($this->leading(), $trailing);
3415   }
3416 }
3417 final class SemicolonToken extends EditableToken {
3418   public function __construct(
3419     EditableSyntax $leading,
3420     EditableSyntax $trailing) {
3421     parent::__construct(';', $leading, $trailing, ';');
3422   }
3423
3424   public function with_leading(EditableSyntax $leading): SemicolonToken {
3425     return new SemicolonToken($leading, $this->trailing());
3426   }
3427
3428   public function with_trailing(EditableSyntax $trailing): SemicolonToken {
3429     return new SemicolonToken($this->leading(), $trailing);
3430   }
3431 }
3432 final class EqualToken extends EditableToken {
3433   public function __construct(
3434     EditableSyntax $leading,
3435     EditableSyntax $trailing) {
3436     parent::__construct('=', $leading, $trailing, '=');
3437   }
3438
3439   public function with_leading(EditableSyntax $leading): EqualToken {
3440     return new EqualToken($leading, $this->trailing());
3441   }
3442
3443   public function with_trailing(EditableSyntax $trailing): EqualToken {
3444     return new EqualToken($this->leading(), $trailing);
3445   }
3446 }
3447 final class StarStarEqualToken extends EditableToken {
3448   public function __construct(
3449     EditableSyntax $leading,
3450     EditableSyntax $trailing) {
3451     parent::__construct('**=', $leading, $trailing, '**=');
3452   }
3453
3454   public function with_leading(EditableSyntax $leading): StarStarEqualToken {
3455     return new StarStarEqualToken($leading, $this->trailing());
3456   }
3457
3458   public function with_trailing(EditableSyntax $trailing): StarStarEqualToken {
3459     return new StarStarEqualToken($this->leading(), $trailing);
3460   }
3461 }
3462 final class StarEqualToken extends EditableToken {
3463   public function __construct(
3464     EditableSyntax $leading,
3465     EditableSyntax $trailing) {
3466     parent::__construct('*=', $leading, $trailing, '*=');
3467   }
3468
3469   public function with_leading(EditableSyntax $leading): StarEqualToken {
3470     return new StarEqualToken($leading, $this->trailing());
3471   }
3472
3473   public function with_trailing(EditableSyntax $trailing): StarEqualToken {
3474     return new StarEqualToken($this->leading(), $trailing);
3475   }
3476 }
3477 final class SlashEqualToken extends EditableToken {
3478   public function __construct(
3479     EditableSyntax $leading,
3480     EditableSyntax $trailing) {
3481     parent::__construct('/=', $leading, $trailing, '/=');
3482   }
3483
3484   public function with_leading(EditableSyntax $leading): SlashEqualToken {
3485     return new SlashEqualToken($leading, $this->trailing());
3486   }
3487
3488   public function with_trailing(EditableSyntax $trailing): SlashEqualToken {
3489     return new SlashEqualToken($this->leading(), $trailing);
3490   }
3491 }
3492 final class PercentEqualToken extends EditableToken {
3493   public function __construct(
3494     EditableSyntax $leading,
3495     EditableSyntax $trailing) {
3496     parent::__construct('%=', $leading, $trailing, '%=');
3497   }
3498
3499   public function with_leading(EditableSyntax $leading): PercentEqualToken {
3500     return new PercentEqualToken($leading, $this->trailing());
3501   }
3502
3503   public function with_trailing(EditableSyntax $trailing): PercentEqualToken {
3504     return new PercentEqualToken($this->leading(), $trailing);
3505   }
3506 }
3507 final class PlusEqualToken extends EditableToken {
3508   public function __construct(
3509     EditableSyntax $leading,
3510     EditableSyntax $trailing) {
3511     parent::__construct('+=', $leading, $trailing, '+=');
3512   }
3513
3514   public function with_leading(EditableSyntax $leading): PlusEqualToken {
3515     return new PlusEqualToken($leading, $this->trailing());
3516   }
3517
3518   public function with_trailing(EditableSyntax $trailing): PlusEqualToken {
3519     return new PlusEqualToken($this->leading(), $trailing);
3520   }
3521 }
3522 final class MinusEqualToken extends EditableToken {
3523   public function __construct(
3524     EditableSyntax $leading,
3525     EditableSyntax $trailing) {
3526     parent::__construct('-=', $leading, $trailing, '-=');
3527   }
3528
3529   public function with_leading(EditableSyntax $leading): MinusEqualToken {
3530     return new MinusEqualToken($leading, $this->trailing());
3531   }
3532
3533   public function with_trailing(EditableSyntax $trailing): MinusEqualToken {
3534     return new MinusEqualToken($this->leading(), $trailing);
3535   }
3536 }
3537 final class DotEqualToken extends EditableToken {
3538   public function __construct(
3539     EditableSyntax $leading,
3540     EditableSyntax $trailing) {
3541     parent::__construct('.=', $leading, $trailing, '.=');
3542   }
3543
3544   public function with_leading(EditableSyntax $leading): DotEqualToken {
3545     return new DotEqualToken($leading, $this->trailing());
3546   }
3547
3548   public function with_trailing(EditableSyntax $trailing): DotEqualToken {
3549     return new DotEqualToken($this->leading(), $trailing);
3550   }
3551 }
3552 final class LessThanLessThanEqualToken extends EditableToken {
3553   public function __construct(
3554     EditableSyntax $leading,
3555     EditableSyntax $trailing) {
3556     parent::__construct('<<=', $leading, $trailing, '<<=');
3557   }
3558
3559   public function with_leading(EditableSyntax $leading): LessThanLessThanEqualToken {
3560     return new LessThanLessThanEqualToken($leading, $this->trailing());
3561   }
3562
3563   public function with_trailing(EditableSyntax $trailing): LessThanLessThanEqualToken {
3564     return new LessThanLessThanEqualToken($this->leading(), $trailing);
3565   }
3566 }
3567 final class GreaterThanGreaterThanEqualToken extends EditableToken {
3568   public function __construct(
3569     EditableSyntax $leading,
3570     EditableSyntax $trailing) {
3571     parent::__construct('>>=', $leading, $trailing, '>>=');
3572   }
3573
3574   public function with_leading(EditableSyntax $leading): GreaterThanGreaterThanEqualToken {
3575     return new GreaterThanGreaterThanEqualToken($leading, $this->trailing());
3576   }
3577
3578   public function with_trailing(EditableSyntax $trailing): GreaterThanGreaterThanEqualToken {
3579     return new GreaterThanGreaterThanEqualToken($this->leading(), $trailing);
3580   }
3581 }
3582 final class AmpersandEqualToken extends EditableToken {
3583   public function __construct(
3584     EditableSyntax $leading,
3585     EditableSyntax $trailing) {
3586     parent::__construct('&=', $leading, $trailing, '&=');
3587   }
3588
3589   public function with_leading(EditableSyntax $leading): AmpersandEqualToken {
3590     return new AmpersandEqualToken($leading, $this->trailing());
3591   }
3592
3593   public function with_trailing(EditableSyntax $trailing): AmpersandEqualToken {
3594     return new AmpersandEqualToken($this->leading(), $trailing);
3595   }
3596 }
3597 final class CaratEqualToken extends EditableToken {
3598   public function __construct(
3599     EditableSyntax $leading,
3600     EditableSyntax $trailing) {
3601     parent::__construct('^=', $leading, $trailing, '^=');
3602   }
3603
3604   public function with_leading(EditableSyntax $leading): CaratEqualToken {
3605     return new CaratEqualToken($leading, $this->trailing());
3606   }
3607
3608   public function with_trailing(EditableSyntax $trailing): CaratEqualToken {
3609     return new CaratEqualToken($this->leading(), $trailing);
3610   }
3611 }
3612 final class BarEqualToken extends EditableToken {
3613   public function __construct(
3614     EditableSyntax $leading,
3615     EditableSyntax $trailing) {
3616     parent::__construct('|=', $leading, $trailing, '|=');
3617   }
3618
3619   public function with_leading(EditableSyntax $leading): BarEqualToken {
3620     return new BarEqualToken($leading, $this->trailing());
3621   }
3622
3623   public function with_trailing(EditableSyntax $trailing): BarEqualToken {
3624     return new BarEqualToken($this->leading(), $trailing);
3625   }
3626 }
3627 final class CommaToken extends EditableToken {
3628   public function __construct(
3629     EditableSyntax $leading,
3630     EditableSyntax $trailing) {
3631     parent::__construct(',', $leading, $trailing, ',');
3632   }
3633
3634   public function with_leading(EditableSyntax $leading): CommaToken {
3635     return new CommaToken($leading, $this->trailing());
3636   }
3637
3638   public function with_trailing(EditableSyntax $trailing): CommaToken {
3639     return new CommaToken($this->leading(), $trailing);
3640   }
3641 }
3642 final class AtToken extends EditableToken {
3643   public function __construct(
3644     EditableSyntax $leading,
3645     EditableSyntax $trailing) {
3646     parent::__construct('@', $leading, $trailing, '@');
3647   }
3648
3649   public function with_leading(EditableSyntax $leading): AtToken {
3650     return new AtToken($leading, $this->trailing());
3651   }
3652
3653   public function with_trailing(EditableSyntax $trailing): AtToken {
3654     return new AtToken($this->leading(), $trailing);
3655   }
3656 }
3657 final class ColonColonToken extends EditableToken {
3658   public function __construct(
3659     EditableSyntax $leading,
3660     EditableSyntax $trailing) {
3661     parent::__construct('::', $leading, $trailing, '::');
3662   }
3663
3664   public function with_leading(EditableSyntax $leading): ColonColonToken {
3665     return new ColonColonToken($leading, $this->trailing());
3666   }
3667
3668   public function with_trailing(EditableSyntax $trailing): ColonColonToken {
3669     return new ColonColonToken($this->leading(), $trailing);
3670   }
3671 }
3672 final class EqualGreaterThanToken extends EditableToken {
3673   public function __construct(
3674     EditableSyntax $leading,
3675     EditableSyntax $trailing) {
3676     parent::__construct('=>', $leading, $trailing, '=>');
3677   }
3678
3679   public function with_leading(EditableSyntax $leading): EqualGreaterThanToken {
3680     return new EqualGreaterThanToken($leading, $this->trailing());
3681   }
3682
3683   public function with_trailing(EditableSyntax $trailing): EqualGreaterThanToken {
3684     return new EqualGreaterThanToken($this->leading(), $trailing);
3685   }
3686 }
3687 final class EqualEqualGreaterThanToken extends EditableToken {
3688   public function __construct(
3689     EditableSyntax $leading,
3690     EditableSyntax $trailing) {
3691     parent::__construct('==>', $leading, $trailing, '==>');
3692   }
3693
3694   public function with_leading(EditableSyntax $leading): EqualEqualGreaterThanToken {
3695     return new EqualEqualGreaterThanToken($leading, $this->trailing());
3696   }
3697
3698   public function with_trailing(EditableSyntax $trailing): EqualEqualGreaterThanToken {
3699     return new EqualEqualGreaterThanToken($this->leading(), $trailing);
3700   }
3701 }
3702 final class QuestionMinusGreaterThanToken extends EditableToken {
3703   public function __construct(
3704     EditableSyntax $leading,
3705     EditableSyntax $trailing) {
3706     parent::__construct('?->', $leading, $trailing, '?->');
3707   }
3708
3709   public function with_leading(EditableSyntax $leading): QuestionMinusGreaterThanToken {
3710     return new QuestionMinusGreaterThanToken($leading, $this->trailing());
3711   }
3712
3713   public function with_trailing(EditableSyntax $trailing): QuestionMinusGreaterThanToken {
3714     return new QuestionMinusGreaterThanToken($this->leading(), $trailing);
3715   }
3716 }
3717 final class DotDotDotToken extends EditableToken {
3718   public function __construct(
3719     EditableSyntax $leading,
3720     EditableSyntax $trailing) {
3721     parent::__construct('...', $leading, $trailing, '...');
3722   }
3723
3724   public function with_leading(EditableSyntax $leading): DotDotDotToken {
3725     return new DotDotDotToken($leading, $this->trailing());
3726   }
3727
3728   public function with_trailing(EditableSyntax $trailing): DotDotDotToken {
3729     return new DotDotDotToken($this->leading(), $trailing);
3730   }
3731 }
3732 final class DollarDollarToken extends EditableToken {
3733   public function __construct(
3734     EditableSyntax $leading,
3735     EditableSyntax $trailing) {
3736     parent::__construct('$$', $leading, $trailing, '$$');
3737   }
3738
3739   public function with_leading(EditableSyntax $leading): DollarDollarToken {
3740     return new DollarDollarToken($leading, $this->trailing());
3741   }
3742
3743   public function with_trailing(EditableSyntax $trailing): DollarDollarToken {
3744     return new DollarDollarToken($this->leading(), $trailing);
3745   }
3746 }
3747 final class BarGreaterThanToken extends EditableToken {
3748   public function __construct(
3749     EditableSyntax $leading,
3750     EditableSyntax $trailing) {
3751     parent::__construct('|>', $leading, $trailing, '|>');
3752   }
3753
3754   public function with_leading(EditableSyntax $leading): BarGreaterThanToken {
3755     return new BarGreaterThanToken($leading, $this->trailing());
3756   }
3757
3758   public function with_trailing(EditableSyntax $trailing): BarGreaterThanToken {
3759     return new BarGreaterThanToken($this->leading(), $trailing);
3760   }
3761 }
3762 final class NullLiteralToken extends EditableToken {
3763   public function __construct(
3764     EditableSyntax $leading,
3765     EditableSyntax $trailing) {
3766     parent::__construct('null', $leading, $trailing, 'null');
3767   }
3768
3769   public function with_leading(EditableSyntax $leading): NullLiteralToken {
3770     return new NullLiteralToken($leading, $this->trailing());
3771   }
3772
3773   public function with_trailing(EditableSyntax $trailing): NullLiteralToken {
3774     return new NullLiteralToken($this->leading(), $trailing);
3775   }
3776 }
3777 final class SlashGreaterThanToken extends EditableToken {
3778   public function __construct(
3779     EditableSyntax $leading,
3780     EditableSyntax $trailing) {
3781     parent::__construct('/>', $leading, $trailing, '/>');
3782   }
3783
3784   public function with_leading(EditableSyntax $leading): SlashGreaterThanToken {
3785     return new SlashGreaterThanToken($leading, $this->trailing());
3786   }
3787
3788   public function with_trailing(EditableSyntax $trailing): SlashGreaterThanToken {
3789     return new SlashGreaterThanToken($this->leading(), $trailing);
3790   }
3791 }
3792 final class LessThanSlashToken extends EditableToken {
3793   public function __construct(
3794     EditableSyntax $leading,
3795     EditableSyntax $trailing) {
3796     parent::__construct('</', $leading, $trailing, '</');
3797   }
3798
3799   public function with_leading(EditableSyntax $leading): LessThanSlashToken {
3800     return new LessThanSlashToken($leading, $this->trailing());
3801   }
3802
3803   public function with_trailing(EditableSyntax $trailing): LessThanSlashToken {
3804     return new LessThanSlashToken($this->leading(), $trailing);
3805   }
3806 }
3807 final class LessThanQuestionToken extends EditableToken {
3808   public function __construct(
3809     EditableSyntax $leading,
3810     EditableSyntax $trailing) {
3811     parent::__construct('<?', $leading, $trailing, '<?');
3812   }
3813
3814   public function with_leading(EditableSyntax $leading): LessThanQuestionToken {
3815     return new LessThanQuestionToken($leading, $this->trailing());
3816   }
3817
3818   public function with_trailing(EditableSyntax $trailing): LessThanQuestionToken {
3819     return new LessThanQuestionToken($this->leading(), $trailing);
3820   }
3821 }
3822 final class QuestionGreaterThanToken extends EditableToken {
3823   public function __construct(
3824     EditableSyntax $leading,
3825     EditableSyntax $trailing) {
3826     parent::__construct('?>', $leading, $trailing, '?>');
3827   }
3828
3829   public function with_leading(EditableSyntax $leading): QuestionGreaterThanToken {
3830     return new QuestionGreaterThanToken($leading, $this->trailing());
3831   }
3832
3833   public function with_trailing(EditableSyntax $trailing): QuestionGreaterThanToken {
3834     return new QuestionGreaterThanToken($this->leading(), $trailing);
3835   }
3836 }
3837 final class HaltCompilerToken extends EditableToken {
3838   public function __construct(
3839     EditableSyntax $leading,
3840     EditableSyntax $trailing) {
3841     parent::__construct('__halt_compiler', $leading, $trailing, '__halt_compiler');
3842   }
3843
3844   public function with_leading(EditableSyntax $leading): HaltCompilerToken {
3845     return new HaltCompilerToken($leading, $this->trailing());
3846   }
3847
3848   public function with_trailing(EditableSyntax $trailing): HaltCompilerToken {
3849     return new HaltCompilerToken($this->leading(), $trailing);
3850   }
3851 }
3852
3853 final class ErrorTokenToken extends EditableToken {
3854   public function __construct(
3855     EditableSyntax $leading,
3856     EditableSyntax $trailing,
3857     string $text) {
3858     parent::__construct('error_token', $leading, $trailing, $text);
3859   }
3860
3861   public function with_text(string $text): ErrorTokenToken {
3862     return new ErrorTokenToken($this->leading(), $this->trailing(), $text);
3863   }
3864
3865   public function with_leading(EditableSyntax $leading): ErrorTokenToken {
3866     return new ErrorTokenToken($leading, $this->trailing(), $this->text());
3867   }
3868
3869   public function with_trailing(EditableSyntax $trailing): ErrorTokenToken {
3870     return new ErrorTokenToken($this->leading(), $trailing, $this->text());
3871   }
3872 }
3873 final class NameToken extends EditableToken {
3874   public function __construct(
3875     EditableSyntax $leading,
3876     EditableSyntax $trailing,
3877     string $text) {
3878     parent::__construct('name', $leading, $trailing, $text);
3879   }
3880
3881   public function with_text(string $text): NameToken {
3882     return new NameToken($this->leading(), $this->trailing(), $text);
3883   }
3884
3885   public function with_leading(EditableSyntax $leading): NameToken {
3886     return new NameToken($leading, $this->trailing(), $this->text());
3887   }
3888
3889   public function with_trailing(EditableSyntax $trailing): NameToken {
3890     return new NameToken($this->leading(), $trailing, $this->text());
3891   }
3892 }
3893 final class QualifiedNameToken extends EditableToken {
3894   public function __construct(
3895     EditableSyntax $leading,
3896     EditableSyntax $trailing,
3897     string $text) {
3898     parent::__construct('qualified_name', $leading, $trailing, $text);
3899   }
3900
3901   public function with_text(string $text): QualifiedNameToken {
3902     return new QualifiedNameToken($this->leading(), $this->trailing(), $text);
3903   }
3904
3905   public function with_leading(EditableSyntax $leading): QualifiedNameToken {
3906     return new QualifiedNameToken($leading, $this->trailing(), $this->text());
3907   }
3908
3909   public function with_trailing(EditableSyntax $trailing): QualifiedNameToken {
3910     return new QualifiedNameToken($this->leading(), $trailing, $this->text());
3911   }
3912 }
3913 final class VariableToken extends EditableToken {
3914   public function __construct(
3915     EditableSyntax $leading,
3916     EditableSyntax $trailing,
3917     string $text) {
3918     parent::__construct('variable', $leading, $trailing, $text);
3919   }
3920
3921   public function with_text(string $text): VariableToken {
3922     return new VariableToken($this->leading(), $this->trailing(), $text);
3923   }
3924
3925   public function with_leading(EditableSyntax $leading): VariableToken {
3926     return new VariableToken($leading, $this->trailing(), $this->text());
3927   }
3928
3929   public function with_trailing(EditableSyntax $trailing): VariableToken {
3930     return new VariableToken($this->leading(), $trailing, $this->text());
3931   }
3932 }
3933 final class NamespacePrefixToken extends EditableToken {
3934   public function __construct(
3935     EditableSyntax $leading,
3936     EditableSyntax $trailing,
3937     string $text) {
3938     parent::__construct('namespace_prefix', $leading, $trailing, $text);
3939   }
3940
3941   public function with_text(string $text): NamespacePrefixToken {
3942     return new NamespacePrefixToken($this->leading(), $this->trailing(), $text);
3943   }
3944
3945   public function with_leading(EditableSyntax $leading): NamespacePrefixToken {
3946     return new NamespacePrefixToken($leading, $this->trailing(), $this->text());
3947   }
3948
3949   public function with_trailing(EditableSyntax $trailing): NamespacePrefixToken {
3950     return new NamespacePrefixToken($this->leading(), $trailing, $this->text());
3951   }
3952 }
3953 final class DecimalLiteralToken extends EditableToken {
3954   public function __construct(
3955     EditableSyntax $leading,
3956     EditableSyntax $trailing,
3957     string $text) {
3958     parent::__construct('decimal_literal', $leading, $trailing, $text);
3959   }
3960
3961   public function with_text(string $text): DecimalLiteralToken {
3962     return new DecimalLiteralToken($this->leading(), $this->trailing(), $text);
3963   }
3964
3965   public function with_leading(EditableSyntax $leading): DecimalLiteralToken {
3966     return new DecimalLiteralToken($leading, $this->trailing(), $this->text());
3967   }
3968
3969   public function with_trailing(EditableSyntax $trailing): DecimalLiteralToken {
3970     return new DecimalLiteralToken($this->leading(), $trailing, $this->text());
3971   }
3972 }
3973 final class OctalLiteralToken extends EditableToken {
3974   public function __construct(
3975     EditableSyntax $leading,
3976     EditableSyntax $trailing,
3977     string $text) {
3978     parent::__construct('octal_literal', $leading, $trailing, $text);
3979   }
3980
3981   public function with_text(string $text): OctalLiteralToken {
3982     return new OctalLiteralToken($this->leading(), $this->trailing(), $text);
3983   }
3984
3985   public function with_leading(EditableSyntax $leading): OctalLiteralToken {
3986     return new OctalLiteralToken($leading, $this->trailing(), $this->text());
3987   }
3988
3989   public function with_trailing(EditableSyntax $trailing): OctalLiteralToken {
3990     return new OctalLiteralToken($this->leading(), $trailing, $this->text());
3991   }
3992 }
3993 final class HexadecimalLiteralToken extends EditableToken {
3994   public function __construct(
3995     EditableSyntax $leading,
3996     EditableSyntax $trailing,
3997     string $text) {
3998     parent::__construct('hexadecimal_literal', $leading, $trailing, $text);
3999   }
4000
4001   public function with_text(string $text): HexadecimalLiteralToken {
4002     return new HexadecimalLiteralToken($this->leading(), $this->trailing(), $text);
4003   }
4004
4005   public function with_leading(EditableSyntax $leading): HexadecimalLiteralToken {
4006     return new HexadecimalLiteralToken($leading, $this->trailing(), $this->text());
4007   }
4008
4009   public function with_trailing(EditableSyntax $trailing): HexadecimalLiteralToken {
4010     return new HexadecimalLiteralToken($this->leading(), $trailing, $this->text());
4011   }
4012 }
4013 final class BinaryLiteralToken extends EditableToken {
4014   public function __construct(
4015     EditableSyntax $leading,
4016     EditableSyntax $trailing,
4017     string $text) {
4018     parent::__construct('binary_literal', $leading, $trailing, $text);
4019   }
4020
4021   public function with_text(string $text): BinaryLiteralToken {
4022     return new BinaryLiteralToken($this->leading(), $this->trailing(), $text);
4023   }
4024
4025   public function with_leading(EditableSyntax $leading): BinaryLiteralToken {
4026     return new BinaryLiteralToken($leading, $this->trailing(), $this->text());
4027   }
4028
4029   public function with_trailing(EditableSyntax $trailing): BinaryLiteralToken {
4030     return new BinaryLiteralToken($this->leading(), $trailing, $this->text());
4031   }
4032 }
4033 final class FloatingLiteralToken extends EditableToken {
4034   public function __construct(
4035     EditableSyntax $leading,
4036     EditableSyntax $trailing,
4037     string $text) {
4038     parent::__construct('floating_literal', $leading, $trailing, $text);
4039   }
4040
4041   public function with_text(string $text): FloatingLiteralToken {
4042     return new FloatingLiteralToken($this->leading(), $this->trailing(), $text);
4043   }
4044
4045   public function with_leading(EditableSyntax $leading): FloatingLiteralToken {
4046     return new FloatingLiteralToken($leading, $this->trailing(), $this->text());
4047   }
4048
4049   public function with_trailing(EditableSyntax $trailing): FloatingLiteralToken {
4050     return new FloatingLiteralToken($this->leading(), $trailing, $this->text());
4051   }
4052 }
4053 final class ExecutionStringLiteralToken extends EditableToken {
4054   public function __construct(
4055     EditableSyntax $leading,
4056     EditableSyntax $trailing,
4057     string $text) {
4058     parent::__construct('execution_string_literal', $leading, $trailing, $text);
4059   }
4060
4061   public function with_text(string $text): ExecutionStringLiteralToken {
4062     return new ExecutionStringLiteralToken($this->leading(), $this->trailing(), $text);
4063   }
4064
4065   public function with_leading(EditableSyntax $leading): ExecutionStringLiteralToken {
4066     return new ExecutionStringLiteralToken($leading, $this->trailing(), $this->text());
4067   }
4068
4069   public function with_trailing(EditableSyntax $trailing): ExecutionStringLiteralToken {
4070     return new ExecutionStringLiteralToken($this->leading(), $trailing, $this->text());
4071   }
4072 }
4073 final class ExecutionStringLiteralHeadToken extends EditableToken {
4074   public function __construct(
4075     EditableSyntax $leading,
4076     EditableSyntax $trailing,
4077     string $text) {
4078     parent::__construct('execution_string_literal_head', $leading, $trailing, $text);
4079   }
4080
4081   public function with_text(string $text): ExecutionStringLiteralHeadToken {
4082     return new ExecutionStringLiteralHeadToken($this->leading(), $this->trailing(), $text);
4083   }
4084
4085   public function with_leading(EditableSyntax $leading): ExecutionStringLiteralHeadToken {
4086     return new ExecutionStringLiteralHeadToken($leading, $this->trailing(), $this->text());
4087   }
4088
4089   public function with_trailing(EditableSyntax $trailing): ExecutionStringLiteralHeadToken {
4090     return new ExecutionStringLiteralHeadToken($this->leading(), $trailing, $this->text());
4091   }
4092 }
4093 final class ExecutionStringLiteralTailToken extends EditableToken {
4094   public function __construct(
4095     EditableSyntax $leading,
4096     EditableSyntax $trailing,
4097     string $text) {
4098     parent::__construct('execution_string_literal_tail', $leading, $trailing, $text);
4099   }
4100
4101   public function with_text(string $text): ExecutionStringLiteralTailToken {
4102     return new ExecutionStringLiteralTailToken($this->leading(), $this->trailing(), $text);
4103   }
4104
4105   public function with_leading(EditableSyntax $leading): ExecutionStringLiteralTailToken {
4106     return new ExecutionStringLiteralTailToken($leading, $this->trailing(), $this->text());
4107   }
4108
4109   public function with_trailing(EditableSyntax $trailing): ExecutionStringLiteralTailToken {
4110     return new ExecutionStringLiteralTailToken($this->leading(), $trailing, $this->text());
4111   }
4112 }
4113 final class SingleQuotedStringLiteralToken extends EditableToken {
4114   public function __construct(
4115     EditableSyntax $leading,
4116     EditableSyntax $trailing,
4117     string $text) {
4118     parent::__construct('single_quoted_string_literal', $leading, $trailing, $text);
4119   }
4120
4121   public function with_text(string $text): SingleQuotedStringLiteralToken {
4122     return new SingleQuotedStringLiteralToken($this->leading(), $this->trailing(), $text);
4123   }
4124
4125   public function with_leading(EditableSyntax $leading): SingleQuotedStringLiteralToken {
4126     return new SingleQuotedStringLiteralToken($leading, $this->trailing(), $this->text());
4127   }
4128
4129   public function with_trailing(EditableSyntax $trailing): SingleQuotedStringLiteralToken {
4130     return new SingleQuotedStringLiteralToken($this->leading(), $trailing, $this->text());
4131   }
4132 }
4133 final class DoubleQuotedStringLiteralToken extends EditableToken {
4134   public function __construct(
4135     EditableSyntax $leading,
4136     EditableSyntax $trailing,
4137     string $text) {
4138     parent::__construct('double_quoted_string_literal', $leading, $trailing, $text);
4139   }
4140
4141   public function with_text(string $text): DoubleQuotedStringLiteralToken {
4142     return new DoubleQuotedStringLiteralToken($this->leading(), $this->trailing(), $text);
4143   }
4144
4145   public function with_leading(EditableSyntax $leading): DoubleQuotedStringLiteralToken {
4146     return new DoubleQuotedStringLiteralToken($leading, $this->trailing(), $this->text());
4147   }
4148
4149   public function with_trailing(EditableSyntax $trailing): DoubleQuotedStringLiteralToken {
4150     return new DoubleQuotedStringLiteralToken($this->leading(), $trailing, $this->text());
4151   }
4152 }
4153 final class DoubleQuotedStringLiteralHeadToken extends EditableToken {
4154   public function __construct(
4155     EditableSyntax $leading,
4156     EditableSyntax $trailing,
4157     string $text) {
4158     parent::__construct('double_quoted_string_literal_head', $leading, $trailing, $text);
4159   }
4160
4161   public function with_text(string $text): DoubleQuotedStringLiteralHeadToken {
4162     return new DoubleQuotedStringLiteralHeadToken($this->leading(), $this->trailing(), $text);
4163   }
4164
4165   public function with_leading(EditableSyntax $leading): DoubleQuotedStringLiteralHeadToken {
4166     return new DoubleQuotedStringLiteralHeadToken($leading, $this->trailing(), $this->text());
4167   }
4168
4169   public function with_trailing(EditableSyntax $trailing): DoubleQuotedStringLiteralHeadToken {
4170     return new DoubleQuotedStringLiteralHeadToken($this->leading(), $trailing, $this->text());
4171   }
4172 }
4173 final class StringLiteralBodyToken extends EditableToken {
4174   public function __construct(
4175     EditableSyntax $leading,
4176     EditableSyntax $trailing,
4177     string $text) {
4178     parent::__construct('string_literal_body', $leading, $trailing, $text);
4179   }
4180
4181   public function with_text(string $text): StringLiteralBodyToken {
4182     return new StringLiteralBodyToken($this->leading(), $this->trailing(), $text);
4183   }
4184
4185   public function with_leading(EditableSyntax $leading): StringLiteralBodyToken {
4186     return new StringLiteralBodyToken($leading, $this->trailing(), $this->text());
4187   }
4188
4189   public function with_trailing(EditableSyntax $trailing): StringLiteralBodyToken {
4190     return new StringLiteralBodyToken($this->leading(), $trailing, $this->text());
4191   }
4192 }
4193 final class DoubleQuotedStringLiteralTailToken extends EditableToken {
4194   public function __construct(
4195     EditableSyntax $leading,
4196     EditableSyntax $trailing,
4197     string $text) {
4198     parent::__construct('double_quoted_string_literal_tail', $leading, $trailing, $text);
4199   }
4200
4201   public function with_text(string $text): DoubleQuotedStringLiteralTailToken {
4202     return new DoubleQuotedStringLiteralTailToken($this->leading(), $this->trailing(), $text);
4203   }
4204
4205   public function with_leading(EditableSyntax $leading): DoubleQuotedStringLiteralTailToken {
4206     return new DoubleQuotedStringLiteralTailToken($leading, $this->trailing(), $this->text());
4207   }
4208
4209   public function with_trailing(EditableSyntax $trailing): DoubleQuotedStringLiteralTailToken {
4210     return new DoubleQuotedStringLiteralTailToken($this->leading(), $trailing, $this->text());
4211   }
4212 }
4213 final class HeredocStringLiteralToken extends EditableToken {
4214   public function __construct(
4215     EditableSyntax $leading,
4216     EditableSyntax $trailing,
4217     string $text) {
4218     parent::__construct('heredoc_string_literal', $leading, $trailing, $text);
4219   }
4220
4221   public function with_text(string $text): HeredocStringLiteralToken {
4222     return new HeredocStringLiteralToken($this->leading(), $this->trailing(), $text);
4223   }
4224
4225   public function with_leading(EditableSyntax $leading): HeredocStringLiteralToken {
4226     return new HeredocStringLiteralToken($leading, $this->trailing(), $this->text());
4227   }
4228
4229   public function with_trailing(EditableSyntax $trailing): HeredocStringLiteralToken {
4230     return new HeredocStringLiteralToken($this->leading(), $trailing, $this->text());
4231   }
4232 }
4233 final class HeredocStringLiteralHeadToken extends EditableToken {
4234   public function __construct(
4235     EditableSyntax $leading,
4236     EditableSyntax $trailing,
4237     string $text) {
4238     parent::__construct('heredoc_string_literal_head', $leading, $trailing, $text);
4239   }
4240
4241   public function with_text(string $text): HeredocStringLiteralHeadToken {
4242     return new HeredocStringLiteralHeadToken($this->leading(), $this->trailing(), $text);
4243   }
4244
4245   public function with_leading(EditableSyntax $leading): HeredocStringLiteralHeadToken {
4246     return new HeredocStringLiteralHeadToken($leading, $this->trailing(), $this->text());
4247   }
4248
4249   public function with_trailing(EditableSyntax $trailing): HeredocStringLiteralHeadToken {
4250     return new HeredocStringLiteralHeadToken($this->leading(), $trailing, $this->text());
4251   }
4252 }
4253 final class HeredocStringLiteralTailToken extends EditableToken {
4254   public function __construct(
4255     EditableSyntax $leading,
4256     EditableSyntax $trailing,
4257     string $text) {
4258     parent::__construct('heredoc_string_literal_tail', $leading, $trailing, $text);
4259   }
4260
4261   public function with_text(string $text): HeredocStringLiteralTailToken {
4262     return new HeredocStringLiteralTailToken($this->leading(), $this->trailing(), $text);
4263   }
4264
4265   public function with_leading(EditableSyntax $leading): HeredocStringLiteralTailToken {
4266     return new HeredocStringLiteralTailToken($leading, $this->trailing(), $this->text());
4267   }
4268
4269   public function with_trailing(EditableSyntax $trailing): HeredocStringLiteralTailToken {
4270     return new HeredocStringLiteralTailToken($this->leading(), $trailing, $this->text());
4271   }
4272 }
4273 final class NowdocStringLiteralToken extends EditableToken {
4274   public function __construct(
4275     EditableSyntax $leading,
4276     EditableSyntax $trailing,
4277     string $text) {
4278     parent::__construct('nowdoc_string_literal', $leading, $trailing, $text);
4279   }
4280
4281   public function with_text(string $text): NowdocStringLiteralToken {
4282     return new NowdocStringLiteralToken($this->leading(), $this->trailing(), $text);
4283   }
4284
4285   public function with_leading(EditableSyntax $leading): NowdocStringLiteralToken {
4286     return new NowdocStringLiteralToken($leading, $this->trailing(), $this->text());
4287   }
4288
4289   public function with_trailing(EditableSyntax $trailing): NowdocStringLiteralToken {
4290     return new NowdocStringLiteralToken($this->leading(), $trailing, $this->text());
4291   }
4292 }
4293 final class BooleanLiteralToken extends EditableToken {
4294   public function __construct(
4295     EditableSyntax $leading,
4296     EditableSyntax $trailing,
4297     string $text) {
4298     parent::__construct('boolean_literal', $leading, $trailing, $text);
4299   }
4300
4301   public function with_text(string $text): BooleanLiteralToken {
4302     return new BooleanLiteralToken($this->leading(), $this->trailing(), $text);
4303   }
4304
4305   public function with_leading(EditableSyntax $leading): BooleanLiteralToken {
4306     return new BooleanLiteralToken($leading, $this->trailing(), $this->text());
4307   }
4308
4309   public function with_trailing(EditableSyntax $trailing): BooleanLiteralToken {
4310     return new BooleanLiteralToken($this->leading(), $trailing, $this->text());
4311   }
4312 }
4313 final class XHPCategoryNameToken extends EditableToken {
4314   public function __construct(
4315     EditableSyntax $leading,
4316     EditableSyntax $trailing,
4317     string $text) {
4318     parent::__construct('XHP_category_name', $leading, $trailing, $text);
4319   }
4320
4321   public function with_text(string $text): XHPCategoryNameToken {
4322     return new XHPCategoryNameToken($this->leading(), $this->trailing(), $text);
4323   }
4324
4325   public function with_leading(EditableSyntax $leading): XHPCategoryNameToken {
4326     return new XHPCategoryNameToken($leading, $this->trailing(), $this->text());
4327   }
4328
4329   public function with_trailing(EditableSyntax $trailing): XHPCategoryNameToken {
4330     return new XHPCategoryNameToken($this->leading(), $trailing, $this->text());
4331   }
4332 }
4333 final class XHPElementNameToken extends EditableToken {
4334   public function __construct(
4335     EditableSyntax $leading,
4336     EditableSyntax $trailing,
4337     string $text) {
4338     parent::__construct('XHP_element_name', $leading, $trailing, $text);
4339   }
4340
4341   public function with_text(string $text): XHPElementNameToken {
4342     return new XHPElementNameToken($this->leading(), $this->trailing(), $text);
4343   }
4344
4345   public function with_leading(EditableSyntax $leading): XHPElementNameToken {
4346     return new XHPElementNameToken($leading, $this->trailing(), $this->text());
4347   }
4348
4349   public function with_trailing(EditableSyntax $trailing): XHPElementNameToken {
4350     return new XHPElementNameToken($this->leading(), $trailing, $this->text());
4351   }
4352 }
4353 final class XHPClassNameToken extends EditableToken {
4354   public function __construct(
4355     EditableSyntax $leading,
4356     EditableSyntax $trailing,
4357     string $text) {
4358     parent::__construct('XHP_class_name', $leading, $trailing, $text);
4359   }
4360
4361   public function with_text(string $text): XHPClassNameToken {
4362     return new XHPClassNameToken($this->leading(), $this->trailing(), $text);
4363   }
4364
4365   public function with_leading(EditableSyntax $leading): XHPClassNameToken {
4366     return new XHPClassNameToken($leading, $this->trailing(), $this->text());
4367   }
4368
4369   public function with_trailing(EditableSyntax $trailing): XHPClassNameToken {
4370     return new XHPClassNameToken($this->leading(), $trailing, $this->text());
4371   }
4372 }
4373 final class XHPStringLiteralToken extends EditableToken {
4374   public function __construct(
4375     EditableSyntax $leading,
4376     EditableSyntax $trailing,
4377     string $text) {
4378     parent::__construct('XHP_string_literal', $leading, $trailing, $text);
4379   }
4380
4381   public function with_text(string $text): XHPStringLiteralToken {
4382     return new XHPStringLiteralToken($this->leading(), $this->trailing(), $text);
4383   }
4384
4385   public function with_leading(EditableSyntax $leading): XHPStringLiteralToken {
4386     return new XHPStringLiteralToken($leading, $this->trailing(), $this->text());
4387   }
4388
4389   public function with_trailing(EditableSyntax $trailing): XHPStringLiteralToken {
4390     return new XHPStringLiteralToken($this->leading(), $trailing, $this->text());
4391   }
4392 }
4393 final class XHPBodyToken extends EditableToken {
4394   public function __construct(
4395     EditableSyntax $leading,
4396     EditableSyntax $trailing,
4397     string $text) {
4398     parent::__construct('XHP_body', $leading, $trailing, $text);
4399   }
4400
4401   public function with_text(string $text): XHPBodyToken {
4402     return new XHPBodyToken($this->leading(), $this->trailing(), $text);
4403   }
4404
4405   public function with_leading(EditableSyntax $leading): XHPBodyToken {
4406     return new XHPBodyToken($leading, $this->trailing(), $this->text());
4407   }
4408
4409   public function with_trailing(EditableSyntax $trailing): XHPBodyToken {
4410     return new XHPBodyToken($this->leading(), $trailing, $this->text());
4411   }
4412 }
4413 final class XHPCommentToken extends EditableToken {
4414   public function __construct(
4415     EditableSyntax $leading,
4416     EditableSyntax $trailing,
4417     string $text) {
4418     parent::__construct('XHP_comment', $leading, $trailing, $text);
4419   }
4420
4421   public function with_text(string $text): XHPCommentToken {
4422     return new XHPCommentToken($this->leading(), $this->trailing(), $text);
4423   }
4424
4425   public function with_leading(EditableSyntax $leading): XHPCommentToken {
4426     return new XHPCommentToken($leading, $this->trailing(), $this->text());
4427   }
4428
4429   public function with_trailing(EditableSyntax $trailing): XHPCommentToken {
4430     return new XHPCommentToken($this->leading(), $trailing, $this->text());
4431   }
4432 }
4433 final class MarkupToken extends EditableToken {
4434   public function __construct(
4435     EditableSyntax $leading,
4436     EditableSyntax $trailing,
4437     string $text) {
4438     parent::__construct('markup', $leading, $trailing, $text);
4439   }
4440
4441   public function with_text(string $text): MarkupToken {
4442     return new MarkupToken($this->leading(), $this->trailing(), $text);
4443   }
4444
4445   public function with_leading(EditableSyntax $leading): MarkupToken {
4446     return new MarkupToken($leading, $this->trailing(), $this->text());
4447   }
4448
4449   public function with_trailing(EditableSyntax $trailing): MarkupToken {
4450     return new MarkupToken($this->leading(), $trailing, $this->text());
4451   }
4452 }
4453
4454
4455 abstract class EditableTrivia extends EditableSyntax {
4456   private string $_text;
4457   public function __construct(string $trivia_kind , string $text) {
4458     parent::__construct($trivia_kind);
4459     $this->_text = $text;
4460   }
4461
4462   public function text(): string {
4463     return $this->_text;
4464   }
4465
4466   public function full_text() {
4467     return $this->_text;
4468   }
4469
4470   public function width() {
4471     return strlen($this->_text);
4472   }
4473
4474   public function is_trivia() {
4475     return true;
4476   }
4477
4478   public function children(): Generator<string, EditableSyntax, void> {
4479     yield break;
4480   }
4481
4482   public static function from_json(
4483     mixed $json,
4484     int $position,
4485     string $source) {
4486     $trivia_text = substr($source, $position, $json->width);
4487     switch($json->kind) {
4488       case 'whitespace':
4489         return new WhiteSpace($trivia_text);
4490       case 'end_of_line':
4491         return new EndOfLine($trivia_text);
4492       case 'delimited_comment':
4493         return new DelimitedComment($trivia_text);
4494       case 'single_line_comment':
4495         return new SingleLineComment($trivia_text);
4496       case 'unsafe':
4497         return new Unsafe($trivia_text);
4498       case 'unsafe_expression':
4499         return new UnsafeExpression($trivia_text);
4500       case 'fix_me':
4501         return new FixMe($trivia_text);
4502       case 'ignore_error':
4503         return new IgnoreError($trivia_text);
4504       case 'fall_through':
4505         return new FallThrough($trivia_text);
4506       case 'extra_token_error':
4507         return new ExtraTokenError($trivia_text);
4508       case 'after_halt_compiler':
4509         return new AfterHaltCompiler($trivia_text);
4510
4511       default:
4512         throw new Exception('unexpected json kind: ' . $json->kind);
4513         // TODO: Better error
4514     }
4515   }
4516
4517 public function rewrite(
4518   ( function
4519     (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
4520   ?array<EditableSyntax> $parents = null): EditableSyntax {
4521     return $rewriter($this, $parents ?? []);
4522   }
4523 }
4524
4525 class WhiteSpace extends EditableTrivia {
4526   public function __construct(string $text) {
4527     parent::__construct('whitespace', $text);
4528   }
4529   public function with_text(string $text): WhiteSpace {
4530     return new WhiteSpace($text);
4531   }
4532 }
4533
4534 class EndOfLine extends EditableTrivia {
4535   public function __construct(string $text) {
4536     parent::__construct('end_of_line', $text);
4537   }
4538   public function with_text(string $text): EndOfLine {
4539     return new EndOfLine($text);
4540   }
4541 }
4542
4543 class DelimitedComment extends EditableTrivia {
4544   public function __construct(string $text) {
4545     parent::__construct('delimited_comment', $text);
4546   }
4547   public function with_text(string $text): DelimitedComment {
4548     return new DelimitedComment($text);
4549   }
4550 }
4551
4552 class SingleLineComment extends EditableTrivia {
4553   public function __construct(string $text) {
4554     parent::__construct('single_line_comment', $text);
4555   }
4556   public function with_text(string $text): SingleLineComment {
4557     return new SingleLineComment($text);
4558   }
4559 }
4560
4561 class Unsafe extends EditableTrivia {
4562   public function __construct(string $text) {
4563     parent::__construct('unsafe', $text);
4564   }
4565   public function with_text(string $text): Unsafe {
4566     return new Unsafe($text);
4567   }
4568 }
4569
4570 class UnsafeExpression extends EditableTrivia {
4571   public function __construct(string $text) {
4572     parent::__construct('unsafe_expression', $text);
4573   }
4574   public function with_text(string $text): UnsafeExpression {
4575     return new UnsafeExpression($text);
4576   }
4577 }
4578
4579 class FixMe extends EditableTrivia {
4580   public function __construct(string $text) {
4581     parent::__construct('fix_me', $text);
4582   }
4583   public function with_text(string $text): FixMe {
4584     return new FixMe($text);
4585   }
4586 }
4587
4588 class IgnoreError extends EditableTrivia {
4589   public function __construct(string $text) {
4590     parent::__construct('ignore_error', $text);
4591   }
4592   public function with_text(string $text): IgnoreError {
4593     return new IgnoreError($text);
4594   }
4595 }
4596
4597 class FallThrough extends EditableTrivia {
4598   public function __construct(string $text) {
4599     parent::__construct('fall_through', $text);
4600   }
4601   public function with_text(string $text): FallThrough {
4602     return new FallThrough($text);
4603   }
4604 }
4605
4606 class ExtraTokenError extends EditableTrivia {
4607   public function __construct(string $text) {
4608     parent::__construct('extra_token_error', $text);
4609   }
4610   public function with_text(string $text): ExtraTokenError {
4611     return new ExtraTokenError($text);
4612   }
4613 }
4614
4615 class AfterHaltCompiler extends EditableTrivia {
4616   public function __construct(string $text) {
4617     parent::__construct('after_halt_compiler', $text);
4618   }
4619   public function with_text(string $text): AfterHaltCompiler {
4620     return new AfterHaltCompiler($text);
4621   }
4622 }
4623
4624
4625
4626 final class Missing extends EditableSyntax {
4627   private static ?Missing $_missing = null;
4628
4629   public function __construct() {
4630     parent::__construct('missing');
4631   }
4632
4633   public function is_missing(): bool {
4634     return true;
4635   }
4636
4637   public function children(): Generator<string, EditableSyntax, void> {
4638     yield break;
4639   }
4640
4641   public static function missing(): Missing {
4642     if (Missing::$_missing === null) {
4643       $m = new Missing();
4644       Missing::$_missing = $m;
4645       return $m;
4646     } else {
4647       return Missing::$_missing;
4648     }
4649   }
4650
4651   public static function from_json(
4652     mixed $json,
4653     int $position,
4654     string $source) {
4655     return Missing::missing();
4656   }
4657
4658   public function rewrite(
4659     ( function
4660       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
4661     ?array<EditableSyntax> $parents = null): EditableSyntax {
4662       return $rewriter($this, $parents ?? []);
4663   }
4664
4665   public function to_array(): array<EditableSyntax> {
4666     return [];
4667   }
4668 }
4669
4670 final class EndOfFile extends EditableSyntax {
4671   private EditableSyntax $_token;
4672   public function __construct(
4673     EditableSyntax $token) {
4674     parent::__construct('end_of_file');
4675     $this->_token = $token;
4676   }
4677   public function token(): EditableSyntax {
4678     return $this->_token;
4679   }
4680   public function with_token(EditableSyntax $token): EndOfFile {
4681     return new EndOfFile(
4682       $token);
4683   }
4684
4685   public function rewrite(
4686     ( function
4687       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
4688     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
4689     $new_parents = $parents ?? [];
4690     array_push($new_parents, $this);
4691     $token = $this->token()->rewrite($rewriter, $new_parents);
4692     if (
4693       $token === $this->token()) {
4694       return $rewriter($this, $parents ?? []);
4695     } else {
4696       return $rewriter(new EndOfFile(
4697         $token), $parents ?? []);
4698     }
4699   }
4700
4701   public static function from_json(mixed $json, int $position, string $source) {
4702     $token = EditableSyntax::from_json(
4703       $json->end_of_file_token, $position, $source);
4704     $position += $token->width();
4705     return new EndOfFile(
4706         $token);
4707   }
4708   public function children(): Generator<string, EditableSyntax, void> {
4709     yield $this->_token;
4710     yield break;
4711   }
4712 }
4713 final class Script extends EditableSyntax {
4714   private EditableSyntax $_declarations;
4715   public function __construct(
4716     EditableSyntax $declarations) {
4717     parent::__construct('script');
4718     $this->_declarations = $declarations;
4719   }
4720   public function declarations(): EditableSyntax {
4721     return $this->_declarations;
4722   }
4723   public function with_declarations(EditableSyntax $declarations): Script {
4724     return new Script(
4725       $declarations);
4726   }
4727
4728   public function rewrite(
4729     ( function
4730       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
4731     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
4732     $new_parents = $parents ?? [];
4733     array_push($new_parents, $this);
4734     $declarations = $this->declarations()->rewrite($rewriter, $new_parents);
4735     if (
4736       $declarations === $this->declarations()) {
4737       return $rewriter($this, $parents ?? []);
4738     } else {
4739       return $rewriter(new Script(
4740         $declarations), $parents ?? []);
4741     }
4742   }
4743
4744   public static function from_json(mixed $json, int $position, string $source) {
4745     $declarations = EditableSyntax::from_json(
4746       $json->script_declarations, $position, $source);
4747     $position += $declarations->width();
4748     return new Script(
4749         $declarations);
4750   }
4751   public function children(): Generator<string, EditableSyntax, void> {
4752     yield $this->_declarations;
4753     yield break;
4754   }
4755 }
4756 final class SimpleTypeSpecifier extends EditableSyntax {
4757   private EditableSyntax $_specifier;
4758   public function __construct(
4759     EditableSyntax $specifier) {
4760     parent::__construct('simple_type_specifier');
4761     $this->_specifier = $specifier;
4762   }
4763   public function specifier(): EditableSyntax {
4764     return $this->_specifier;
4765   }
4766   public function with_specifier(EditableSyntax $specifier): SimpleTypeSpecifier {
4767     return new SimpleTypeSpecifier(
4768       $specifier);
4769   }
4770
4771   public function rewrite(
4772     ( function
4773       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
4774     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
4775     $new_parents = $parents ?? [];
4776     array_push($new_parents, $this);
4777     $specifier = $this->specifier()->rewrite($rewriter, $new_parents);
4778     if (
4779       $specifier === $this->specifier()) {
4780       return $rewriter($this, $parents ?? []);
4781     } else {
4782       return $rewriter(new SimpleTypeSpecifier(
4783         $specifier), $parents ?? []);
4784     }
4785   }
4786
4787   public static function from_json(mixed $json, int $position, string $source) {
4788     $specifier = EditableSyntax::from_json(
4789       $json->simple_type_specifier, $position, $source);
4790     $position += $specifier->width();
4791     return new SimpleTypeSpecifier(
4792         $specifier);
4793   }
4794   public function children(): Generator<string, EditableSyntax, void> {
4795     yield $this->_specifier;
4796     yield break;
4797   }
4798 }
4799 final class LiteralExpression extends EditableSyntax {
4800   private EditableSyntax $_expression;
4801   public function __construct(
4802     EditableSyntax $expression) {
4803     parent::__construct('literal');
4804     $this->_expression = $expression;
4805   }
4806   public function expression(): EditableSyntax {
4807     return $this->_expression;
4808   }
4809   public function with_expression(EditableSyntax $expression): LiteralExpression {
4810     return new LiteralExpression(
4811       $expression);
4812   }
4813
4814   public function rewrite(
4815     ( function
4816       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
4817     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
4818     $new_parents = $parents ?? [];
4819     array_push($new_parents, $this);
4820     $expression = $this->expression()->rewrite($rewriter, $new_parents);
4821     if (
4822       $expression === $this->expression()) {
4823       return $rewriter($this, $parents ?? []);
4824     } else {
4825       return $rewriter(new LiteralExpression(
4826         $expression), $parents ?? []);
4827     }
4828   }
4829
4830   public static function from_json(mixed $json, int $position, string $source) {
4831     $expression = EditableSyntax::from_json(
4832       $json->literal_expression, $position, $source);
4833     $position += $expression->width();
4834     return new LiteralExpression(
4835         $expression);
4836   }
4837   public function children(): Generator<string, EditableSyntax, void> {
4838     yield $this->_expression;
4839     yield break;
4840   }
4841 }
4842 final class VariableExpression extends EditableSyntax {
4843   private EditableSyntax $_expression;
4844   public function __construct(
4845     EditableSyntax $expression) {
4846     parent::__construct('variable');
4847     $this->_expression = $expression;
4848   }
4849   public function expression(): EditableSyntax {
4850     return $this->_expression;
4851   }
4852   public function with_expression(EditableSyntax $expression): VariableExpression {
4853     return new VariableExpression(
4854       $expression);
4855   }
4856
4857   public function rewrite(
4858     ( function
4859       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
4860     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
4861     $new_parents = $parents ?? [];
4862     array_push($new_parents, $this);
4863     $expression = $this->expression()->rewrite($rewriter, $new_parents);
4864     if (
4865       $expression === $this->expression()) {
4866       return $rewriter($this, $parents ?? []);
4867     } else {
4868       return $rewriter(new VariableExpression(
4869         $expression), $parents ?? []);
4870     }
4871   }
4872
4873   public static function from_json(mixed $json, int $position, string $source) {
4874     $expression = EditableSyntax::from_json(
4875       $json->variable_expression, $position, $source);
4876     $position += $expression->width();
4877     return new VariableExpression(
4878         $expression);
4879   }
4880   public function children(): Generator<string, EditableSyntax, void> {
4881     yield $this->_expression;
4882     yield break;
4883   }
4884 }
4885 final class QualifiedNameExpression extends EditableSyntax {
4886   private EditableSyntax $_expression;
4887   public function __construct(
4888     EditableSyntax $expression) {
4889     parent::__construct('qualified_name');
4890     $this->_expression = $expression;
4891   }
4892   public function expression(): EditableSyntax {
4893     return $this->_expression;
4894   }
4895   public function with_expression(EditableSyntax $expression): QualifiedNameExpression {
4896     return new QualifiedNameExpression(
4897       $expression);
4898   }
4899
4900   public function rewrite(
4901     ( function
4902       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
4903     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
4904     $new_parents = $parents ?? [];
4905     array_push($new_parents, $this);
4906     $expression = $this->expression()->rewrite($rewriter, $new_parents);
4907     if (
4908       $expression === $this->expression()) {
4909       return $rewriter($this, $parents ?? []);
4910     } else {
4911       return $rewriter(new QualifiedNameExpression(
4912         $expression), $parents ?? []);
4913     }
4914   }
4915
4916   public static function from_json(mixed $json, int $position, string $source) {
4917     $expression = EditableSyntax::from_json(
4918       $json->qualified_name_expression, $position, $source);
4919     $position += $expression->width();
4920     return new QualifiedNameExpression(
4921         $expression);
4922   }
4923   public function children(): Generator<string, EditableSyntax, void> {
4924     yield $this->_expression;
4925     yield break;
4926   }
4927 }
4928 final class PipeVariableExpression extends EditableSyntax {
4929   private EditableSyntax $_expression;
4930   public function __construct(
4931     EditableSyntax $expression) {
4932     parent::__construct('pipe_variable');
4933     $this->_expression = $expression;
4934   }
4935   public function expression(): EditableSyntax {
4936     return $this->_expression;
4937   }
4938   public function with_expression(EditableSyntax $expression): PipeVariableExpression {
4939     return new PipeVariableExpression(
4940       $expression);
4941   }
4942
4943   public function rewrite(
4944     ( function
4945       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
4946     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
4947     $new_parents = $parents ?? [];
4948     array_push($new_parents, $this);
4949     $expression = $this->expression()->rewrite($rewriter, $new_parents);
4950     if (
4951       $expression === $this->expression()) {
4952       return $rewriter($this, $parents ?? []);
4953     } else {
4954       return $rewriter(new PipeVariableExpression(
4955         $expression), $parents ?? []);
4956     }
4957   }
4958
4959   public static function from_json(mixed $json, int $position, string $source) {
4960     $expression = EditableSyntax::from_json(
4961       $json->pipe_variable_expression, $position, $source);
4962     $position += $expression->width();
4963     return new PipeVariableExpression(
4964         $expression);
4965   }
4966   public function children(): Generator<string, EditableSyntax, void> {
4967     yield $this->_expression;
4968     yield break;
4969   }
4970 }
4971 final class EnumDeclaration extends EditableSyntax {
4972   private EditableSyntax $_attribute_spec;
4973   private EditableSyntax $_keyword;
4974   private EditableSyntax $_name;
4975   private EditableSyntax $_colon;
4976   private EditableSyntax $_base;
4977   private EditableSyntax $_type;
4978   private EditableSyntax $_left_brace;
4979   private EditableSyntax $_enumerators;
4980   private EditableSyntax $_right_brace;
4981   public function __construct(
4982     EditableSyntax $attribute_spec,
4983     EditableSyntax $keyword,
4984     EditableSyntax $name,
4985     EditableSyntax $colon,
4986     EditableSyntax $base,
4987     EditableSyntax $type,
4988     EditableSyntax $left_brace,
4989     EditableSyntax $enumerators,
4990     EditableSyntax $right_brace) {
4991     parent::__construct('enum_declaration');
4992     $this->_attribute_spec = $attribute_spec;
4993     $this->_keyword = $keyword;
4994     $this->_name = $name;
4995     $this->_colon = $colon;
4996     $this->_base = $base;
4997     $this->_type = $type;
4998     $this->_left_brace = $left_brace;
4999     $this->_enumerators = $enumerators;
5000     $this->_right_brace = $right_brace;
5001   }
5002   public function attribute_spec(): EditableSyntax {
5003     return $this->_attribute_spec;
5004   }
5005   public function keyword(): EditableSyntax {
5006     return $this->_keyword;
5007   }
5008   public function name(): EditableSyntax {
5009     return $this->_name;
5010   }
5011   public function colon(): EditableSyntax {
5012     return $this->_colon;
5013   }
5014   public function base(): EditableSyntax {
5015     return $this->_base;
5016   }
5017   public function type(): EditableSyntax {
5018     return $this->_type;
5019   }
5020   public function left_brace(): EditableSyntax {
5021     return $this->_left_brace;
5022   }
5023   public function enumerators(): EditableSyntax {
5024     return $this->_enumerators;
5025   }
5026   public function right_brace(): EditableSyntax {
5027     return $this->_right_brace;
5028   }
5029   public function with_attribute_spec(EditableSyntax $attribute_spec): EnumDeclaration {
5030     return new EnumDeclaration(
5031       $attribute_spec,
5032       $this->_keyword,
5033       $this->_name,
5034       $this->_colon,
5035       $this->_base,
5036       $this->_type,
5037       $this->_left_brace,
5038       $this->_enumerators,
5039       $this->_right_brace);
5040   }
5041   public function with_keyword(EditableSyntax $keyword): EnumDeclaration {
5042     return new EnumDeclaration(
5043       $this->_attribute_spec,
5044       $keyword,
5045       $this->_name,
5046       $this->_colon,
5047       $this->_base,
5048       $this->_type,
5049       $this->_left_brace,
5050       $this->_enumerators,
5051       $this->_right_brace);
5052   }
5053   public function with_name(EditableSyntax $name): EnumDeclaration {
5054     return new EnumDeclaration(
5055       $this->_attribute_spec,
5056       $this->_keyword,
5057       $name,
5058       $this->_colon,
5059       $this->_base,
5060       $this->_type,
5061       $this->_left_brace,
5062       $this->_enumerators,
5063       $this->_right_brace);
5064   }
5065   public function with_colon(EditableSyntax $colon): EnumDeclaration {
5066     return new EnumDeclaration(
5067       $this->_attribute_spec,
5068       $this->_keyword,
5069       $this->_name,
5070       $colon,
5071       $this->_base,
5072       $this->_type,
5073       $this->_left_brace,
5074       $this->_enumerators,
5075       $this->_right_brace);
5076   }
5077   public function with_base(EditableSyntax $base): EnumDeclaration {
5078     return new EnumDeclaration(
5079       $this->_attribute_spec,
5080       $this->_keyword,
5081       $this->_name,
5082       $this->_colon,
5083       $base,
5084       $this->_type,
5085       $this->_left_brace,
5086       $this->_enumerators,
5087       $this->_right_brace);
5088   }
5089   public function with_type(EditableSyntax $type): EnumDeclaration {
5090     return new EnumDeclaration(
5091       $this->_attribute_spec,
5092       $this->_keyword,
5093       $this->_name,
5094       $this->_colon,
5095       $this->_base,
5096       $type,
5097       $this->_left_brace,
5098       $this->_enumerators,
5099       $this->_right_brace);
5100   }
5101   public function with_left_brace(EditableSyntax $left_brace): EnumDeclaration {
5102     return new EnumDeclaration(
5103       $this->_attribute_spec,
5104       $this->_keyword,
5105       $this->_name,
5106       $this->_colon,
5107       $this->_base,
5108       $this->_type,
5109       $left_brace,
5110       $this->_enumerators,
5111       $this->_right_brace);
5112   }
5113   public function with_enumerators(EditableSyntax $enumerators): EnumDeclaration {
5114     return new EnumDeclaration(
5115       $this->_attribute_spec,
5116       $this->_keyword,
5117       $this->_name,
5118       $this->_colon,
5119       $this->_base,
5120       $this->_type,
5121       $this->_left_brace,
5122       $enumerators,
5123       $this->_right_brace);
5124   }
5125   public function with_right_brace(EditableSyntax $right_brace): EnumDeclaration {
5126     return new EnumDeclaration(
5127       $this->_attribute_spec,
5128       $this->_keyword,
5129       $this->_name,
5130       $this->_colon,
5131       $this->_base,
5132       $this->_type,
5133       $this->_left_brace,
5134       $this->_enumerators,
5135       $right_brace);
5136   }
5137
5138   public function rewrite(
5139     ( function
5140       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
5141     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
5142     $new_parents = $parents ?? [];
5143     array_push($new_parents, $this);
5144     $attribute_spec = $this->attribute_spec()->rewrite($rewriter, $new_parents);
5145     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
5146     $name = $this->name()->rewrite($rewriter, $new_parents);
5147     $colon = $this->colon()->rewrite($rewriter, $new_parents);
5148     $base = $this->base()->rewrite($rewriter, $new_parents);
5149     $type = $this->type()->rewrite($rewriter, $new_parents);
5150     $left_brace = $this->left_brace()->rewrite($rewriter, $new_parents);
5151     $enumerators = $this->enumerators()->rewrite($rewriter, $new_parents);
5152     $right_brace = $this->right_brace()->rewrite($rewriter, $new_parents);
5153     if (
5154       $attribute_spec === $this->attribute_spec() &&
5155       $keyword === $this->keyword() &&
5156       $name === $this->name() &&
5157       $colon === $this->colon() &&
5158       $base === $this->base() &&
5159       $type === $this->type() &&
5160       $left_brace === $this->left_brace() &&
5161       $enumerators === $this->enumerators() &&
5162       $right_brace === $this->right_brace()) {
5163       return $rewriter($this, $parents ?? []);
5164     } else {
5165       return $rewriter(new EnumDeclaration(
5166         $attribute_spec,
5167         $keyword,
5168         $name,
5169         $colon,
5170         $base,
5171         $type,
5172         $left_brace,
5173         $enumerators,
5174         $right_brace), $parents ?? []);
5175     }
5176   }
5177
5178   public static function from_json(mixed $json, int $position, string $source) {
5179     $attribute_spec = EditableSyntax::from_json(
5180       $json->enum_attribute_spec, $position, $source);
5181     $position += $attribute_spec->width();
5182     $keyword = EditableSyntax::from_json(
5183       $json->enum_keyword, $position, $source);
5184     $position += $keyword->width();
5185     $name = EditableSyntax::from_json(
5186       $json->enum_name, $position, $source);
5187     $position += $name->width();
5188     $colon = EditableSyntax::from_json(
5189       $json->enum_colon, $position, $source);
5190     $position += $colon->width();
5191     $base = EditableSyntax::from_json(
5192       $json->enum_base, $position, $source);
5193     $position += $base->width();
5194     $type = EditableSyntax::from_json(
5195       $json->enum_type, $position, $source);
5196     $position += $type->width();
5197     $left_brace = EditableSyntax::from_json(
5198       $json->enum_left_brace, $position, $source);
5199     $position += $left_brace->width();
5200     $enumerators = EditableSyntax::from_json(
5201       $json->enum_enumerators, $position, $source);
5202     $position += $enumerators->width();
5203     $right_brace = EditableSyntax::from_json(
5204       $json->enum_right_brace, $position, $source);
5205     $position += $right_brace->width();
5206     return new EnumDeclaration(
5207         $attribute_spec,
5208         $keyword,
5209         $name,
5210         $colon,
5211         $base,
5212         $type,
5213         $left_brace,
5214         $enumerators,
5215         $right_brace);
5216   }
5217   public function children(): Generator<string, EditableSyntax, void> {
5218     yield $this->_attribute_spec;
5219     yield $this->_keyword;
5220     yield $this->_name;
5221     yield $this->_colon;
5222     yield $this->_base;
5223     yield $this->_type;
5224     yield $this->_left_brace;
5225     yield $this->_enumerators;
5226     yield $this->_right_brace;
5227     yield break;
5228   }
5229 }
5230 final class Enumerator extends EditableSyntax {
5231   private EditableSyntax $_name;
5232   private EditableSyntax $_equal;
5233   private EditableSyntax $_value;
5234   private EditableSyntax $_semicolon;
5235   public function __construct(
5236     EditableSyntax $name,
5237     EditableSyntax $equal,
5238     EditableSyntax $value,
5239     EditableSyntax $semicolon) {
5240     parent::__construct('enumerator');
5241     $this->_name = $name;
5242     $this->_equal = $equal;
5243     $this->_value = $value;
5244     $this->_semicolon = $semicolon;
5245   }
5246   public function name(): EditableSyntax {
5247     return $this->_name;
5248   }
5249   public function equal(): EditableSyntax {
5250     return $this->_equal;
5251   }
5252   public function value(): EditableSyntax {
5253     return $this->_value;
5254   }
5255   public function semicolon(): EditableSyntax {
5256     return $this->_semicolon;
5257   }
5258   public function with_name(EditableSyntax $name): Enumerator {
5259     return new Enumerator(
5260       $name,
5261       $this->_equal,
5262       $this->_value,
5263       $this->_semicolon);
5264   }
5265   public function with_equal(EditableSyntax $equal): Enumerator {
5266     return new Enumerator(
5267       $this->_name,
5268       $equal,
5269       $this->_value,
5270       $this->_semicolon);
5271   }
5272   public function with_value(EditableSyntax $value): Enumerator {
5273     return new Enumerator(
5274       $this->_name,
5275       $this->_equal,
5276       $value,
5277       $this->_semicolon);
5278   }
5279   public function with_semicolon(EditableSyntax $semicolon): Enumerator {
5280     return new Enumerator(
5281       $this->_name,
5282       $this->_equal,
5283       $this->_value,
5284       $semicolon);
5285   }
5286
5287   public function rewrite(
5288     ( function
5289       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
5290     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
5291     $new_parents = $parents ?? [];
5292     array_push($new_parents, $this);
5293     $name = $this->name()->rewrite($rewriter, $new_parents);
5294     $equal = $this->equal()->rewrite($rewriter, $new_parents);
5295     $value = $this->value()->rewrite($rewriter, $new_parents);
5296     $semicolon = $this->semicolon()->rewrite($rewriter, $new_parents);
5297     if (
5298       $name === $this->name() &&
5299       $equal === $this->equal() &&
5300       $value === $this->value() &&
5301       $semicolon === $this->semicolon()) {
5302       return $rewriter($this, $parents ?? []);
5303     } else {
5304       return $rewriter(new Enumerator(
5305         $name,
5306         $equal,
5307         $value,
5308         $semicolon), $parents ?? []);
5309     }
5310   }
5311
5312   public static function from_json(mixed $json, int $position, string $source) {
5313     $name = EditableSyntax::from_json(
5314       $json->enumerator_name, $position, $source);
5315     $position += $name->width();
5316     $equal = EditableSyntax::from_json(
5317       $json->enumerator_equal, $position, $source);
5318     $position += $equal->width();
5319     $value = EditableSyntax::from_json(
5320       $json->enumerator_value, $position, $source);
5321     $position += $value->width();
5322     $semicolon = EditableSyntax::from_json(
5323       $json->enumerator_semicolon, $position, $source);
5324     $position += $semicolon->width();
5325     return new Enumerator(
5326         $name,
5327         $equal,
5328         $value,
5329         $semicolon);
5330   }
5331   public function children(): Generator<string, EditableSyntax, void> {
5332     yield $this->_name;
5333     yield $this->_equal;
5334     yield $this->_value;
5335     yield $this->_semicolon;
5336     yield break;
5337   }
5338 }
5339 final class AliasDeclaration extends EditableSyntax {
5340   private EditableSyntax $_attribute_spec;
5341   private EditableSyntax $_keyword;
5342   private EditableSyntax $_name;
5343   private EditableSyntax $_generic_parameter;
5344   private EditableSyntax $_constraint;
5345   private EditableSyntax $_equal;
5346   private EditableSyntax $_type;
5347   private EditableSyntax $_semicolon;
5348   public function __construct(
5349     EditableSyntax $attribute_spec,
5350     EditableSyntax $keyword,
5351     EditableSyntax $name,
5352     EditableSyntax $generic_parameter,
5353     EditableSyntax $constraint,
5354     EditableSyntax $equal,
5355     EditableSyntax $type,
5356     EditableSyntax $semicolon) {
5357     parent::__construct('alias_declaration');
5358     $this->_attribute_spec = $attribute_spec;
5359     $this->_keyword = $keyword;
5360     $this->_name = $name;
5361     $this->_generic_parameter = $generic_parameter;
5362     $this->_constraint = $constraint;
5363     $this->_equal = $equal;
5364     $this->_type = $type;
5365     $this->_semicolon = $semicolon;
5366   }
5367   public function attribute_spec(): EditableSyntax {
5368     return $this->_attribute_spec;
5369   }
5370   public function keyword(): EditableSyntax {
5371     return $this->_keyword;
5372   }
5373   public function name(): EditableSyntax {
5374     return $this->_name;
5375   }
5376   public function generic_parameter(): EditableSyntax {
5377     return $this->_generic_parameter;
5378   }
5379   public function constraint(): EditableSyntax {
5380     return $this->_constraint;
5381   }
5382   public function equal(): EditableSyntax {
5383     return $this->_equal;
5384   }
5385   public function type(): EditableSyntax {
5386     return $this->_type;
5387   }
5388   public function semicolon(): EditableSyntax {
5389     return $this->_semicolon;
5390   }
5391   public function with_attribute_spec(EditableSyntax $attribute_spec): AliasDeclaration {
5392     return new AliasDeclaration(
5393       $attribute_spec,
5394       $this->_keyword,
5395       $this->_name,
5396       $this->_generic_parameter,
5397       $this->_constraint,
5398       $this->_equal,
5399       $this->_type,
5400       $this->_semicolon);
5401   }
5402   public function with_keyword(EditableSyntax $keyword): AliasDeclaration {
5403     return new AliasDeclaration(
5404       $this->_attribute_spec,
5405       $keyword,
5406       $this->_name,
5407       $this->_generic_parameter,
5408       $this->_constraint,
5409       $this->_equal,
5410       $this->_type,
5411       $this->_semicolon);
5412   }
5413   public function with_name(EditableSyntax $name): AliasDeclaration {
5414     return new AliasDeclaration(
5415       $this->_attribute_spec,
5416       $this->_keyword,
5417       $name,
5418       $this->_generic_parameter,
5419       $this->_constraint,
5420       $this->_equal,
5421       $this->_type,
5422       $this->_semicolon);
5423   }
5424   public function with_generic_parameter(EditableSyntax $generic_parameter): AliasDeclaration {
5425     return new AliasDeclaration(
5426       $this->_attribute_spec,
5427       $this->_keyword,
5428       $this->_name,
5429       $generic_parameter,
5430       $this->_constraint,
5431       $this->_equal,
5432       $this->_type,
5433       $this->_semicolon);
5434   }
5435   public function with_constraint(EditableSyntax $constraint): AliasDeclaration {
5436     return new AliasDeclaration(
5437       $this->_attribute_spec,
5438       $this->_keyword,
5439       $this->_name,
5440       $this->_generic_parameter,
5441       $constraint,
5442       $this->_equal,
5443       $this->_type,
5444       $this->_semicolon);
5445   }
5446   public function with_equal(EditableSyntax $equal): AliasDeclaration {
5447     return new AliasDeclaration(
5448       $this->_attribute_spec,
5449       $this->_keyword,
5450       $this->_name,
5451       $this->_generic_parameter,
5452       $this->_constraint,
5453       $equal,
5454       $this->_type,
5455       $this->_semicolon);
5456   }
5457   public function with_type(EditableSyntax $type): AliasDeclaration {
5458     return new AliasDeclaration(
5459       $this->_attribute_spec,
5460       $this->_keyword,
5461       $this->_name,
5462       $this->_generic_parameter,
5463       $this->_constraint,
5464       $this->_equal,
5465       $type,
5466       $this->_semicolon);
5467   }
5468   public function with_semicolon(EditableSyntax $semicolon): AliasDeclaration {
5469     return new AliasDeclaration(
5470       $this->_attribute_spec,
5471       $this->_keyword,
5472       $this->_name,
5473       $this->_generic_parameter,
5474       $this->_constraint,
5475       $this->_equal,
5476       $this->_type,
5477       $semicolon);
5478   }
5479
5480   public function rewrite(
5481     ( function
5482       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
5483     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
5484     $new_parents = $parents ?? [];
5485     array_push($new_parents, $this);
5486     $attribute_spec = $this->attribute_spec()->rewrite($rewriter, $new_parents);
5487     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
5488     $name = $this->name()->rewrite($rewriter, $new_parents);
5489     $generic_parameter = $this->generic_parameter()->rewrite($rewriter, $new_parents);
5490     $constraint = $this->constraint()->rewrite($rewriter, $new_parents);
5491     $equal = $this->equal()->rewrite($rewriter, $new_parents);
5492     $type = $this->type()->rewrite($rewriter, $new_parents);
5493     $semicolon = $this->semicolon()->rewrite($rewriter, $new_parents);
5494     if (
5495       $attribute_spec === $this->attribute_spec() &&
5496       $keyword === $this->keyword() &&
5497       $name === $this->name() &&
5498       $generic_parameter === $this->generic_parameter() &&
5499       $constraint === $this->constraint() &&
5500       $equal === $this->equal() &&
5501       $type === $this->type() &&
5502       $semicolon === $this->semicolon()) {
5503       return $rewriter($this, $parents ?? []);
5504     } else {
5505       return $rewriter(new AliasDeclaration(
5506         $attribute_spec,
5507         $keyword,
5508         $name,
5509         $generic_parameter,
5510         $constraint,
5511         $equal,
5512         $type,
5513         $semicolon), $parents ?? []);
5514     }
5515   }
5516
5517   public static function from_json(mixed $json, int $position, string $source) {
5518     $attribute_spec = EditableSyntax::from_json(
5519       $json->alias_attribute_spec, $position, $source);
5520     $position += $attribute_spec->width();
5521     $keyword = EditableSyntax::from_json(
5522       $json->alias_keyword, $position, $source);
5523     $position += $keyword->width();
5524     $name = EditableSyntax::from_json(
5525       $json->alias_name, $position, $source);
5526     $position += $name->width();
5527     $generic_parameter = EditableSyntax::from_json(
5528       $json->alias_generic_parameter, $position, $source);
5529     $position += $generic_parameter->width();
5530     $constraint = EditableSyntax::from_json(
5531       $json->alias_constraint, $position, $source);
5532     $position += $constraint->width();
5533     $equal = EditableSyntax::from_json(
5534       $json->alias_equal, $position, $source);
5535     $position += $equal->width();
5536     $type = EditableSyntax::from_json(
5537       $json->alias_type, $position, $source);
5538     $position += $type->width();
5539     $semicolon = EditableSyntax::from_json(
5540       $json->alias_semicolon, $position, $source);
5541     $position += $semicolon->width();
5542     return new AliasDeclaration(
5543         $attribute_spec,
5544         $keyword,
5545         $name,
5546         $generic_parameter,
5547         $constraint,
5548         $equal,
5549         $type,
5550         $semicolon);
5551   }
5552   public function children(): Generator<string, EditableSyntax, void> {
5553     yield $this->_attribute_spec;
5554     yield $this->_keyword;
5555     yield $this->_name;
5556     yield $this->_generic_parameter;
5557     yield $this->_constraint;
5558     yield $this->_equal;
5559     yield $this->_type;
5560     yield $this->_semicolon;
5561     yield break;
5562   }
5563 }
5564 final class PropertyDeclaration extends EditableSyntax {
5565   private EditableSyntax $_modifiers;
5566   private EditableSyntax $_type;
5567   private EditableSyntax $_declarators;
5568   private EditableSyntax $_semicolon;
5569   public function __construct(
5570     EditableSyntax $modifiers,
5571     EditableSyntax $type,
5572     EditableSyntax $declarators,
5573     EditableSyntax $semicolon) {
5574     parent::__construct('property_declaration');
5575     $this->_modifiers = $modifiers;
5576     $this->_type = $type;
5577     $this->_declarators = $declarators;
5578     $this->_semicolon = $semicolon;
5579   }
5580   public function modifiers(): EditableSyntax {
5581     return $this->_modifiers;
5582   }
5583   public function type(): EditableSyntax {
5584     return $this->_type;
5585   }
5586   public function declarators(): EditableSyntax {
5587     return $this->_declarators;
5588   }
5589   public function semicolon(): EditableSyntax {
5590     return $this->_semicolon;
5591   }
5592   public function with_modifiers(EditableSyntax $modifiers): PropertyDeclaration {
5593     return new PropertyDeclaration(
5594       $modifiers,
5595       $this->_type,
5596       $this->_declarators,
5597       $this->_semicolon);
5598   }
5599   public function with_type(EditableSyntax $type): PropertyDeclaration {
5600     return new PropertyDeclaration(
5601       $this->_modifiers,
5602       $type,
5603       $this->_declarators,
5604       $this->_semicolon);
5605   }
5606   public function with_declarators(EditableSyntax $declarators): PropertyDeclaration {
5607     return new PropertyDeclaration(
5608       $this->_modifiers,
5609       $this->_type,
5610       $declarators,
5611       $this->_semicolon);
5612   }
5613   public function with_semicolon(EditableSyntax $semicolon): PropertyDeclaration {
5614     return new PropertyDeclaration(
5615       $this->_modifiers,
5616       $this->_type,
5617       $this->_declarators,
5618       $semicolon);
5619   }
5620
5621   public function rewrite(
5622     ( function
5623       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
5624     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
5625     $new_parents = $parents ?? [];
5626     array_push($new_parents, $this);
5627     $modifiers = $this->modifiers()->rewrite($rewriter, $new_parents);
5628     $type = $this->type()->rewrite($rewriter, $new_parents);
5629     $declarators = $this->declarators()->rewrite($rewriter, $new_parents);
5630     $semicolon = $this->semicolon()->rewrite($rewriter, $new_parents);
5631     if (
5632       $modifiers === $this->modifiers() &&
5633       $type === $this->type() &&
5634       $declarators === $this->declarators() &&
5635       $semicolon === $this->semicolon()) {
5636       return $rewriter($this, $parents ?? []);
5637     } else {
5638       return $rewriter(new PropertyDeclaration(
5639         $modifiers,
5640         $type,
5641         $declarators,
5642         $semicolon), $parents ?? []);
5643     }
5644   }
5645
5646   public static function from_json(mixed $json, int $position, string $source) {
5647     $modifiers = EditableSyntax::from_json(
5648       $json->property_modifiers, $position, $source);
5649     $position += $modifiers->width();
5650     $type = EditableSyntax::from_json(
5651       $json->property_type, $position, $source);
5652     $position += $type->width();
5653     $declarators = EditableSyntax::from_json(
5654       $json->property_declarators, $position, $source);
5655     $position += $declarators->width();
5656     $semicolon = EditableSyntax::from_json(
5657       $json->property_semicolon, $position, $source);
5658     $position += $semicolon->width();
5659     return new PropertyDeclaration(
5660         $modifiers,
5661         $type,
5662         $declarators,
5663         $semicolon);
5664   }
5665   public function children(): Generator<string, EditableSyntax, void> {
5666     yield $this->_modifiers;
5667     yield $this->_type;
5668     yield $this->_declarators;
5669     yield $this->_semicolon;
5670     yield break;
5671   }
5672 }
5673 final class PropertyDeclarator extends EditableSyntax {
5674   private EditableSyntax $_name;
5675   private EditableSyntax $_initializer;
5676   public function __construct(
5677     EditableSyntax $name,
5678     EditableSyntax $initializer) {
5679     parent::__construct('property_declarator');
5680     $this->_name = $name;
5681     $this->_initializer = $initializer;
5682   }
5683   public function name(): EditableSyntax {
5684     return $this->_name;
5685   }
5686   public function initializer(): EditableSyntax {
5687     return $this->_initializer;
5688   }
5689   public function with_name(EditableSyntax $name): PropertyDeclarator {
5690     return new PropertyDeclarator(
5691       $name,
5692       $this->_initializer);
5693   }
5694   public function with_initializer(EditableSyntax $initializer): PropertyDeclarator {
5695     return new PropertyDeclarator(
5696       $this->_name,
5697       $initializer);
5698   }
5699
5700   public function rewrite(
5701     ( function
5702       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
5703     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
5704     $new_parents = $parents ?? [];
5705     array_push($new_parents, $this);
5706     $name = $this->name()->rewrite($rewriter, $new_parents);
5707     $initializer = $this->initializer()->rewrite($rewriter, $new_parents);
5708     if (
5709       $name === $this->name() &&
5710       $initializer === $this->initializer()) {
5711       return $rewriter($this, $parents ?? []);
5712     } else {
5713       return $rewriter(new PropertyDeclarator(
5714         $name,
5715         $initializer), $parents ?? []);
5716     }
5717   }
5718
5719   public static function from_json(mixed $json, int $position, string $source) {
5720     $name = EditableSyntax::from_json(
5721       $json->property_name, $position, $source);
5722     $position += $name->width();
5723     $initializer = EditableSyntax::from_json(
5724       $json->property_initializer, $position, $source);
5725     $position += $initializer->width();
5726     return new PropertyDeclarator(
5727         $name,
5728         $initializer);
5729   }
5730   public function children(): Generator<string, EditableSyntax, void> {
5731     yield $this->_name;
5732     yield $this->_initializer;
5733     yield break;
5734   }
5735 }
5736 final class NamespaceDeclaration extends EditableSyntax {
5737   private EditableSyntax $_keyword;
5738   private EditableSyntax $_name;
5739   private EditableSyntax $_body;
5740   public function __construct(
5741     EditableSyntax $keyword,
5742     EditableSyntax $name,
5743     EditableSyntax $body) {
5744     parent::__construct('namespace_declaration');
5745     $this->_keyword = $keyword;
5746     $this->_name = $name;
5747     $this->_body = $body;
5748   }
5749   public function keyword(): EditableSyntax {
5750     return $this->_keyword;
5751   }
5752   public function name(): EditableSyntax {
5753     return $this->_name;
5754   }
5755   public function body(): EditableSyntax {
5756     return $this->_body;
5757   }
5758   public function with_keyword(EditableSyntax $keyword): NamespaceDeclaration {
5759     return new NamespaceDeclaration(
5760       $keyword,
5761       $this->_name,
5762       $this->_body);
5763   }
5764   public function with_name(EditableSyntax $name): NamespaceDeclaration {
5765     return new NamespaceDeclaration(
5766       $this->_keyword,
5767       $name,
5768       $this->_body);
5769   }
5770   public function with_body(EditableSyntax $body): NamespaceDeclaration {
5771     return new NamespaceDeclaration(
5772       $this->_keyword,
5773       $this->_name,
5774       $body);
5775   }
5776
5777   public function rewrite(
5778     ( function
5779       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
5780     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
5781     $new_parents = $parents ?? [];
5782     array_push($new_parents, $this);
5783     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
5784     $name = $this->name()->rewrite($rewriter, $new_parents);
5785     $body = $this->body()->rewrite($rewriter, $new_parents);
5786     if (
5787       $keyword === $this->keyword() &&
5788       $name === $this->name() &&
5789       $body === $this->body()) {
5790       return $rewriter($this, $parents ?? []);
5791     } else {
5792       return $rewriter(new NamespaceDeclaration(
5793         $keyword,
5794         $name,
5795         $body), $parents ?? []);
5796     }
5797   }
5798
5799   public static function from_json(mixed $json, int $position, string $source) {
5800     $keyword = EditableSyntax::from_json(
5801       $json->namespace_keyword, $position, $source);
5802     $position += $keyword->width();
5803     $name = EditableSyntax::from_json(
5804       $json->namespace_name, $position, $source);
5805     $position += $name->width();
5806     $body = EditableSyntax::from_json(
5807       $json->namespace_body, $position, $source);
5808     $position += $body->width();
5809     return new NamespaceDeclaration(
5810         $keyword,
5811         $name,
5812         $body);
5813   }
5814   public function children(): Generator<string, EditableSyntax, void> {
5815     yield $this->_keyword;
5816     yield $this->_name;
5817     yield $this->_body;
5818     yield break;
5819   }
5820 }
5821 final class NamespaceBody extends EditableSyntax {
5822   private EditableSyntax $_left_brace;
5823   private EditableSyntax $_declarations;
5824   private EditableSyntax $_right_brace;
5825   public function __construct(
5826     EditableSyntax $left_brace,
5827     EditableSyntax $declarations,
5828     EditableSyntax $right_brace) {
5829     parent::__construct('namespace_body');
5830     $this->_left_brace = $left_brace;
5831     $this->_declarations = $declarations;
5832     $this->_right_brace = $right_brace;
5833   }
5834   public function left_brace(): EditableSyntax {
5835     return $this->_left_brace;
5836   }
5837   public function declarations(): EditableSyntax {
5838     return $this->_declarations;
5839   }
5840   public function right_brace(): EditableSyntax {
5841     return $this->_right_brace;
5842   }
5843   public function with_left_brace(EditableSyntax $left_brace): NamespaceBody {
5844     return new NamespaceBody(
5845       $left_brace,
5846       $this->_declarations,
5847       $this->_right_brace);
5848   }
5849   public function with_declarations(EditableSyntax $declarations): NamespaceBody {
5850     return new NamespaceBody(
5851       $this->_left_brace,
5852       $declarations,
5853       $this->_right_brace);
5854   }
5855   public function with_right_brace(EditableSyntax $right_brace): NamespaceBody {
5856     return new NamespaceBody(
5857       $this->_left_brace,
5858       $this->_declarations,
5859       $right_brace);
5860   }
5861
5862   public function rewrite(
5863     ( function
5864       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
5865     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
5866     $new_parents = $parents ?? [];
5867     array_push($new_parents, $this);
5868     $left_brace = $this->left_brace()->rewrite($rewriter, $new_parents);
5869     $declarations = $this->declarations()->rewrite($rewriter, $new_parents);
5870     $right_brace = $this->right_brace()->rewrite($rewriter, $new_parents);
5871     if (
5872       $left_brace === $this->left_brace() &&
5873       $declarations === $this->declarations() &&
5874       $right_brace === $this->right_brace()) {
5875       return $rewriter($this, $parents ?? []);
5876     } else {
5877       return $rewriter(new NamespaceBody(
5878         $left_brace,
5879         $declarations,
5880         $right_brace), $parents ?? []);
5881     }
5882   }
5883
5884   public static function from_json(mixed $json, int $position, string $source) {
5885     $left_brace = EditableSyntax::from_json(
5886       $json->namespace_left_brace, $position, $source);
5887     $position += $left_brace->width();
5888     $declarations = EditableSyntax::from_json(
5889       $json->namespace_declarations, $position, $source);
5890     $position += $declarations->width();
5891     $right_brace = EditableSyntax::from_json(
5892       $json->namespace_right_brace, $position, $source);
5893     $position += $right_brace->width();
5894     return new NamespaceBody(
5895         $left_brace,
5896         $declarations,
5897         $right_brace);
5898   }
5899   public function children(): Generator<string, EditableSyntax, void> {
5900     yield $this->_left_brace;
5901     yield $this->_declarations;
5902     yield $this->_right_brace;
5903     yield break;
5904   }
5905 }
5906 final class NamespaceEmptyBody extends EditableSyntax {
5907   private EditableSyntax $_semicolon;
5908   public function __construct(
5909     EditableSyntax $semicolon) {
5910     parent::__construct('namespace_empty_body');
5911     $this->_semicolon = $semicolon;
5912   }
5913   public function semicolon(): EditableSyntax {
5914     return $this->_semicolon;
5915   }
5916   public function with_semicolon(EditableSyntax $semicolon): NamespaceEmptyBody {
5917     return new NamespaceEmptyBody(
5918       $semicolon);
5919   }
5920
5921   public function rewrite(
5922     ( function
5923       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
5924     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
5925     $new_parents = $parents ?? [];
5926     array_push($new_parents, $this);
5927     $semicolon = $this->semicolon()->rewrite($rewriter, $new_parents);
5928     if (
5929       $semicolon === $this->semicolon()) {
5930       return $rewriter($this, $parents ?? []);
5931     } else {
5932       return $rewriter(new NamespaceEmptyBody(
5933         $semicolon), $parents ?? []);
5934     }
5935   }
5936
5937   public static function from_json(mixed $json, int $position, string $source) {
5938     $semicolon = EditableSyntax::from_json(
5939       $json->namespace_semicolon, $position, $source);
5940     $position += $semicolon->width();
5941     return new NamespaceEmptyBody(
5942         $semicolon);
5943   }
5944   public function children(): Generator<string, EditableSyntax, void> {
5945     yield $this->_semicolon;
5946     yield break;
5947   }
5948 }
5949 final class NamespaceUseDeclaration extends EditableSyntax {
5950   private EditableSyntax $_keyword;
5951   private EditableSyntax $_kind;
5952   private EditableSyntax $_clauses;
5953   private EditableSyntax $_semicolon;
5954   public function __construct(
5955     EditableSyntax $keyword,
5956     EditableSyntax $kind,
5957     EditableSyntax $clauses,
5958     EditableSyntax $semicolon) {
5959     parent::__construct('namespace_use_declaration');
5960     $this->_keyword = $keyword;
5961     $this->_kind = $kind;
5962     $this->_clauses = $clauses;
5963     $this->_semicolon = $semicolon;
5964   }
5965   public function keyword(): EditableSyntax {
5966     return $this->_keyword;
5967   }
5968   public function kind(): EditableSyntax {
5969     return $this->_kind;
5970   }
5971   public function clauses(): EditableSyntax {
5972     return $this->_clauses;
5973   }
5974   public function semicolon(): EditableSyntax {
5975     return $this->_semicolon;
5976   }
5977   public function with_keyword(EditableSyntax $keyword): NamespaceUseDeclaration {
5978     return new NamespaceUseDeclaration(
5979       $keyword,
5980       $this->_kind,
5981       $this->_clauses,
5982       $this->_semicolon);
5983   }
5984   public function with_kind(EditableSyntax $kind): NamespaceUseDeclaration {
5985     return new NamespaceUseDeclaration(
5986       $this->_keyword,
5987       $kind,
5988       $this->_clauses,
5989       $this->_semicolon);
5990   }
5991   public function with_clauses(EditableSyntax $clauses): NamespaceUseDeclaration {
5992     return new NamespaceUseDeclaration(
5993       $this->_keyword,
5994       $this->_kind,
5995       $clauses,
5996       $this->_semicolon);
5997   }
5998   public function with_semicolon(EditableSyntax $semicolon): NamespaceUseDeclaration {
5999     return new NamespaceUseDeclaration(
6000       $this->_keyword,
6001       $this->_kind,
6002       $this->_clauses,
6003       $semicolon);
6004   }
6005
6006   public function rewrite(
6007     ( function
6008       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
6009     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
6010     $new_parents = $parents ?? [];
6011     array_push($new_parents, $this);
6012     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
6013     $kind = $this->kind()->rewrite($rewriter, $new_parents);
6014     $clauses = $this->clauses()->rewrite($rewriter, $new_parents);
6015     $semicolon = $this->semicolon()->rewrite($rewriter, $new_parents);
6016     if (
6017       $keyword === $this->keyword() &&
6018       $kind === $this->kind() &&
6019       $clauses === $this->clauses() &&
6020       $semicolon === $this->semicolon()) {
6021       return $rewriter($this, $parents ?? []);
6022     } else {
6023       return $rewriter(new NamespaceUseDeclaration(
6024         $keyword,
6025         $kind,
6026         $clauses,
6027         $semicolon), $parents ?? []);
6028     }
6029   }
6030
6031   public static function from_json(mixed $json, int $position, string $source) {
6032     $keyword = EditableSyntax::from_json(
6033       $json->namespace_use_keyword, $position, $source);
6034     $position += $keyword->width();
6035     $kind = EditableSyntax::from_json(
6036       $json->namespace_use_kind, $position, $source);
6037     $position += $kind->width();
6038     $clauses = EditableSyntax::from_json(
6039       $json->namespace_use_clauses, $position, $source);
6040     $position += $clauses->width();
6041     $semicolon = EditableSyntax::from_json(
6042       $json->namespace_use_semicolon, $position, $source);
6043     $position += $semicolon->width();
6044     return new NamespaceUseDeclaration(
6045         $keyword,
6046         $kind,
6047         $clauses,
6048         $semicolon);
6049   }
6050   public function children(): Generator<string, EditableSyntax, void> {
6051     yield $this->_keyword;
6052     yield $this->_kind;
6053     yield $this->_clauses;
6054     yield $this->_semicolon;
6055     yield break;
6056   }
6057 }
6058 final class NamespaceGroupUseDeclaration extends EditableSyntax {
6059   private EditableSyntax $_keyword;
6060   private EditableSyntax $_kind;
6061   private EditableSyntax $_prefix;
6062   private EditableSyntax $_left_brace;
6063   private EditableSyntax $_clauses;
6064   private EditableSyntax $_right_brace;
6065   private EditableSyntax $_semicolon;
6066   public function __construct(
6067     EditableSyntax $keyword,
6068     EditableSyntax $kind,
6069     EditableSyntax $prefix,
6070     EditableSyntax $left_brace,
6071     EditableSyntax $clauses,
6072     EditableSyntax $right_brace,
6073     EditableSyntax $semicolon) {
6074     parent::__construct('namespace_group_use_declaration');
6075     $this->_keyword = $keyword;
6076     $this->_kind = $kind;
6077     $this->_prefix = $prefix;
6078     $this->_left_brace = $left_brace;
6079     $this->_clauses = $clauses;
6080     $this->_right_brace = $right_brace;
6081     $this->_semicolon = $semicolon;
6082   }
6083   public function keyword(): EditableSyntax {
6084     return $this->_keyword;
6085   }
6086   public function kind(): EditableSyntax {
6087     return $this->_kind;
6088   }
6089   public function prefix(): EditableSyntax {
6090     return $this->_prefix;
6091   }
6092   public function left_brace(): EditableSyntax {
6093     return $this->_left_brace;
6094   }
6095   public function clauses(): EditableSyntax {
6096     return $this->_clauses;
6097   }
6098   public function right_brace(): EditableSyntax {
6099     return $this->_right_brace;
6100   }
6101   public function semicolon(): EditableSyntax {
6102     return $this->_semicolon;
6103   }
6104   public function with_keyword(EditableSyntax $keyword): NamespaceGroupUseDeclaration {
6105     return new NamespaceGroupUseDeclaration(
6106       $keyword,
6107       $this->_kind,
6108       $this->_prefix,
6109       $this->_left_brace,
6110       $this->_clauses,
6111       $this->_right_brace,
6112       $this->_semicolon);
6113   }
6114   public function with_kind(EditableSyntax $kind): NamespaceGroupUseDeclaration {
6115     return new NamespaceGroupUseDeclaration(
6116       $this->_keyword,
6117       $kind,
6118       $this->_prefix,
6119       $this->_left_brace,
6120       $this->_clauses,
6121       $this->_right_brace,
6122       $this->_semicolon);
6123   }
6124   public function with_prefix(EditableSyntax $prefix): NamespaceGroupUseDeclaration {
6125     return new NamespaceGroupUseDeclaration(
6126       $this->_keyword,
6127       $this->_kind,
6128       $prefix,
6129       $this->_left_brace,
6130       $this->_clauses,
6131       $this->_right_brace,
6132       $this->_semicolon);
6133   }
6134   public function with_left_brace(EditableSyntax $left_brace): NamespaceGroupUseDeclaration {
6135     return new NamespaceGroupUseDeclaration(
6136       $this->_keyword,
6137       $this->_kind,
6138       $this->_prefix,
6139       $left_brace,
6140       $this->_clauses,
6141       $this->_right_brace,
6142       $this->_semicolon);
6143   }
6144   public function with_clauses(EditableSyntax $clauses): NamespaceGroupUseDeclaration {
6145     return new NamespaceGroupUseDeclaration(
6146       $this->_keyword,
6147       $this->_kind,
6148       $this->_prefix,
6149       $this->_left_brace,
6150       $clauses,
6151       $this->_right_brace,
6152       $this->_semicolon);
6153   }
6154   public function with_right_brace(EditableSyntax $right_brace): NamespaceGroupUseDeclaration {
6155     return new NamespaceGroupUseDeclaration(
6156       $this->_keyword,
6157       $this->_kind,
6158       $this->_prefix,
6159       $this->_left_brace,
6160       $this->_clauses,
6161       $right_brace,
6162       $this->_semicolon);
6163   }
6164   public function with_semicolon(EditableSyntax $semicolon): NamespaceGroupUseDeclaration {
6165     return new NamespaceGroupUseDeclaration(
6166       $this->_keyword,
6167       $this->_kind,
6168       $this->_prefix,
6169       $this->_left_brace,
6170       $this->_clauses,
6171       $this->_right_brace,
6172       $semicolon);
6173   }
6174
6175   public function rewrite(
6176     ( function
6177       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
6178     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
6179     $new_parents = $parents ?? [];
6180     array_push($new_parents, $this);
6181     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
6182     $kind = $this->kind()->rewrite($rewriter, $new_parents);
6183     $prefix = $this->prefix()->rewrite($rewriter, $new_parents);
6184     $left_brace = $this->left_brace()->rewrite($rewriter, $new_parents);
6185     $clauses = $this->clauses()->rewrite($rewriter, $new_parents);
6186     $right_brace = $this->right_brace()->rewrite($rewriter, $new_parents);
6187     $semicolon = $this->semicolon()->rewrite($rewriter, $new_parents);
6188     if (
6189       $keyword === $this->keyword() &&
6190       $kind === $this->kind() &&
6191       $prefix === $this->prefix() &&
6192       $left_brace === $this->left_brace() &&
6193       $clauses === $this->clauses() &&
6194       $right_brace === $this->right_brace() &&
6195       $semicolon === $this->semicolon()) {
6196       return $rewriter($this, $parents ?? []);
6197     } else {
6198       return $rewriter(new NamespaceGroupUseDeclaration(
6199         $keyword,
6200         $kind,
6201         $prefix,
6202         $left_brace,
6203         $clauses,
6204         $right_brace,
6205         $semicolon), $parents ?? []);
6206     }
6207   }
6208
6209   public static function from_json(mixed $json, int $position, string $source) {
6210     $keyword = EditableSyntax::from_json(
6211       $json->namespace_group_use_keyword, $position, $source);
6212     $position += $keyword->width();
6213     $kind = EditableSyntax::from_json(
6214       $json->namespace_group_use_kind, $position, $source);
6215     $position += $kind->width();
6216     $prefix = EditableSyntax::from_json(
6217       $json->namespace_group_use_prefix, $position, $source);
6218     $position += $prefix->width();
6219     $left_brace = EditableSyntax::from_json(
6220       $json->namespace_group_use_left_brace, $position, $source);
6221     $position += $left_brace->width();
6222     $clauses = EditableSyntax::from_json(
6223       $json->namespace_group_use_clauses, $position, $source);
6224     $position += $clauses->width();
6225     $right_brace = EditableSyntax::from_json(
6226       $json->namespace_group_use_right_brace, $position, $source);
6227     $position += $right_brace->width();
6228     $semicolon = EditableSyntax::from_json(
6229       $json->namespace_group_use_semicolon, $position, $source);
6230     $position += $semicolon->width();
6231     return new NamespaceGroupUseDeclaration(
6232         $keyword,
6233         $kind,
6234         $prefix,
6235         $left_brace,
6236         $clauses,
6237         $right_brace,
6238         $semicolon);
6239   }
6240   public function children(): Generator<string, EditableSyntax, void> {
6241     yield $this->_keyword;
6242     yield $this->_kind;
6243     yield $this->_prefix;
6244     yield $this->_left_brace;
6245     yield $this->_clauses;
6246     yield $this->_right_brace;
6247     yield $this->_semicolon;
6248     yield break;
6249   }
6250 }
6251 final class NamespaceUseClause extends EditableSyntax {
6252   private EditableSyntax $_clause_kind;
6253   private EditableSyntax $_name;
6254   private EditableSyntax $_as;
6255   private EditableSyntax $_alias;
6256   public function __construct(
6257     EditableSyntax $clause_kind,
6258     EditableSyntax $name,
6259     EditableSyntax $as,
6260     EditableSyntax $alias) {
6261     parent::__construct('namespace_use_clause');
6262     $this->_clause_kind = $clause_kind;
6263     $this->_name = $name;
6264     $this->_as = $as;
6265     $this->_alias = $alias;
6266   }
6267   public function clause_kind(): EditableSyntax {
6268     return $this->_clause_kind;
6269   }
6270   public function name(): EditableSyntax {
6271     return $this->_name;
6272   }
6273   public function as(): EditableSyntax {
6274     return $this->_as;
6275   }
6276   public function alias(): EditableSyntax {
6277     return $this->_alias;
6278   }
6279   public function with_clause_kind(EditableSyntax $clause_kind): NamespaceUseClause {
6280     return new NamespaceUseClause(
6281       $clause_kind,
6282       $this->_name,
6283       $this->_as,
6284       $this->_alias);
6285   }
6286   public function with_name(EditableSyntax $name): NamespaceUseClause {
6287     return new NamespaceUseClause(
6288       $this->_clause_kind,
6289       $name,
6290       $this->_as,
6291       $this->_alias);
6292   }
6293   public function with_as(EditableSyntax $as): NamespaceUseClause {
6294     return new NamespaceUseClause(
6295       $this->_clause_kind,
6296       $this->_name,
6297       $as,
6298       $this->_alias);
6299   }
6300   public function with_alias(EditableSyntax $alias): NamespaceUseClause {
6301     return new NamespaceUseClause(
6302       $this->_clause_kind,
6303       $this->_name,
6304       $this->_as,
6305       $alias);
6306   }
6307
6308   public function rewrite(
6309     ( function
6310       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
6311     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
6312     $new_parents = $parents ?? [];
6313     array_push($new_parents, $this);
6314     $clause_kind = $this->clause_kind()->rewrite($rewriter, $new_parents);
6315     $name = $this->name()->rewrite($rewriter, $new_parents);
6316     $as = $this->as()->rewrite($rewriter, $new_parents);
6317     $alias = $this->alias()->rewrite($rewriter, $new_parents);
6318     if (
6319       $clause_kind === $this->clause_kind() &&
6320       $name === $this->name() &&
6321       $as === $this->as() &&
6322       $alias === $this->alias()) {
6323       return $rewriter($this, $parents ?? []);
6324     } else {
6325       return $rewriter(new NamespaceUseClause(
6326         $clause_kind,
6327         $name,
6328         $as,
6329         $alias), $parents ?? []);
6330     }
6331   }
6332
6333   public static function from_json(mixed $json, int $position, string $source) {
6334     $clause_kind = EditableSyntax::from_json(
6335       $json->namespace_use_clause_kind, $position, $source);
6336     $position += $clause_kind->width();
6337     $name = EditableSyntax::from_json(
6338       $json->namespace_use_name, $position, $source);
6339     $position += $name->width();
6340     $as = EditableSyntax::from_json(
6341       $json->namespace_use_as, $position, $source);
6342     $position += $as->width();
6343     $alias = EditableSyntax::from_json(
6344       $json->namespace_use_alias, $position, $source);
6345     $position += $alias->width();
6346     return new NamespaceUseClause(
6347         $clause_kind,
6348         $name,
6349         $as,
6350         $alias);
6351   }
6352   public function children(): Generator<string, EditableSyntax, void> {
6353     yield $this->_clause_kind;
6354     yield $this->_name;
6355     yield $this->_as;
6356     yield $this->_alias;
6357     yield break;
6358   }
6359 }
6360 final class FunctionDeclaration extends EditableSyntax {
6361   private EditableSyntax $_attribute_spec;
6362   private EditableSyntax $_declaration_header;
6363   private EditableSyntax $_body;
6364   public function __construct(
6365     EditableSyntax $attribute_spec,
6366     EditableSyntax $declaration_header,
6367     EditableSyntax $body) {
6368     parent::__construct('function_declaration');
6369     $this->_attribute_spec = $attribute_spec;
6370     $this->_declaration_header = $declaration_header;
6371     $this->_body = $body;
6372   }
6373   public function attribute_spec(): EditableSyntax {
6374     return $this->_attribute_spec;
6375   }
6376   public function declaration_header(): EditableSyntax {
6377     return $this->_declaration_header;
6378   }
6379   public function body(): EditableSyntax {
6380     return $this->_body;
6381   }
6382   public function with_attribute_spec(EditableSyntax $attribute_spec): FunctionDeclaration {
6383     return new FunctionDeclaration(
6384       $attribute_spec,
6385       $this->_declaration_header,
6386       $this->_body);
6387   }
6388   public function with_declaration_header(EditableSyntax $declaration_header): FunctionDeclaration {
6389     return new FunctionDeclaration(
6390       $this->_attribute_spec,
6391       $declaration_header,
6392       $this->_body);
6393   }
6394   public function with_body(EditableSyntax $body): FunctionDeclaration {
6395     return new FunctionDeclaration(
6396       $this->_attribute_spec,
6397       $this->_declaration_header,
6398       $body);
6399   }
6400
6401   public function rewrite(
6402     ( function
6403       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
6404     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
6405     $new_parents = $parents ?? [];
6406     array_push($new_parents, $this);
6407     $attribute_spec = $this->attribute_spec()->rewrite($rewriter, $new_parents);
6408     $declaration_header = $this->declaration_header()->rewrite($rewriter, $new_parents);
6409     $body = $this->body()->rewrite($rewriter, $new_parents);
6410     if (
6411       $attribute_spec === $this->attribute_spec() &&
6412       $declaration_header === $this->declaration_header() &&
6413       $body === $this->body()) {
6414       return $rewriter($this, $parents ?? []);
6415     } else {
6416       return $rewriter(new FunctionDeclaration(
6417         $attribute_spec,
6418         $declaration_header,
6419         $body), $parents ?? []);
6420     }
6421   }
6422
6423   public static function from_json(mixed $json, int $position, string $source) {
6424     $attribute_spec = EditableSyntax::from_json(
6425       $json->function_attribute_spec, $position, $source);
6426     $position += $attribute_spec->width();
6427     $declaration_header = EditableSyntax::from_json(
6428       $json->function_declaration_header, $position, $source);
6429     $position += $declaration_header->width();
6430     $body = EditableSyntax::from_json(
6431       $json->function_body, $position, $source);
6432     $position += $body->width();
6433     return new FunctionDeclaration(
6434         $attribute_spec,
6435         $declaration_header,
6436         $body);
6437   }
6438   public function children(): Generator<string, EditableSyntax, void> {
6439     yield $this->_attribute_spec;
6440     yield $this->_declaration_header;
6441     yield $this->_body;
6442     yield break;
6443   }
6444 }
6445 final class FunctionDeclarationHeader extends EditableSyntax {
6446   private EditableSyntax $_modifiers;
6447   private EditableSyntax $_keyword;
6448   private EditableSyntax $_ampersand;
6449   private EditableSyntax $_name;
6450   private EditableSyntax $_type_parameter_list;
6451   private EditableSyntax $_left_paren;
6452   private EditableSyntax $_parameter_list;
6453   private EditableSyntax $_right_paren;
6454   private EditableSyntax $_colon;
6455   private EditableSyntax $_type;
6456   private EditableSyntax $_where_clause;
6457   public function __construct(
6458     EditableSyntax $modifiers,
6459     EditableSyntax $keyword,
6460     EditableSyntax $ampersand,
6461     EditableSyntax $name,
6462     EditableSyntax $type_parameter_list,
6463     EditableSyntax $left_paren,
6464     EditableSyntax $parameter_list,
6465     EditableSyntax $right_paren,
6466     EditableSyntax $colon,
6467     EditableSyntax $type,
6468     EditableSyntax $where_clause) {
6469     parent::__construct('function_declaration_header');
6470     $this->_modifiers = $modifiers;
6471     $this->_keyword = $keyword;
6472     $this->_ampersand = $ampersand;
6473     $this->_name = $name;
6474     $this->_type_parameter_list = $type_parameter_list;
6475     $this->_left_paren = $left_paren;
6476     $this->_parameter_list = $parameter_list;
6477     $this->_right_paren = $right_paren;
6478     $this->_colon = $colon;
6479     $this->_type = $type;
6480     $this->_where_clause = $where_clause;
6481   }
6482   public function modifiers(): EditableSyntax {
6483     return $this->_modifiers;
6484   }
6485   public function keyword(): EditableSyntax {
6486     return $this->_keyword;
6487   }
6488   public function ampersand(): EditableSyntax {
6489     return $this->_ampersand;
6490   }
6491   public function name(): EditableSyntax {
6492     return $this->_name;
6493   }
6494   public function type_parameter_list(): EditableSyntax {
6495     return $this->_type_parameter_list;
6496   }
6497   public function left_paren(): EditableSyntax {
6498     return $this->_left_paren;
6499   }
6500   public function parameter_list(): EditableSyntax {
6501     return $this->_parameter_list;
6502   }
6503   public function right_paren(): EditableSyntax {
6504     return $this->_right_paren;
6505   }
6506   public function colon(): EditableSyntax {
6507     return $this->_colon;
6508   }
6509   public function type(): EditableSyntax {
6510     return $this->_type;
6511   }
6512   public function where_clause(): EditableSyntax {
6513     return $this->_where_clause;
6514   }
6515   public function with_modifiers(EditableSyntax $modifiers): FunctionDeclarationHeader {
6516     return new FunctionDeclarationHeader(
6517       $modifiers,
6518       $this->_keyword,
6519       $this->_ampersand,
6520       $this->_name,
6521       $this->_type_parameter_list,
6522       $this->_left_paren,
6523       $this->_parameter_list,
6524       $this->_right_paren,
6525       $this->_colon,
6526       $this->_type,
6527       $this->_where_clause);
6528   }
6529   public function with_keyword(EditableSyntax $keyword): FunctionDeclarationHeader {
6530     return new FunctionDeclarationHeader(
6531       $this->_modifiers,
6532       $keyword,
6533       $this->_ampersand,
6534       $this->_name,
6535       $this->_type_parameter_list,
6536       $this->_left_paren,
6537       $this->_parameter_list,
6538       $this->_right_paren,
6539       $this->_colon,
6540       $this->_type,
6541       $this->_where_clause);
6542   }
6543   public function with_ampersand(EditableSyntax $ampersand): FunctionDeclarationHeader {
6544     return new FunctionDeclarationHeader(
6545       $this->_modifiers,
6546       $this->_keyword,
6547       $ampersand,
6548       $this->_name,
6549       $this->_type_parameter_list,
6550       $this->_left_paren,
6551       $this->_parameter_list,
6552       $this->_right_paren,
6553       $this->_colon,
6554       $this->_type,
6555       $this->_where_clause);
6556   }
6557   public function with_name(EditableSyntax $name): FunctionDeclarationHeader {
6558     return new FunctionDeclarationHeader(
6559       $this->_modifiers,
6560       $this->_keyword,
6561       $this->_ampersand,
6562       $name,
6563       $this->_type_parameter_list,
6564       $this->_left_paren,
6565       $this->_parameter_list,
6566       $this->_right_paren,
6567       $this->_colon,
6568       $this->_type,
6569       $this->_where_clause);
6570   }
6571   public function with_type_parameter_list(EditableSyntax $type_parameter_list): FunctionDeclarationHeader {
6572     return new FunctionDeclarationHeader(
6573       $this->_modifiers,
6574       $this->_keyword,
6575       $this->_ampersand,
6576       $this->_name,
6577       $type_parameter_list,
6578       $this->_left_paren,
6579       $this->_parameter_list,
6580       $this->_right_paren,
6581       $this->_colon,
6582       $this->_type,
6583       $this->_where_clause);
6584   }
6585   public function with_left_paren(EditableSyntax $left_paren): FunctionDeclarationHeader {
6586     return new FunctionDeclarationHeader(
6587       $this->_modifiers,
6588       $this->_keyword,
6589       $this->_ampersand,
6590       $this->_name,
6591       $this->_type_parameter_list,
6592       $left_paren,
6593       $this->_parameter_list,
6594       $this->_right_paren,
6595       $this->_colon,
6596       $this->_type,
6597       $this->_where_clause);
6598   }
6599   public function with_parameter_list(EditableSyntax $parameter_list): FunctionDeclarationHeader {
6600     return new FunctionDeclarationHeader(
6601       $this->_modifiers,
6602       $this->_keyword,
6603       $this->_ampersand,
6604       $this->_name,
6605       $this->_type_parameter_list,
6606       $this->_left_paren,
6607       $parameter_list,
6608       $this->_right_paren,
6609       $this->_colon,
6610       $this->_type,
6611       $this->_where_clause);
6612   }
6613   public function with_right_paren(EditableSyntax $right_paren): FunctionDeclarationHeader {
6614     return new FunctionDeclarationHeader(
6615       $this->_modifiers,
6616       $this->_keyword,
6617       $this->_ampersand,
6618       $this->_name,
6619       $this->_type_parameter_list,
6620       $this->_left_paren,
6621       $this->_parameter_list,
6622       $right_paren,
6623       $this->_colon,
6624       $this->_type,
6625       $this->_where_clause);
6626   }
6627   public function with_colon(EditableSyntax $colon): FunctionDeclarationHeader {
6628     return new FunctionDeclarationHeader(
6629       $this->_modifiers,
6630       $this->_keyword,
6631       $this->_ampersand,
6632       $this->_name,
6633       $this->_type_parameter_list,
6634       $this->_left_paren,
6635       $this->_parameter_list,
6636       $this->_right_paren,
6637       $colon,
6638       $this->_type,
6639       $this->_where_clause);
6640   }
6641   public function with_type(EditableSyntax $type): FunctionDeclarationHeader {
6642     return new FunctionDeclarationHeader(
6643       $this->_modifiers,
6644       $this->_keyword,
6645       $this->_ampersand,
6646       $this->_name,
6647       $this->_type_parameter_list,
6648       $this->_left_paren,
6649       $this->_parameter_list,
6650       $this->_right_paren,
6651       $this->_colon,
6652       $type,
6653       $this->_where_clause);
6654   }
6655   public function with_where_clause(EditableSyntax $where_clause): FunctionDeclarationHeader {
6656     return new FunctionDeclarationHeader(
6657       $this->_modifiers,
6658       $this->_keyword,
6659       $this->_ampersand,
6660       $this->_name,
6661       $this->_type_parameter_list,
6662       $this->_left_paren,
6663       $this->_parameter_list,
6664       $this->_right_paren,
6665       $this->_colon,
6666       $this->_type,
6667       $where_clause);
6668   }
6669
6670   public function rewrite(
6671     ( function
6672       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
6673     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
6674     $new_parents = $parents ?? [];
6675     array_push($new_parents, $this);
6676     $modifiers = $this->modifiers()->rewrite($rewriter, $new_parents);
6677     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
6678     $ampersand = $this->ampersand()->rewrite($rewriter, $new_parents);
6679     $name = $this->name()->rewrite($rewriter, $new_parents);
6680     $type_parameter_list = $this->type_parameter_list()->rewrite($rewriter, $new_parents);
6681     $left_paren = $this->left_paren()->rewrite($rewriter, $new_parents);
6682     $parameter_list = $this->parameter_list()->rewrite($rewriter, $new_parents);
6683     $right_paren = $this->right_paren()->rewrite($rewriter, $new_parents);
6684     $colon = $this->colon()->rewrite($rewriter, $new_parents);
6685     $type = $this->type()->rewrite($rewriter, $new_parents);
6686     $where_clause = $this->where_clause()->rewrite($rewriter, $new_parents);
6687     if (
6688       $modifiers === $this->modifiers() &&
6689       $keyword === $this->keyword() &&
6690       $ampersand === $this->ampersand() &&
6691       $name === $this->name() &&
6692       $type_parameter_list === $this->type_parameter_list() &&
6693       $left_paren === $this->left_paren() &&
6694       $parameter_list === $this->parameter_list() &&
6695       $right_paren === $this->right_paren() &&
6696       $colon === $this->colon() &&
6697       $type === $this->type() &&
6698       $where_clause === $this->where_clause()) {
6699       return $rewriter($this, $parents ?? []);
6700     } else {
6701       return $rewriter(new FunctionDeclarationHeader(
6702         $modifiers,
6703         $keyword,
6704         $ampersand,
6705         $name,
6706         $type_parameter_list,
6707         $left_paren,
6708         $parameter_list,
6709         $right_paren,
6710         $colon,
6711         $type,
6712         $where_clause), $parents ?? []);
6713     }
6714   }
6715
6716   public static function from_json(mixed $json, int $position, string $source) {
6717     $modifiers = EditableSyntax::from_json(
6718       $json->function_modifiers, $position, $source);
6719     $position += $modifiers->width();
6720     $keyword = EditableSyntax::from_json(
6721       $json->function_keyword, $position, $source);
6722     $position += $keyword->width();
6723     $ampersand = EditableSyntax::from_json(
6724       $json->function_ampersand, $position, $source);
6725     $position += $ampersand->width();
6726     $name = EditableSyntax::from_json(
6727       $json->function_name, $position, $source);
6728     $position += $name->width();
6729     $type_parameter_list = EditableSyntax::from_json(
6730       $json->function_type_parameter_list, $position, $source);
6731     $position += $type_parameter_list->width();
6732     $left_paren = EditableSyntax::from_json(
6733       $json->function_left_paren, $position, $source);
6734     $position += $left_paren->width();
6735     $parameter_list = EditableSyntax::from_json(
6736       $json->function_parameter_list, $position, $source);
6737     $position += $parameter_list->width();
6738     $right_paren = EditableSyntax::from_json(
6739       $json->function_right_paren, $position, $source);
6740     $position += $right_paren->width();
6741     $colon = EditableSyntax::from_json(
6742       $json->function_colon, $position, $source);
6743     $position += $colon->width();
6744     $type = EditableSyntax::from_json(
6745       $json->function_type, $position, $source);
6746     $position += $type->width();
6747     $where_clause = EditableSyntax::from_json(
6748       $json->function_where_clause, $position, $source);
6749     $position += $where_clause->width();
6750     return new FunctionDeclarationHeader(
6751         $modifiers,
6752         $keyword,
6753         $ampersand,
6754         $name,
6755         $type_parameter_list,
6756         $left_paren,
6757         $parameter_list,
6758         $right_paren,
6759         $colon,
6760         $type,
6761         $where_clause);
6762   }
6763   public function children(): Generator<string, EditableSyntax, void> {
6764     yield $this->_modifiers;
6765     yield $this->_keyword;
6766     yield $this->_ampersand;
6767     yield $this->_name;
6768     yield $this->_type_parameter_list;
6769     yield $this->_left_paren;
6770     yield $this->_parameter_list;
6771     yield $this->_right_paren;
6772     yield $this->_colon;
6773     yield $this->_type;
6774     yield $this->_where_clause;
6775     yield break;
6776   }
6777 }
6778 final class WhereClause extends EditableSyntax {
6779   private EditableSyntax $_keyword;
6780   private EditableSyntax $_constraints;
6781   public function __construct(
6782     EditableSyntax $keyword,
6783     EditableSyntax $constraints) {
6784     parent::__construct('where_clause');
6785     $this->_keyword = $keyword;
6786     $this->_constraints = $constraints;
6787   }
6788   public function keyword(): EditableSyntax {
6789     return $this->_keyword;
6790   }
6791   public function constraints(): EditableSyntax {
6792     return $this->_constraints;
6793   }
6794   public function with_keyword(EditableSyntax $keyword): WhereClause {
6795     return new WhereClause(
6796       $keyword,
6797       $this->_constraints);
6798   }
6799   public function with_constraints(EditableSyntax $constraints): WhereClause {
6800     return new WhereClause(
6801       $this->_keyword,
6802       $constraints);
6803   }
6804
6805   public function rewrite(
6806     ( function
6807       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
6808     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
6809     $new_parents = $parents ?? [];
6810     array_push($new_parents, $this);
6811     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
6812     $constraints = $this->constraints()->rewrite($rewriter, $new_parents);
6813     if (
6814       $keyword === $this->keyword() &&
6815       $constraints === $this->constraints()) {
6816       return $rewriter($this, $parents ?? []);
6817     } else {
6818       return $rewriter(new WhereClause(
6819         $keyword,
6820         $constraints), $parents ?? []);
6821     }
6822   }
6823
6824   public static function from_json(mixed $json, int $position, string $source) {
6825     $keyword = EditableSyntax::from_json(
6826       $json->where_clause_keyword, $position, $source);
6827     $position += $keyword->width();
6828     $constraints = EditableSyntax::from_json(
6829       $json->where_clause_constraints, $position, $source);
6830     $position += $constraints->width();
6831     return new WhereClause(
6832         $keyword,
6833         $constraints);
6834   }
6835   public function children(): Generator<string, EditableSyntax, void> {
6836     yield $this->_keyword;
6837     yield $this->_constraints;
6838     yield break;
6839   }
6840 }
6841 final class WhereConstraint extends EditableSyntax {
6842   private EditableSyntax $_left_type;
6843   private EditableSyntax $_operator;
6844   private EditableSyntax $_right_type;
6845   public function __construct(
6846     EditableSyntax $left_type,
6847     EditableSyntax $operator,
6848     EditableSyntax $right_type) {
6849     parent::__construct('where_constraint');
6850     $this->_left_type = $left_type;
6851     $this->_operator = $operator;
6852     $this->_right_type = $right_type;
6853   }
6854   public function left_type(): EditableSyntax {
6855     return $this->_left_type;
6856   }
6857   public function operator(): EditableSyntax {
6858     return $this->_operator;
6859   }
6860   public function right_type(): EditableSyntax {
6861     return $this->_right_type;
6862   }
6863   public function with_left_type(EditableSyntax $left_type): WhereConstraint {
6864     return new WhereConstraint(
6865       $left_type,
6866       $this->_operator,
6867       $this->_right_type);
6868   }
6869   public function with_operator(EditableSyntax $operator): WhereConstraint {
6870     return new WhereConstraint(
6871       $this->_left_type,
6872       $operator,
6873       $this->_right_type);
6874   }
6875   public function with_right_type(EditableSyntax $right_type): WhereConstraint {
6876     return new WhereConstraint(
6877       $this->_left_type,
6878       $this->_operator,
6879       $right_type);
6880   }
6881
6882   public function rewrite(
6883     ( function
6884       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
6885     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
6886     $new_parents = $parents ?? [];
6887     array_push($new_parents, $this);
6888     $left_type = $this->left_type()->rewrite($rewriter, $new_parents);
6889     $operator = $this->operator()->rewrite($rewriter, $new_parents);
6890     $right_type = $this->right_type()->rewrite($rewriter, $new_parents);
6891     if (
6892       $left_type === $this->left_type() &&
6893       $operator === $this->operator() &&
6894       $right_type === $this->right_type()) {
6895       return $rewriter($this, $parents ?? []);
6896     } else {
6897       return $rewriter(new WhereConstraint(
6898         $left_type,
6899         $operator,
6900         $right_type), $parents ?? []);
6901     }
6902   }
6903
6904   public static function from_json(mixed $json, int $position, string $source) {
6905     $left_type = EditableSyntax::from_json(
6906       $json->where_constraint_left_type, $position, $source);
6907     $position += $left_type->width();
6908     $operator = EditableSyntax::from_json(
6909       $json->where_constraint_operator, $position, $source);
6910     $position += $operator->width();
6911     $right_type = EditableSyntax::from_json(
6912       $json->where_constraint_right_type, $position, $source);
6913     $position += $right_type->width();
6914     return new WhereConstraint(
6915         $left_type,
6916         $operator,
6917         $right_type);
6918   }
6919   public function children(): Generator<string, EditableSyntax, void> {
6920     yield $this->_left_type;
6921     yield $this->_operator;
6922     yield $this->_right_type;
6923     yield break;
6924   }
6925 }
6926 final class MethodishDeclaration extends EditableSyntax {
6927   private EditableSyntax $_attribute;
6928   private EditableSyntax $_function_decl_header;
6929   private EditableSyntax $_function_body;
6930   private EditableSyntax $_semicolon;
6931   public function __construct(
6932     EditableSyntax $attribute,
6933     EditableSyntax $function_decl_header,
6934     EditableSyntax $function_body,
6935     EditableSyntax $semicolon) {
6936     parent::__construct('methodish_declaration');
6937     $this->_attribute = $attribute;
6938     $this->_function_decl_header = $function_decl_header;
6939     $this->_function_body = $function_body;
6940     $this->_semicolon = $semicolon;
6941   }
6942   public function attribute(): EditableSyntax {
6943     return $this->_attribute;
6944   }
6945   public function function_decl_header(): EditableSyntax {
6946     return $this->_function_decl_header;
6947   }
6948   public function function_body(): EditableSyntax {
6949     return $this->_function_body;
6950   }
6951   public function semicolon(): EditableSyntax {
6952     return $this->_semicolon;
6953   }
6954   public function with_attribute(EditableSyntax $attribute): MethodishDeclaration {
6955     return new MethodishDeclaration(
6956       $attribute,
6957       $this->_function_decl_header,
6958       $this->_function_body,
6959       $this->_semicolon);
6960   }
6961   public function with_function_decl_header(EditableSyntax $function_decl_header): MethodishDeclaration {
6962     return new MethodishDeclaration(
6963       $this->_attribute,
6964       $function_decl_header,
6965       $this->_function_body,
6966       $this->_semicolon);
6967   }
6968   public function with_function_body(EditableSyntax $function_body): MethodishDeclaration {
6969     return new MethodishDeclaration(
6970       $this->_attribute,
6971       $this->_function_decl_header,
6972       $function_body,
6973       $this->_semicolon);
6974   }
6975   public function with_semicolon(EditableSyntax $semicolon): MethodishDeclaration {
6976     return new MethodishDeclaration(
6977       $this->_attribute,
6978       $this->_function_decl_header,
6979       $this->_function_body,
6980       $semicolon);
6981   }
6982
6983   public function rewrite(
6984     ( function
6985       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
6986     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
6987     $new_parents = $parents ?? [];
6988     array_push($new_parents, $this);
6989     $attribute = $this->attribute()->rewrite($rewriter, $new_parents);
6990     $function_decl_header = $this->function_decl_header()->rewrite($rewriter, $new_parents);
6991     $function_body = $this->function_body()->rewrite($rewriter, $new_parents);
6992     $semicolon = $this->semicolon()->rewrite($rewriter, $new_parents);
6993     if (
6994       $attribute === $this->attribute() &&
6995       $function_decl_header === $this->function_decl_header() &&
6996       $function_body === $this->function_body() &&
6997       $semicolon === $this->semicolon()) {
6998       return $rewriter($this, $parents ?? []);
6999     } else {
7000       return $rewriter(new MethodishDeclaration(
7001         $attribute,
7002         $function_decl_header,
7003         $function_body,
7004         $semicolon), $parents ?? []);
7005     }
7006   }
7007
7008   public static function from_json(mixed $json, int $position, string $source) {
7009     $attribute = EditableSyntax::from_json(
7010       $json->methodish_attribute, $position, $source);
7011     $position += $attribute->width();
7012     $function_decl_header = EditableSyntax::from_json(
7013       $json->methodish_function_decl_header, $position, $source);
7014     $position += $function_decl_header->width();
7015     $function_body = EditableSyntax::from_json(
7016       $json->methodish_function_body, $position, $source);
7017     $position += $function_body->width();
7018     $semicolon = EditableSyntax::from_json(
7019       $json->methodish_semicolon, $position, $source);
7020     $position += $semicolon->width();
7021     return new MethodishDeclaration(
7022         $attribute,
7023         $function_decl_header,
7024         $function_body,
7025         $semicolon);
7026   }
7027   public function children(): Generator<string, EditableSyntax, void> {
7028     yield $this->_attribute;
7029     yield $this->_function_decl_header;
7030     yield $this->_function_body;
7031     yield $this->_semicolon;
7032     yield break;
7033   }
7034 }
7035 final class ClassishDeclaration extends EditableSyntax {
7036   private EditableSyntax $_attribute;
7037   private EditableSyntax $_modifiers;
7038   private EditableSyntax $_keyword;
7039   private EditableSyntax $_name;
7040   private EditableSyntax $_type_parameters;
7041   private EditableSyntax $_extends_keyword;
7042   private EditableSyntax $_extends_list;
7043   private EditableSyntax $_implements_keyword;
7044   private EditableSyntax $_implements_list;
7045   private EditableSyntax $_body;
7046   public function __construct(
7047     EditableSyntax $attribute,
7048     EditableSyntax $modifiers,
7049     EditableSyntax $keyword,
7050     EditableSyntax $name,
7051     EditableSyntax $type_parameters,
7052     EditableSyntax $extends_keyword,
7053     EditableSyntax $extends_list,
7054     EditableSyntax $implements_keyword,
7055     EditableSyntax $implements_list,
7056     EditableSyntax $body) {
7057     parent::__construct('classish_declaration');
7058     $this->_attribute = $attribute;
7059     $this->_modifiers = $modifiers;
7060     $this->_keyword = $keyword;
7061     $this->_name = $name;
7062     $this->_type_parameters = $type_parameters;
7063     $this->_extends_keyword = $extends_keyword;
7064     $this->_extends_list = $extends_list;
7065     $this->_implements_keyword = $implements_keyword;
7066     $this->_implements_list = $implements_list;
7067     $this->_body = $body;
7068   }
7069   public function attribute(): EditableSyntax {
7070     return $this->_attribute;
7071   }
7072   public function modifiers(): EditableSyntax {
7073     return $this->_modifiers;
7074   }
7075   public function keyword(): EditableSyntax {
7076     return $this->_keyword;
7077   }
7078   public function name(): EditableSyntax {
7079     return $this->_name;
7080   }
7081   public function type_parameters(): EditableSyntax {
7082     return $this->_type_parameters;
7083   }
7084   public function extends_keyword(): EditableSyntax {
7085     return $this->_extends_keyword;
7086   }
7087   public function extends_list(): EditableSyntax {
7088     return $this->_extends_list;
7089   }
7090   public function implements_keyword(): EditableSyntax {
7091     return $this->_implements_keyword;
7092   }
7093   public function implements_list(): EditableSyntax {
7094     return $this->_implements_list;
7095   }
7096   public function body(): EditableSyntax {
7097     return $this->_body;
7098   }
7099   public function with_attribute(EditableSyntax $attribute): ClassishDeclaration {
7100     return new ClassishDeclaration(
7101       $attribute,
7102       $this->_modifiers,
7103       $this->_keyword,
7104       $this->_name,
7105       $this->_type_parameters,
7106       $this->_extends_keyword,
7107       $this->_extends_list,
7108       $this->_implements_keyword,
7109       $this->_implements_list,
7110       $this->_body);
7111   }
7112   public function with_modifiers(EditableSyntax $modifiers): ClassishDeclaration {
7113     return new ClassishDeclaration(
7114       $this->_attribute,
7115       $modifiers,
7116       $this->_keyword,
7117       $this->_name,
7118       $this->_type_parameters,
7119       $this->_extends_keyword,
7120       $this->_extends_list,
7121       $this->_implements_keyword,
7122       $this->_implements_list,
7123       $this->_body);
7124   }
7125   public function with_keyword(EditableSyntax $keyword): ClassishDeclaration {
7126     return new ClassishDeclaration(
7127       $this->_attribute,
7128       $this->_modifiers,
7129       $keyword,
7130       $this->_name,
7131       $this->_type_parameters,
7132       $this->_extends_keyword,
7133       $this->_extends_list,
7134       $this->_implements_keyword,
7135       $this->_implements_list,
7136       $this->_body);
7137   }
7138   public function with_name(EditableSyntax $name): ClassishDeclaration {
7139     return new ClassishDeclaration(
7140       $this->_attribute,
7141       $this->_modifiers,
7142       $this->_keyword,
7143       $name,
7144       $this->_type_parameters,
7145       $this->_extends_keyword,
7146       $this->_extends_list,
7147       $this->_implements_keyword,
7148       $this->_implements_list,
7149       $this->_body);
7150   }
7151   public function with_type_parameters(EditableSyntax $type_parameters): ClassishDeclaration {
7152     return new ClassishDeclaration(
7153       $this->_attribute,
7154       $this->_modifiers,
7155       $this->_keyword,
7156       $this->_name,
7157       $type_parameters,
7158       $this->_extends_keyword,
7159       $this->_extends_list,
7160       $this->_implements_keyword,
7161       $this->_implements_list,
7162       $this->_body);
7163   }
7164   public function with_extends_keyword(EditableSyntax $extends_keyword): ClassishDeclaration {
7165     return new ClassishDeclaration(
7166       $this->_attribute,
7167       $this->_modifiers,
7168       $this->_keyword,
7169       $this->_name,
7170       $this->_type_parameters,
7171       $extends_keyword,
7172       $this->_extends_list,
7173       $this->_implements_keyword,
7174       $this->_implements_list,
7175       $this->_body);
7176   }
7177   public function with_extends_list(EditableSyntax $extends_list): ClassishDeclaration {
7178     return new ClassishDeclaration(
7179       $this->_attribute,
7180       $this->_modifiers,
7181       $this->_keyword,
7182       $this->_name,
7183       $this->_type_parameters,
7184       $this->_extends_keyword,
7185       $extends_list,
7186       $this->_implements_keyword,
7187       $this->_implements_list,
7188       $this->_body);
7189   }
7190   public function with_implements_keyword(EditableSyntax $implements_keyword): ClassishDeclaration {
7191     return new ClassishDeclaration(
7192       $this->_attribute,
7193       $this->_modifiers,
7194       $this->_keyword,
7195       $this->_name,
7196       $this->_type_parameters,
7197       $this->_extends_keyword,
7198       $this->_extends_list,
7199       $implements_keyword,
7200       $this->_implements_list,
7201       $this->_body);
7202   }
7203   public function with_implements_list(EditableSyntax $implements_list): ClassishDeclaration {
7204     return new ClassishDeclaration(
7205       $this->_attribute,
7206       $this->_modifiers,
7207       $this->_keyword,
7208       $this->_name,
7209       $this->_type_parameters,
7210       $this->_extends_keyword,
7211       $this->_extends_list,
7212       $this->_implements_keyword,
7213       $implements_list,
7214       $this->_body);
7215   }
7216   public function with_body(EditableSyntax $body): ClassishDeclaration {
7217     return new ClassishDeclaration(
7218       $this->_attribute,
7219       $this->_modifiers,
7220       $this->_keyword,
7221       $this->_name,
7222       $this->_type_parameters,
7223       $this->_extends_keyword,
7224       $this->_extends_list,
7225       $this->_implements_keyword,
7226       $this->_implements_list,
7227       $body);
7228   }
7229
7230   public function rewrite(
7231     ( function
7232       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
7233     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
7234     $new_parents = $parents ?? [];
7235     array_push($new_parents, $this);
7236     $attribute = $this->attribute()->rewrite($rewriter, $new_parents);
7237     $modifiers = $this->modifiers()->rewrite($rewriter, $new_parents);
7238     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
7239     $name = $this->name()->rewrite($rewriter, $new_parents);
7240     $type_parameters = $this->type_parameters()->rewrite($rewriter, $new_parents);
7241     $extends_keyword = $this->extends_keyword()->rewrite($rewriter, $new_parents);
7242     $extends_list = $this->extends_list()->rewrite($rewriter, $new_parents);
7243     $implements_keyword = $this->implements_keyword()->rewrite($rewriter, $new_parents);
7244     $implements_list = $this->implements_list()->rewrite($rewriter, $new_parents);
7245     $body = $this->body()->rewrite($rewriter, $new_parents);
7246     if (
7247       $attribute === $this->attribute() &&
7248       $modifiers === $this->modifiers() &&
7249       $keyword === $this->keyword() &&
7250       $name === $this->name() &&
7251       $type_parameters === $this->type_parameters() &&
7252       $extends_keyword === $this->extends_keyword() &&
7253       $extends_list === $this->extends_list() &&
7254       $implements_keyword === $this->implements_keyword() &&
7255       $implements_list === $this->implements_list() &&
7256       $body === $this->body()) {
7257       return $rewriter($this, $parents ?? []);
7258     } else {
7259       return $rewriter(new ClassishDeclaration(
7260         $attribute,
7261         $modifiers,
7262         $keyword,
7263         $name,
7264         $type_parameters,
7265         $extends_keyword,
7266         $extends_list,
7267         $implements_keyword,
7268         $implements_list,
7269         $body), $parents ?? []);
7270     }
7271   }
7272
7273   public static function from_json(mixed $json, int $position, string $source) {
7274     $attribute = EditableSyntax::from_json(
7275       $json->classish_attribute, $position, $source);
7276     $position += $attribute->width();
7277     $modifiers = EditableSyntax::from_json(
7278       $json->classish_modifiers, $position, $source);
7279     $position += $modifiers->width();
7280     $keyword = EditableSyntax::from_json(
7281       $json->classish_keyword, $position, $source);
7282     $position += $keyword->width();
7283     $name = EditableSyntax::from_json(
7284       $json->classish_name, $position, $source);
7285     $position += $name->width();
7286     $type_parameters = EditableSyntax::from_json(
7287       $json->classish_type_parameters, $position, $source);
7288     $position += $type_parameters->width();
7289     $extends_keyword = EditableSyntax::from_json(
7290       $json->classish_extends_keyword, $position, $source);
7291     $position += $extends_keyword->width();
7292     $extends_list = EditableSyntax::from_json(
7293       $json->classish_extends_list, $position, $source);
7294     $position += $extends_list->width();
7295     $implements_keyword = EditableSyntax::from_json(
7296       $json->classish_implements_keyword, $position, $source);
7297     $position += $implements_keyword->width();
7298     $implements_list = EditableSyntax::from_json(
7299       $json->classish_implements_list, $position, $source);
7300     $position += $implements_list->width();
7301     $body = EditableSyntax::from_json(
7302       $json->classish_body, $position, $source);
7303     $position += $body->width();
7304     return new ClassishDeclaration(
7305         $attribute,
7306         $modifiers,
7307         $keyword,
7308         $name,
7309         $type_parameters,
7310         $extends_keyword,
7311         $extends_list,
7312         $implements_keyword,
7313         $implements_list,
7314         $body);
7315   }
7316   public function children(): Generator<string, EditableSyntax, void> {
7317     yield $this->_attribute;
7318     yield $this->_modifiers;
7319     yield $this->_keyword;
7320     yield $this->_name;
7321     yield $this->_type_parameters;
7322     yield $this->_extends_keyword;
7323     yield $this->_extends_list;
7324     yield $this->_implements_keyword;
7325     yield $this->_implements_list;
7326     yield $this->_body;
7327     yield break;
7328   }
7329 }
7330 final class ClassishBody extends EditableSyntax {
7331   private EditableSyntax $_left_brace;
7332   private EditableSyntax $_elements;
7333   private EditableSyntax $_right_brace;
7334   public function __construct(
7335     EditableSyntax $left_brace,
7336     EditableSyntax $elements,
7337     EditableSyntax $right_brace) {
7338     parent::__construct('classish_body');
7339     $this->_left_brace = $left_brace;
7340     $this->_elements = $elements;
7341     $this->_right_brace = $right_brace;
7342   }
7343   public function left_brace(): EditableSyntax {
7344     return $this->_left_brace;
7345   }
7346   public function elements(): EditableSyntax {
7347     return $this->_elements;
7348   }
7349   public function right_brace(): EditableSyntax {
7350     return $this->_right_brace;
7351   }
7352   public function with_left_brace(EditableSyntax $left_brace): ClassishBody {
7353     return new ClassishBody(
7354       $left_brace,
7355       $this->_elements,
7356       $this->_right_brace);
7357   }
7358   public function with_elements(EditableSyntax $elements): ClassishBody {
7359     return new ClassishBody(
7360       $this->_left_brace,
7361       $elements,
7362       $this->_right_brace);
7363   }
7364   public function with_right_brace(EditableSyntax $right_brace): ClassishBody {
7365     return new ClassishBody(
7366       $this->_left_brace,
7367       $this->_elements,
7368       $right_brace);
7369   }
7370
7371   public function rewrite(
7372     ( function
7373       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
7374     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
7375     $new_parents = $parents ?? [];
7376     array_push($new_parents, $this);
7377     $left_brace = $this->left_brace()->rewrite($rewriter, $new_parents);
7378     $elements = $this->elements()->rewrite($rewriter, $new_parents);
7379     $right_brace = $this->right_brace()->rewrite($rewriter, $new_parents);
7380     if (
7381       $left_brace === $this->left_brace() &&
7382       $elements === $this->elements() &&
7383       $right_brace === $this->right_brace()) {
7384       return $rewriter($this, $parents ?? []);
7385     } else {
7386       return $rewriter(new ClassishBody(
7387         $left_brace,
7388         $elements,
7389         $right_brace), $parents ?? []);
7390     }
7391   }
7392
7393   public static function from_json(mixed $json, int $position, string $source) {
7394     $left_brace = EditableSyntax::from_json(
7395       $json->classish_body_left_brace, $position, $source);
7396     $position += $left_brace->width();
7397     $elements = EditableSyntax::from_json(
7398       $json->classish_body_elements, $position, $source);
7399     $position += $elements->width();
7400     $right_brace = EditableSyntax::from_json(
7401       $json->classish_body_right_brace, $position, $source);
7402     $position += $right_brace->width();
7403     return new ClassishBody(
7404         $left_brace,
7405         $elements,
7406         $right_brace);
7407   }
7408   public function children(): Generator<string, EditableSyntax, void> {
7409     yield $this->_left_brace;
7410     yield $this->_elements;
7411     yield $this->_right_brace;
7412     yield break;
7413   }
7414 }
7415 final class TraitUsePrecedenceItem extends EditableSyntax {
7416   private EditableSyntax $_name;
7417   private EditableSyntax $_keyword;
7418   private EditableSyntax $_removed_names;
7419   public function __construct(
7420     EditableSyntax $name,
7421     EditableSyntax $keyword,
7422     EditableSyntax $removed_names) {
7423     parent::__construct('trait_use_precedence_item');
7424     $this->_name = $name;
7425     $this->_keyword = $keyword;
7426     $this->_removed_names = $removed_names;
7427   }
7428   public function name(): EditableSyntax {
7429     return $this->_name;
7430   }
7431   public function keyword(): EditableSyntax {
7432     return $this->_keyword;
7433   }
7434   public function removed_names(): EditableSyntax {
7435     return $this->_removed_names;
7436   }
7437   public function with_name(EditableSyntax $name): TraitUsePrecedenceItem {
7438     return new TraitUsePrecedenceItem(
7439       $name,
7440       $this->_keyword,
7441       $this->_removed_names);
7442   }
7443   public function with_keyword(EditableSyntax $keyword): TraitUsePrecedenceItem {
7444     return new TraitUsePrecedenceItem(
7445       $this->_name,
7446       $keyword,
7447       $this->_removed_names);
7448   }
7449   public function with_removed_names(EditableSyntax $removed_names): TraitUsePrecedenceItem {
7450     return new TraitUsePrecedenceItem(
7451       $this->_name,
7452       $this->_keyword,
7453       $removed_names);
7454   }
7455
7456   public function rewrite(
7457     ( function
7458       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
7459     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
7460     $new_parents = $parents ?? [];
7461     array_push($new_parents, $this);
7462     $name = $this->name()->rewrite($rewriter, $new_parents);
7463     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
7464     $removed_names = $this->removed_names()->rewrite($rewriter, $new_parents);
7465     if (
7466       $name === $this->name() &&
7467       $keyword === $this->keyword() &&
7468       $removed_names === $this->removed_names()) {
7469       return $rewriter($this, $parents ?? []);
7470     } else {
7471       return $rewriter(new TraitUsePrecedenceItem(
7472         $name,
7473         $keyword,
7474         $removed_names), $parents ?? []);
7475     }
7476   }
7477
7478   public static function from_json(mixed $json, int $position, string $source) {
7479     $name = EditableSyntax::from_json(
7480       $json->trait_use_precedence_item_name, $position, $source);
7481     $position += $name->width();
7482     $keyword = EditableSyntax::from_json(
7483       $json->trait_use_precedence_item_keyword, $position, $source);
7484     $position += $keyword->width();
7485     $removed_names = EditableSyntax::from_json(
7486       $json->trait_use_precedence_item_removed_names, $position, $source);
7487     $position += $removed_names->width();
7488     return new TraitUsePrecedenceItem(
7489         $name,
7490         $keyword,
7491         $removed_names);
7492   }
7493   public function children(): Generator<string, EditableSyntax, void> {
7494     yield $this->_name;
7495     yield $this->_keyword;
7496     yield $this->_removed_names;
7497     yield break;
7498   }
7499 }
7500 final class TraitUseAliasItem extends EditableSyntax {
7501   private EditableSyntax $_aliasing_name;
7502   private EditableSyntax $_keyword;
7503   private EditableSyntax $_modifiers;
7504   private EditableSyntax $_aliased_name;
7505   public function __construct(
7506     EditableSyntax $aliasing_name,
7507     EditableSyntax $keyword,
7508     EditableSyntax $modifiers,
7509     EditableSyntax $aliased_name) {
7510     parent::__construct('trait_use_alias_item');
7511     $this->_aliasing_name = $aliasing_name;
7512     $this->_keyword = $keyword;
7513     $this->_modifiers = $modifiers;
7514     $this->_aliased_name = $aliased_name;
7515   }
7516   public function aliasing_name(): EditableSyntax {
7517     return $this->_aliasing_name;
7518   }
7519   public function keyword(): EditableSyntax {
7520     return $this->_keyword;
7521   }
7522   public function modifiers(): EditableSyntax {
7523     return $this->_modifiers;
7524   }
7525   public function aliased_name(): EditableSyntax {
7526     return $this->_aliased_name;
7527   }
7528   public function with_aliasing_name(EditableSyntax $aliasing_name): TraitUseAliasItem {
7529     return new TraitUseAliasItem(
7530       $aliasing_name,
7531       $this->_keyword,
7532       $this->_modifiers,
7533       $this->_aliased_name);
7534   }
7535   public function with_keyword(EditableSyntax $keyword): TraitUseAliasItem {
7536     return new TraitUseAliasItem(
7537       $this->_aliasing_name,
7538       $keyword,
7539       $this->_modifiers,
7540       $this->_aliased_name);
7541   }
7542   public function with_modifiers(EditableSyntax $modifiers): TraitUseAliasItem {
7543     return new TraitUseAliasItem(
7544       $this->_aliasing_name,
7545       $this->_keyword,
7546       $modifiers,
7547       $this->_aliased_name);
7548   }
7549   public function with_aliased_name(EditableSyntax $aliased_name): TraitUseAliasItem {
7550     return new TraitUseAliasItem(
7551       $this->_aliasing_name,
7552       $this->_keyword,
7553       $this->_modifiers,
7554       $aliased_name);
7555   }
7556
7557   public function rewrite(
7558     ( function
7559       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
7560     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
7561     $new_parents = $parents ?? [];
7562     array_push($new_parents, $this);
7563     $aliasing_name = $this->aliasing_name()->rewrite($rewriter, $new_parents);
7564     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
7565     $modifiers = $this->modifiers()->rewrite($rewriter, $new_parents);
7566     $aliased_name = $this->aliased_name()->rewrite($rewriter, $new_parents);
7567     if (
7568       $aliasing_name === $this->aliasing_name() &&
7569       $keyword === $this->keyword() &&
7570       $modifiers === $this->modifiers() &&
7571       $aliased_name === $this->aliased_name()) {
7572       return $rewriter($this, $parents ?? []);
7573     } else {
7574       return $rewriter(new TraitUseAliasItem(
7575         $aliasing_name,
7576         $keyword,
7577         $modifiers,
7578         $aliased_name), $parents ?? []);
7579     }
7580   }
7581
7582   public static function from_json(mixed $json, int $position, string $source) {
7583     $aliasing_name = EditableSyntax::from_json(
7584       $json->trait_use_alias_item_aliasing_name, $position, $source);
7585     $position += $aliasing_name->width();
7586     $keyword = EditableSyntax::from_json(
7587       $json->trait_use_alias_item_keyword, $position, $source);
7588     $position += $keyword->width();
7589     $modifiers = EditableSyntax::from_json(
7590       $json->trait_use_alias_item_modifiers, $position, $source);
7591     $position += $modifiers->width();
7592     $aliased_name = EditableSyntax::from_json(
7593       $json->trait_use_alias_item_aliased_name, $position, $source);
7594     $position += $aliased_name->width();
7595     return new TraitUseAliasItem(
7596         $aliasing_name,
7597         $keyword,
7598         $modifiers,
7599         $aliased_name);
7600   }
7601   public function children(): Generator<string, EditableSyntax, void> {
7602     yield $this->_aliasing_name;
7603     yield $this->_keyword;
7604     yield $this->_modifiers;
7605     yield $this->_aliased_name;
7606     yield break;
7607   }
7608 }
7609 final class TraitUseConflictResolution extends EditableSyntax {
7610   private EditableSyntax $_keyword;
7611   private EditableSyntax $_names;
7612   private EditableSyntax $_left_brace;
7613   private EditableSyntax $_clauses;
7614   private EditableSyntax $_right_brace;
7615   public function __construct(
7616     EditableSyntax $keyword,
7617     EditableSyntax $names,
7618     EditableSyntax $left_brace,
7619     EditableSyntax $clauses,
7620     EditableSyntax $right_brace) {
7621     parent::__construct('trait_use_conflict_resolution');
7622     $this->_keyword = $keyword;
7623     $this->_names = $names;
7624     $this->_left_brace = $left_brace;
7625     $this->_clauses = $clauses;
7626     $this->_right_brace = $right_brace;
7627   }
7628   public function keyword(): EditableSyntax {
7629     return $this->_keyword;
7630   }
7631   public function names(): EditableSyntax {
7632     return $this->_names;
7633   }
7634   public function left_brace(): EditableSyntax {
7635     return $this->_left_brace;
7636   }
7637   public function clauses(): EditableSyntax {
7638     return $this->_clauses;
7639   }
7640   public function right_brace(): EditableSyntax {
7641     return $this->_right_brace;
7642   }
7643   public function with_keyword(EditableSyntax $keyword): TraitUseConflictResolution {
7644     return new TraitUseConflictResolution(
7645       $keyword,
7646       $this->_names,
7647       $this->_left_brace,
7648       $this->_clauses,
7649       $this->_right_brace);
7650   }
7651   public function with_names(EditableSyntax $names): TraitUseConflictResolution {
7652     return new TraitUseConflictResolution(
7653       $this->_keyword,
7654       $names,
7655       $this->_left_brace,
7656       $this->_clauses,
7657       $this->_right_brace);
7658   }
7659   public function with_left_brace(EditableSyntax $left_brace): TraitUseConflictResolution {
7660     return new TraitUseConflictResolution(
7661       $this->_keyword,
7662       $this->_names,
7663       $left_brace,
7664       $this->_clauses,
7665       $this->_right_brace);
7666   }
7667   public function with_clauses(EditableSyntax $clauses): TraitUseConflictResolution {
7668     return new TraitUseConflictResolution(
7669       $this->_keyword,
7670       $this->_names,
7671       $this->_left_brace,
7672       $clauses,
7673       $this->_right_brace);
7674   }
7675   public function with_right_brace(EditableSyntax $right_brace): TraitUseConflictResolution {
7676     return new TraitUseConflictResolution(
7677       $this->_keyword,
7678       $this->_names,
7679       $this->_left_brace,
7680       $this->_clauses,
7681       $right_brace);
7682   }
7683
7684   public function rewrite(
7685     ( function
7686       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
7687     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
7688     $new_parents = $parents ?? [];
7689     array_push($new_parents, $this);
7690     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
7691     $names = $this->names()->rewrite($rewriter, $new_parents);
7692     $left_brace = $this->left_brace()->rewrite($rewriter, $new_parents);
7693     $clauses = $this->clauses()->rewrite($rewriter, $new_parents);
7694     $right_brace = $this->right_brace()->rewrite($rewriter, $new_parents);
7695     if (
7696       $keyword === $this->keyword() &&
7697       $names === $this->names() &&
7698       $left_brace === $this->left_brace() &&
7699       $clauses === $this->clauses() &&
7700       $right_brace === $this->right_brace()) {
7701       return $rewriter($this, $parents ?? []);
7702     } else {
7703       return $rewriter(new TraitUseConflictResolution(
7704         $keyword,
7705         $names,
7706         $left_brace,
7707         $clauses,
7708         $right_brace), $parents ?? []);
7709     }
7710   }
7711
7712   public static function from_json(mixed $json, int $position, string $source) {
7713     $keyword = EditableSyntax::from_json(
7714       $json->trait_use_conflict_resolution_keyword, $position, $source);
7715     $position += $keyword->width();
7716     $names = EditableSyntax::from_json(
7717       $json->trait_use_conflict_resolution_names, $position, $source);
7718     $position += $names->width();
7719     $left_brace = EditableSyntax::from_json(
7720       $json->trait_use_conflict_resolution_left_brace, $position, $source);
7721     $position += $left_brace->width();
7722     $clauses = EditableSyntax::from_json(
7723       $json->trait_use_conflict_resolution_clauses, $position, $source);
7724     $position += $clauses->width();
7725     $right_brace = EditableSyntax::from_json(
7726       $json->trait_use_conflict_resolution_right_brace, $position, $source);
7727     $position += $right_brace->width();
7728     return new TraitUseConflictResolution(
7729         $keyword,
7730         $names,
7731         $left_brace,
7732         $clauses,
7733         $right_brace);
7734   }
7735   public function children(): Generator<string, EditableSyntax, void> {
7736     yield $this->_keyword;
7737     yield $this->_names;
7738     yield $this->_left_brace;
7739     yield $this->_clauses;
7740     yield $this->_right_brace;
7741     yield break;
7742   }
7743 }
7744 final class TraitUse extends EditableSyntax {
7745   private EditableSyntax $_keyword;
7746   private EditableSyntax $_names;
7747   private EditableSyntax $_semicolon;
7748   public function __construct(
7749     EditableSyntax $keyword,
7750     EditableSyntax $names,
7751     EditableSyntax $semicolon) {
7752     parent::__construct('trait_use');
7753     $this->_keyword = $keyword;
7754     $this->_names = $names;
7755     $this->_semicolon = $semicolon;
7756   }
7757   public function keyword(): EditableSyntax {
7758     return $this->_keyword;
7759   }
7760   public function names(): EditableSyntax {
7761     return $this->_names;
7762   }
7763   public function semicolon(): EditableSyntax {
7764     return $this->_semicolon;
7765   }
7766   public function with_keyword(EditableSyntax $keyword): TraitUse {
7767     return new TraitUse(
7768       $keyword,
7769       $this->_names,
7770       $this->_semicolon);
7771   }
7772   public function with_names(EditableSyntax $names): TraitUse {
7773     return new TraitUse(
7774       $this->_keyword,
7775       $names,
7776       $this->_semicolon);
7777   }
7778   public function with_semicolon(EditableSyntax $semicolon): TraitUse {
7779     return new TraitUse(
7780       $this->_keyword,
7781       $this->_names,
7782       $semicolon);
7783   }
7784
7785   public function rewrite(
7786     ( function
7787       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
7788     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
7789     $new_parents = $parents ?? [];
7790     array_push($new_parents, $this);
7791     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
7792     $names = $this->names()->rewrite($rewriter, $new_parents);
7793     $semicolon = $this->semicolon()->rewrite($rewriter, $new_parents);
7794     if (
7795       $keyword === $this->keyword() &&
7796       $names === $this->names() &&
7797       $semicolon === $this->semicolon()) {
7798       return $rewriter($this, $parents ?? []);
7799     } else {
7800       return $rewriter(new TraitUse(
7801         $keyword,
7802         $names,
7803         $semicolon), $parents ?? []);
7804     }
7805   }
7806
7807   public static function from_json(mixed $json, int $position, string $source) {
7808     $keyword = EditableSyntax::from_json(
7809       $json->trait_use_keyword, $position, $source);
7810     $position += $keyword->width();
7811     $names = EditableSyntax::from_json(
7812       $json->trait_use_names, $position, $source);
7813     $position += $names->width();
7814     $semicolon = EditableSyntax::from_json(
7815       $json->trait_use_semicolon, $position, $source);
7816     $position += $semicolon->width();
7817     return new TraitUse(
7818         $keyword,
7819         $names,
7820         $semicolon);
7821   }
7822   public function children(): Generator<string, EditableSyntax, void> {
7823     yield $this->_keyword;
7824     yield $this->_names;
7825     yield $this->_semicolon;
7826     yield break;
7827   }
7828 }
7829 final class RequireClause extends EditableSyntax {
7830   private EditableSyntax $_keyword;
7831   private EditableSyntax $_kind;
7832   private EditableSyntax $_name;
7833   private EditableSyntax $_semicolon;
7834   public function __construct(
7835     EditableSyntax $keyword,
7836     EditableSyntax $kind,
7837     EditableSyntax $name,
7838     EditableSyntax $semicolon) {
7839     parent::__construct('require_clause');
7840     $this->_keyword = $keyword;
7841     $this->_kind = $kind;
7842     $this->_name = $name;
7843     $this->_semicolon = $semicolon;
7844   }
7845   public function keyword(): EditableSyntax {
7846     return $this->_keyword;
7847   }
7848   public function kind(): EditableSyntax {
7849     return $this->_kind;
7850   }
7851   public function name(): EditableSyntax {
7852     return $this->_name;
7853   }
7854   public function semicolon(): EditableSyntax {
7855     return $this->_semicolon;
7856   }
7857   public function with_keyword(EditableSyntax $keyword): RequireClause {
7858     return new RequireClause(
7859       $keyword,
7860       $this->_kind,
7861       $this->_name,
7862       $this->_semicolon);
7863   }
7864   public function with_kind(EditableSyntax $kind): RequireClause {
7865     return new RequireClause(
7866       $this->_keyword,
7867       $kind,
7868       $this->_name,
7869       $this->_semicolon);
7870   }
7871   public function with_name(EditableSyntax $name): RequireClause {
7872     return new RequireClause(
7873       $this->_keyword,
7874       $this->_kind,
7875       $name,
7876       $this->_semicolon);
7877   }
7878   public function with_semicolon(EditableSyntax $semicolon): RequireClause {
7879     return new RequireClause(
7880       $this->_keyword,
7881       $this->_kind,
7882       $this->_name,
7883       $semicolon);
7884   }
7885
7886   public function rewrite(
7887     ( function
7888       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
7889     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
7890     $new_parents = $parents ?? [];
7891     array_push($new_parents, $this);
7892     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
7893     $kind = $this->kind()->rewrite($rewriter, $new_parents);
7894     $name = $this->name()->rewrite($rewriter, $new_parents);
7895     $semicolon = $this->semicolon()->rewrite($rewriter, $new_parents);
7896     if (
7897       $keyword === $this->keyword() &&
7898       $kind === $this->kind() &&
7899       $name === $this->name() &&
7900       $semicolon === $this->semicolon()) {
7901       return $rewriter($this, $parents ?? []);
7902     } else {
7903       return $rewriter(new RequireClause(
7904         $keyword,
7905         $kind,
7906         $name,
7907         $semicolon), $parents ?? []);
7908     }
7909   }
7910
7911   public static function from_json(mixed $json, int $position, string $source) {
7912     $keyword = EditableSyntax::from_json(
7913       $json->require_keyword, $position, $source);
7914     $position += $keyword->width();
7915     $kind = EditableSyntax::from_json(
7916       $json->require_kind, $position, $source);
7917     $position += $kind->width();
7918     $name = EditableSyntax::from_json(
7919       $json->require_name, $position, $source);
7920     $position += $name->width();
7921     $semicolon = EditableSyntax::from_json(
7922       $json->require_semicolon, $position, $source);
7923     $position += $semicolon->width();
7924     return new RequireClause(
7925         $keyword,
7926         $kind,
7927         $name,
7928         $semicolon);
7929   }
7930   public function children(): Generator<string, EditableSyntax, void> {
7931     yield $this->_keyword;
7932     yield $this->_kind;
7933     yield $this->_name;
7934     yield $this->_semicolon;
7935     yield break;
7936   }
7937 }
7938 final class ConstDeclaration extends EditableSyntax {
7939   private EditableSyntax $_abstract;
7940   private EditableSyntax $_keyword;
7941   private EditableSyntax $_type_specifier;
7942   private EditableSyntax $_declarators;
7943   private EditableSyntax $_semicolon;
7944   public function __construct(
7945     EditableSyntax $abstract,
7946     EditableSyntax $keyword,
7947     EditableSyntax $type_specifier,
7948     EditableSyntax $declarators,
7949     EditableSyntax $semicolon) {
7950     parent::__construct('const_declaration');
7951     $this->_abstract = $abstract;
7952     $this->_keyword = $keyword;
7953     $this->_type_specifier = $type_specifier;
7954     $this->_declarators = $declarators;
7955     $this->_semicolon = $semicolon;
7956   }
7957   public function abstract(): EditableSyntax {
7958     return $this->_abstract;
7959   }
7960   public function keyword(): EditableSyntax {
7961     return $this->_keyword;
7962   }
7963   public function type_specifier(): EditableSyntax {
7964     return $this->_type_specifier;
7965   }
7966   public function declarators(): EditableSyntax {
7967     return $this->_declarators;
7968   }
7969   public function semicolon(): EditableSyntax {
7970     return $this->_semicolon;
7971   }
7972   public function with_abstract(EditableSyntax $abstract): ConstDeclaration {
7973     return new ConstDeclaration(
7974       $abstract,
7975       $this->_keyword,
7976       $this->_type_specifier,
7977       $this->_declarators,
7978       $this->_semicolon);
7979   }
7980   public function with_keyword(EditableSyntax $keyword): ConstDeclaration {
7981     return new ConstDeclaration(
7982       $this->_abstract,
7983       $keyword,
7984       $this->_type_specifier,
7985       $this->_declarators,
7986       $this->_semicolon);
7987   }
7988   public function with_type_specifier(EditableSyntax $type_specifier): ConstDeclaration {
7989     return new ConstDeclaration(
7990       $this->_abstract,
7991       $this->_keyword,
7992       $type_specifier,
7993       $this->_declarators,
7994       $this->_semicolon);
7995   }
7996   public function with_declarators(EditableSyntax $declarators): ConstDeclaration {
7997     return new ConstDeclaration(
7998       $this->_abstract,
7999       $this->_keyword,
8000       $this->_type_specifier,
8001       $declarators,
8002       $this->_semicolon);
8003   }
8004   public function with_semicolon(EditableSyntax $semicolon): ConstDeclaration {
8005     return new ConstDeclaration(
8006       $this->_abstract,
8007       $this->_keyword,
8008       $this->_type_specifier,
8009       $this->_declarators,
8010       $semicolon);
8011   }
8012
8013   public function rewrite(
8014     ( function
8015       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
8016     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
8017     $new_parents = $parents ?? [];
8018     array_push($new_parents, $this);
8019     $abstract = $this->abstract()->rewrite($rewriter, $new_parents);
8020     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
8021     $type_specifier = $this->type_specifier()->rewrite($rewriter, $new_parents);
8022     $declarators = $this->declarators()->rewrite($rewriter, $new_parents);
8023     $semicolon = $this->semicolon()->rewrite($rewriter, $new_parents);
8024     if (
8025       $abstract === $this->abstract() &&
8026       $keyword === $this->keyword() &&
8027       $type_specifier === $this->type_specifier() &&
8028       $declarators === $this->declarators() &&
8029       $semicolon === $this->semicolon()) {
8030       return $rewriter($this, $parents ?? []);
8031     } else {
8032       return $rewriter(new ConstDeclaration(
8033         $abstract,
8034         $keyword,
8035         $type_specifier,
8036         $declarators,
8037         $semicolon), $parents ?? []);
8038     }
8039   }
8040
8041   public static function from_json(mixed $json, int $position, string $source) {
8042     $abstract = EditableSyntax::from_json(
8043       $json->const_abstract, $position, $source);
8044     $position += $abstract->width();
8045     $keyword = EditableSyntax::from_json(
8046       $json->const_keyword, $position, $source);
8047     $position += $keyword->width();
8048     $type_specifier = EditableSyntax::from_json(
8049       $json->const_type_specifier, $position, $source);
8050     $position += $type_specifier->width();
8051     $declarators = EditableSyntax::from_json(
8052       $json->const_declarators, $position, $source);
8053     $position += $declarators->width();
8054     $semicolon = EditableSyntax::from_json(
8055       $json->const_semicolon, $position, $source);
8056     $position += $semicolon->width();
8057     return new ConstDeclaration(
8058         $abstract,
8059         $keyword,
8060         $type_specifier,
8061         $declarators,
8062         $semicolon);
8063   }
8064   public function children(): Generator<string, EditableSyntax, void> {
8065     yield $this->_abstract;
8066     yield $this->_keyword;
8067     yield $this->_type_specifier;
8068     yield $this->_declarators;
8069     yield $this->_semicolon;
8070     yield break;
8071   }
8072 }
8073 final class ConstantDeclarator extends EditableSyntax {
8074   private EditableSyntax $_name;
8075   private EditableSyntax $_initializer;
8076   public function __construct(
8077     EditableSyntax $name,
8078     EditableSyntax $initializer) {
8079     parent::__construct('constant_declarator');
8080     $this->_name = $name;
8081     $this->_initializer = $initializer;
8082   }
8083   public function name(): EditableSyntax {
8084     return $this->_name;
8085   }
8086   public function initializer(): EditableSyntax {
8087     return $this->_initializer;
8088   }
8089   public function with_name(EditableSyntax $name): ConstantDeclarator {
8090     return new ConstantDeclarator(
8091       $name,
8092       $this->_initializer);
8093   }
8094   public function with_initializer(EditableSyntax $initializer): ConstantDeclarator {
8095     return new ConstantDeclarator(
8096       $this->_name,
8097       $initializer);
8098   }
8099
8100   public function rewrite(
8101     ( function
8102       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
8103     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
8104     $new_parents = $parents ?? [];
8105     array_push($new_parents, $this);
8106     $name = $this->name()->rewrite($rewriter, $new_parents);
8107     $initializer = $this->initializer()->rewrite($rewriter, $new_parents);
8108     if (
8109       $name === $this->name() &&
8110       $initializer === $this->initializer()) {
8111       return $rewriter($this, $parents ?? []);
8112     } else {
8113       return $rewriter(new ConstantDeclarator(
8114         $name,
8115         $initializer), $parents ?? []);
8116     }
8117   }
8118
8119   public static function from_json(mixed $json, int $position, string $source) {
8120     $name = EditableSyntax::from_json(
8121       $json->constant_declarator_name, $position, $source);
8122     $position += $name->width();
8123     $initializer = EditableSyntax::from_json(
8124       $json->constant_declarator_initializer, $position, $source);
8125     $position += $initializer->width();
8126     return new ConstantDeclarator(
8127         $name,
8128         $initializer);
8129   }
8130   public function children(): Generator<string, EditableSyntax, void> {
8131     yield $this->_name;
8132     yield $this->_initializer;
8133     yield break;
8134   }
8135 }
8136 final class TypeConstDeclaration extends EditableSyntax {
8137   private EditableSyntax $_abstract;
8138   private EditableSyntax $_keyword;
8139   private EditableSyntax $_type_keyword;
8140   private EditableSyntax $_name;
8141   private EditableSyntax $_type_parameters;
8142   private EditableSyntax $_type_constraint;
8143   private EditableSyntax $_equal;
8144   private EditableSyntax $_type_specifier;
8145   private EditableSyntax $_semicolon;
8146   public function __construct(
8147     EditableSyntax $abstract,
8148     EditableSyntax $keyword,
8149     EditableSyntax $type_keyword,
8150     EditableSyntax $name,
8151     EditableSyntax $type_parameters,
8152     EditableSyntax $type_constraint,
8153     EditableSyntax $equal,
8154     EditableSyntax $type_specifier,
8155     EditableSyntax $semicolon) {
8156     parent::__construct('type_const_declaration');
8157     $this->_abstract = $abstract;
8158     $this->_keyword = $keyword;
8159     $this->_type_keyword = $type_keyword;
8160     $this->_name = $name;
8161     $this->_type_parameters = $type_parameters;
8162     $this->_type_constraint = $type_constraint;
8163     $this->_equal = $equal;
8164     $this->_type_specifier = $type_specifier;
8165     $this->_semicolon = $semicolon;
8166   }
8167   public function abstract(): EditableSyntax {
8168     return $this->_abstract;
8169   }
8170   public function keyword(): EditableSyntax {
8171     return $this->_keyword;
8172   }
8173   public function type_keyword(): EditableSyntax {
8174     return $this->_type_keyword;
8175   }
8176   public function name(): EditableSyntax {
8177     return $this->_name;
8178   }
8179   public function type_parameters(): EditableSyntax {
8180     return $this->_type_parameters;
8181   }
8182   public function type_constraint(): EditableSyntax {
8183     return $this->_type_constraint;
8184   }
8185   public function equal(): EditableSyntax {
8186     return $this->_equal;
8187   }
8188   public function type_specifier(): EditableSyntax {
8189     return $this->_type_specifier;
8190   }
8191   public function semicolon(): EditableSyntax {
8192     return $this->_semicolon;
8193   }
8194   public function with_abstract(EditableSyntax $abstract): TypeConstDeclaration {
8195     return new TypeConstDeclaration(
8196       $abstract,
8197       $this->_keyword,
8198       $this->_type_keyword,
8199       $this->_name,
8200       $this->_type_parameters,
8201       $this->_type_constraint,
8202       $this->_equal,
8203       $this->_type_specifier,
8204       $this->_semicolon);
8205   }
8206   public function with_keyword(EditableSyntax $keyword): TypeConstDeclaration {
8207     return new TypeConstDeclaration(
8208       $this->_abstract,
8209       $keyword,
8210       $this->_type_keyword,
8211       $this->_name,
8212       $this->_type_parameters,
8213       $this->_type_constraint,
8214       $this->_equal,
8215       $this->_type_specifier,
8216       $this->_semicolon);
8217   }
8218   public function with_type_keyword(EditableSyntax $type_keyword): TypeConstDeclaration {
8219     return new TypeConstDeclaration(
8220       $this->_abstract,
8221       $this->_keyword,
8222       $type_keyword,
8223       $this->_name,
8224       $this->_type_parameters,
8225       $this->_type_constraint,
8226       $this->_equal,
8227       $this->_type_specifier,
8228       $this->_semicolon);
8229   }
8230   public function with_name(EditableSyntax $name): TypeConstDeclaration {
8231     return new TypeConstDeclaration(
8232       $this->_abstract,
8233       $this->_keyword,
8234       $this->_type_keyword,
8235       $name,
8236       $this->_type_parameters,
8237       $this->_type_constraint,
8238       $this->_equal,
8239       $this->_type_specifier,
8240       $this->_semicolon);
8241   }
8242   public function with_type_parameters(EditableSyntax $type_parameters): TypeConstDeclaration {
8243     return new TypeConstDeclaration(
8244       $this->_abstract,
8245       $this->_keyword,
8246       $this->_type_keyword,
8247       $this->_name,
8248       $type_parameters,
8249       $this->_type_constraint,
8250       $this->_equal,
8251       $this->_type_specifier,
8252       $this->_semicolon);
8253   }
8254   public function with_type_constraint(EditableSyntax $type_constraint): TypeConstDeclaration {
8255     return new TypeConstDeclaration(
8256       $this->_abstract,
8257       $this->_keyword,
8258       $this->_type_keyword,
8259       $this->_name,
8260       $this->_type_parameters,
8261       $type_constraint,
8262       $this->_equal,
8263       $this->_type_specifier,
8264       $this->_semicolon);
8265   }
8266   public function with_equal(EditableSyntax $equal): TypeConstDeclaration {
8267     return new TypeConstDeclaration(
8268       $this->_abstract,
8269       $this->_keyword,
8270       $this->_type_keyword,
8271       $this->_name,
8272       $this->_type_parameters,
8273       $this->_type_constraint,
8274       $equal,
8275       $this->_type_specifier,
8276       $this->_semicolon);
8277   }
8278   public function with_type_specifier(EditableSyntax $type_specifier): TypeConstDeclaration {
8279     return new TypeConstDeclaration(
8280       $this->_abstract,
8281       $this->_keyword,
8282       $this->_type_keyword,
8283       $this->_name,
8284       $this->_type_parameters,
8285       $this->_type_constraint,
8286       $this->_equal,
8287       $type_specifier,
8288       $this->_semicolon);
8289   }
8290   public function with_semicolon(EditableSyntax $semicolon): TypeConstDeclaration {
8291     return new TypeConstDeclaration(
8292       $this->_abstract,
8293       $this->_keyword,
8294       $this->_type_keyword,
8295       $this->_name,
8296       $this->_type_parameters,
8297       $this->_type_constraint,
8298       $this->_equal,
8299       $this->_type_specifier,
8300       $semicolon);
8301   }
8302
8303   public function rewrite(
8304     ( function
8305       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
8306     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
8307     $new_parents = $parents ?? [];
8308     array_push($new_parents, $this);
8309     $abstract = $this->abstract()->rewrite($rewriter, $new_parents);
8310     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
8311     $type_keyword = $this->type_keyword()->rewrite($rewriter, $new_parents);
8312     $name = $this->name()->rewrite($rewriter, $new_parents);
8313     $type_parameters = $this->type_parameters()->rewrite($rewriter, $new_parents);
8314     $type_constraint = $this->type_constraint()->rewrite($rewriter, $new_parents);
8315     $equal = $this->equal()->rewrite($rewriter, $new_parents);
8316     $type_specifier = $this->type_specifier()->rewrite($rewriter, $new_parents);
8317     $semicolon = $this->semicolon()->rewrite($rewriter, $new_parents);
8318     if (
8319       $abstract === $this->abstract() &&
8320       $keyword === $this->keyword() &&
8321       $type_keyword === $this->type_keyword() &&
8322       $name === $this->name() &&
8323       $type_parameters === $this->type_parameters() &&
8324       $type_constraint === $this->type_constraint() &&
8325       $equal === $this->equal() &&
8326       $type_specifier === $this->type_specifier() &&
8327       $semicolon === $this->semicolon()) {
8328       return $rewriter($this, $parents ?? []);
8329     } else {
8330       return $rewriter(new TypeConstDeclaration(
8331         $abstract,
8332         $keyword,
8333         $type_keyword,
8334         $name,
8335         $type_parameters,
8336         $type_constraint,
8337         $equal,
8338         $type_specifier,
8339         $semicolon), $parents ?? []);
8340     }
8341   }
8342
8343   public static function from_json(mixed $json, int $position, string $source) {
8344     $abstract = EditableSyntax::from_json(
8345       $json->type_const_abstract, $position, $source);
8346     $position += $abstract->width();
8347     $keyword = EditableSyntax::from_json(
8348       $json->type_const_keyword, $position, $source);
8349     $position += $keyword->width();
8350     $type_keyword = EditableSyntax::from_json(
8351       $json->type_const_type_keyword, $position, $source);
8352     $position += $type_keyword->width();
8353     $name = EditableSyntax::from_json(
8354       $json->type_const_name, $position, $source);
8355     $position += $name->width();
8356     $type_parameters = EditableSyntax::from_json(
8357       $json->type_const_type_parameters, $position, $source);
8358     $position += $type_parameters->width();
8359     $type_constraint = EditableSyntax::from_json(
8360       $json->type_const_type_constraint, $position, $source);
8361     $position += $type_constraint->width();
8362     $equal = EditableSyntax::from_json(
8363       $json->type_const_equal, $position, $source);
8364     $position += $equal->width();
8365     $type_specifier = EditableSyntax::from_json(
8366       $json->type_const_type_specifier, $position, $source);
8367     $position += $type_specifier->width();
8368     $semicolon = EditableSyntax::from_json(
8369       $json->type_const_semicolon, $position, $source);
8370     $position += $semicolon->width();
8371     return new TypeConstDeclaration(
8372         $abstract,
8373         $keyword,
8374         $type_keyword,
8375         $name,
8376         $type_parameters,
8377         $type_constraint,
8378         $equal,
8379         $type_specifier,
8380         $semicolon);
8381   }
8382   public function children(): Generator<string, EditableSyntax, void> {
8383     yield $this->_abstract;
8384     yield $this->_keyword;
8385     yield $this->_type_keyword;
8386     yield $this->_name;
8387     yield $this->_type_parameters;
8388     yield $this->_type_constraint;
8389     yield $this->_equal;
8390     yield $this->_type_specifier;
8391     yield $this->_semicolon;
8392     yield break;
8393   }
8394 }
8395 final class DecoratedExpression extends EditableSyntax {
8396   private EditableSyntax $_decorator;
8397   private EditableSyntax $_expression;
8398   public function __construct(
8399     EditableSyntax $decorator,
8400     EditableSyntax $expression) {
8401     parent::__construct('decorated_expression');
8402     $this->_decorator = $decorator;
8403     $this->_expression = $expression;
8404   }
8405   public function decorator(): EditableSyntax {
8406     return $this->_decorator;
8407   }
8408   public function expression(): EditableSyntax {
8409     return $this->_expression;
8410   }
8411   public function with_decorator(EditableSyntax $decorator): DecoratedExpression {
8412     return new DecoratedExpression(
8413       $decorator,
8414       $this->_expression);
8415   }
8416   public function with_expression(EditableSyntax $expression): DecoratedExpression {
8417     return new DecoratedExpression(
8418       $this->_decorator,
8419       $expression);
8420   }
8421
8422   public function rewrite(
8423     ( function
8424       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
8425     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
8426     $new_parents = $parents ?? [];
8427     array_push($new_parents, $this);
8428     $decorator = $this->decorator()->rewrite($rewriter, $new_parents);
8429     $expression = $this->expression()->rewrite($rewriter, $new_parents);
8430     if (
8431       $decorator === $this->decorator() &&
8432       $expression === $this->expression()) {
8433       return $rewriter($this, $parents ?? []);
8434     } else {
8435       return $rewriter(new DecoratedExpression(
8436         $decorator,
8437         $expression), $parents ?? []);
8438     }
8439   }
8440
8441   public static function from_json(mixed $json, int $position, string $source) {
8442     $decorator = EditableSyntax::from_json(
8443       $json->decorated_expression_decorator, $position, $source);
8444     $position += $decorator->width();
8445     $expression = EditableSyntax::from_json(
8446       $json->decorated_expression_expression, $position, $source);
8447     $position += $expression->width();
8448     return new DecoratedExpression(
8449         $decorator,
8450         $expression);
8451   }
8452   public function children(): Generator<string, EditableSyntax, void> {
8453     yield $this->_decorator;
8454     yield $this->_expression;
8455     yield break;
8456   }
8457 }
8458 final class ParameterDeclaration extends EditableSyntax {
8459   private EditableSyntax $_attribute;
8460   private EditableSyntax $_visibility;
8461   private EditableSyntax $_call_convention;
8462   private EditableSyntax $_type;
8463   private EditableSyntax $_name;
8464   private EditableSyntax $_default_value;
8465   public function __construct(
8466     EditableSyntax $attribute,
8467     EditableSyntax $visibility,
8468     EditableSyntax $call_convention,
8469     EditableSyntax $type,
8470     EditableSyntax $name,
8471     EditableSyntax $default_value) {
8472     parent::__construct('parameter_declaration');
8473     $this->_attribute = $attribute;
8474     $this->_visibility = $visibility;
8475     $this->_call_convention = $call_convention;
8476     $this->_type = $type;
8477     $this->_name = $name;
8478     $this->_default_value = $default_value;
8479   }
8480   public function attribute(): EditableSyntax {
8481     return $this->_attribute;
8482   }
8483   public function visibility(): EditableSyntax {
8484     return $this->_visibility;
8485   }
8486   public function call_convention(): EditableSyntax {
8487     return $this->_call_convention;
8488   }
8489   public function type(): EditableSyntax {
8490     return $this->_type;
8491   }
8492   public function name(): EditableSyntax {
8493     return $this->_name;
8494   }
8495   public function default_value(): EditableSyntax {
8496     return $this->_default_value;
8497   }
8498   public function with_attribute(EditableSyntax $attribute): ParameterDeclaration {
8499     return new ParameterDeclaration(
8500       $attribute,
8501       $this->_visibility,
8502       $this->_call_convention,
8503       $this->_type,
8504       $this->_name,
8505       $this->_default_value);
8506   }
8507   public function with_visibility(EditableSyntax $visibility): ParameterDeclaration {
8508     return new ParameterDeclaration(
8509       $this->_attribute,
8510       $visibility,
8511       $this->_call_convention,
8512       $this->_type,
8513       $this->_name,
8514       $this->_default_value);
8515   }
8516   public function with_call_convention(EditableSyntax $call_convention): ParameterDeclaration {
8517     return new ParameterDeclaration(
8518       $this->_attribute,
8519       $this->_visibility,
8520       $call_convention,
8521       $this->_type,
8522       $this->_name,
8523       $this->_default_value);
8524   }
8525   public function with_type(EditableSyntax $type): ParameterDeclaration {
8526     return new ParameterDeclaration(
8527       $this->_attribute,
8528       $this->_visibility,
8529       $this->_call_convention,
8530       $type,
8531       $this->_name,
8532       $this->_default_value);
8533   }
8534   public function with_name(EditableSyntax $name): ParameterDeclaration {
8535     return new ParameterDeclaration(
8536       $this->_attribute,
8537       $this->_visibility,
8538       $this->_call_convention,
8539       $this->_type,
8540       $name,
8541       $this->_default_value);
8542   }
8543   public function with_default_value(EditableSyntax $default_value): ParameterDeclaration {
8544     return new ParameterDeclaration(
8545       $this->_attribute,
8546       $this->_visibility,
8547       $this->_call_convention,
8548       $this->_type,
8549       $this->_name,
8550       $default_value);
8551   }
8552
8553   public function rewrite(
8554     ( function
8555       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
8556     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
8557     $new_parents = $parents ?? [];
8558     array_push($new_parents, $this);
8559     $attribute = $this->attribute()->rewrite($rewriter, $new_parents);
8560     $visibility = $this->visibility()->rewrite($rewriter, $new_parents);
8561     $call_convention = $this->call_convention()->rewrite($rewriter, $new_parents);
8562     $type = $this->type()->rewrite($rewriter, $new_parents);
8563     $name = $this->name()->rewrite($rewriter, $new_parents);
8564     $default_value = $this->default_value()->rewrite($rewriter, $new_parents);
8565     if (
8566       $attribute === $this->attribute() &&
8567       $visibility === $this->visibility() &&
8568       $call_convention === $this->call_convention() &&
8569       $type === $this->type() &&
8570       $name === $this->name() &&
8571       $default_value === $this->default_value()) {
8572       return $rewriter($this, $parents ?? []);
8573     } else {
8574       return $rewriter(new ParameterDeclaration(
8575         $attribute,
8576         $visibility,
8577         $call_convention,
8578         $type,
8579         $name,
8580         $default_value), $parents ?? []);
8581     }
8582   }
8583
8584   public static function from_json(mixed $json, int $position, string $source) {
8585     $attribute = EditableSyntax::from_json(
8586       $json->parameter_attribute, $position, $source);
8587     $position += $attribute->width();
8588     $visibility = EditableSyntax::from_json(
8589       $json->parameter_visibility, $position, $source);
8590     $position += $visibility->width();
8591     $call_convention = EditableSyntax::from_json(
8592       $json->parameter_call_convention, $position, $source);
8593     $position += $call_convention->width();
8594     $type = EditableSyntax::from_json(
8595       $json->parameter_type, $position, $source);
8596     $position += $type->width();
8597     $name = EditableSyntax::from_json(
8598       $json->parameter_name, $position, $source);
8599     $position += $name->width();
8600     $default_value = EditableSyntax::from_json(
8601       $json->parameter_default_value, $position, $source);
8602     $position += $default_value->width();
8603     return new ParameterDeclaration(
8604         $attribute,
8605         $visibility,
8606         $call_convention,
8607         $type,
8608         $name,
8609         $default_value);
8610   }
8611   public function children(): Generator<string, EditableSyntax, void> {
8612     yield $this->_attribute;
8613     yield $this->_visibility;
8614     yield $this->_call_convention;
8615     yield $this->_type;
8616     yield $this->_name;
8617     yield $this->_default_value;
8618     yield break;
8619   }
8620 }
8621 final class VariadicParameter extends EditableSyntax {
8622   private EditableSyntax $_call_convention;
8623   private EditableSyntax $_type;
8624   private EditableSyntax $_ellipsis;
8625   public function __construct(
8626     EditableSyntax $call_convention,
8627     EditableSyntax $type,
8628     EditableSyntax $ellipsis) {
8629     parent::__construct('variadic_parameter');
8630     $this->_call_convention = $call_convention;
8631     $this->_type = $type;
8632     $this->_ellipsis = $ellipsis;
8633   }
8634   public function call_convention(): EditableSyntax {
8635     return $this->_call_convention;
8636   }
8637   public function type(): EditableSyntax {
8638     return $this->_type;
8639   }
8640   public function ellipsis(): EditableSyntax {
8641     return $this->_ellipsis;
8642   }
8643   public function with_call_convention(EditableSyntax $call_convention): VariadicParameter {
8644     return new VariadicParameter(
8645       $call_convention,
8646       $this->_type,
8647       $this->_ellipsis);
8648   }
8649   public function with_type(EditableSyntax $type): VariadicParameter {
8650     return new VariadicParameter(
8651       $this->_call_convention,
8652       $type,
8653       $this->_ellipsis);
8654   }
8655   public function with_ellipsis(EditableSyntax $ellipsis): VariadicParameter {
8656     return new VariadicParameter(
8657       $this->_call_convention,
8658       $this->_type,
8659       $ellipsis);
8660   }
8661
8662   public function rewrite(
8663     ( function
8664       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
8665     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
8666     $new_parents = $parents ?? [];
8667     array_push($new_parents, $this);
8668     $call_convention = $this->call_convention()->rewrite($rewriter, $new_parents);
8669     $type = $this->type()->rewrite($rewriter, $new_parents);
8670     $ellipsis = $this->ellipsis()->rewrite($rewriter, $new_parents);
8671     if (
8672       $call_convention === $this->call_convention() &&
8673       $type === $this->type() &&
8674       $ellipsis === $this->ellipsis()) {
8675       return $rewriter($this, $parents ?? []);
8676     } else {
8677       return $rewriter(new VariadicParameter(
8678         $call_convention,
8679         $type,
8680         $ellipsis), $parents ?? []);
8681     }
8682   }
8683
8684   public static function from_json(mixed $json, int $position, string $source) {
8685     $call_convention = EditableSyntax::from_json(
8686       $json->variadic_parameter_call_convention, $position, $source);
8687     $position += $call_convention->width();
8688     $type = EditableSyntax::from_json(
8689       $json->variadic_parameter_type, $position, $source);
8690     $position += $type->width();
8691     $ellipsis = EditableSyntax::from_json(
8692       $json->variadic_parameter_ellipsis, $position, $source);
8693     $position += $ellipsis->width();
8694     return new VariadicParameter(
8695         $call_convention,
8696         $type,
8697         $ellipsis);
8698   }
8699   public function children(): Generator<string, EditableSyntax, void> {
8700     yield $this->_call_convention;
8701     yield $this->_type;
8702     yield $this->_ellipsis;
8703     yield break;
8704   }
8705 }
8706 final class AttributeSpecification extends EditableSyntax {
8707   private EditableSyntax $_left_double_angle;
8708   private EditableSyntax $_attributes;
8709   private EditableSyntax $_right_double_angle;
8710   public function __construct(
8711     EditableSyntax $left_double_angle,
8712     EditableSyntax $attributes,
8713     EditableSyntax $right_double_angle) {
8714     parent::__construct('attribute_specification');
8715     $this->_left_double_angle = $left_double_angle;
8716     $this->_attributes = $attributes;
8717     $this->_right_double_angle = $right_double_angle;
8718   }
8719   public function left_double_angle(): EditableSyntax {
8720     return $this->_left_double_angle;
8721   }
8722   public function attributes(): EditableSyntax {
8723     return $this->_attributes;
8724   }
8725   public function right_double_angle(): EditableSyntax {
8726     return $this->_right_double_angle;
8727   }
8728   public function with_left_double_angle(EditableSyntax $left_double_angle): AttributeSpecification {
8729     return new AttributeSpecification(
8730       $left_double_angle,
8731       $this->_attributes,
8732       $this->_right_double_angle);
8733   }
8734   public function with_attributes(EditableSyntax $attributes): AttributeSpecification {
8735     return new AttributeSpecification(
8736       $this->_left_double_angle,
8737       $attributes,
8738       $this->_right_double_angle);
8739   }
8740   public function with_right_double_angle(EditableSyntax $right_double_angle): AttributeSpecification {
8741     return new AttributeSpecification(
8742       $this->_left_double_angle,
8743       $this->_attributes,
8744       $right_double_angle);
8745   }
8746
8747   public function rewrite(
8748     ( function
8749       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
8750     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
8751     $new_parents = $parents ?? [];
8752     array_push($new_parents, $this);
8753     $left_double_angle = $this->left_double_angle()->rewrite($rewriter, $new_parents);
8754     $attributes = $this->attributes()->rewrite($rewriter, $new_parents);
8755     $right_double_angle = $this->right_double_angle()->rewrite($rewriter, $new_parents);
8756     if (
8757       $left_double_angle === $this->left_double_angle() &&
8758       $attributes === $this->attributes() &&
8759       $right_double_angle === $this->right_double_angle()) {
8760       return $rewriter($this, $parents ?? []);
8761     } else {
8762       return $rewriter(new AttributeSpecification(
8763         $left_double_angle,
8764         $attributes,
8765         $right_double_angle), $parents ?? []);
8766     }
8767   }
8768
8769   public static function from_json(mixed $json, int $position, string $source) {
8770     $left_double_angle = EditableSyntax::from_json(
8771       $json->attribute_specification_left_double_angle, $position, $source);
8772     $position += $left_double_angle->width();
8773     $attributes = EditableSyntax::from_json(
8774       $json->attribute_specification_attributes, $position, $source);
8775     $position += $attributes->width();
8776     $right_double_angle = EditableSyntax::from_json(
8777       $json->attribute_specification_right_double_angle, $position, $source);
8778     $position += $right_double_angle->width();
8779     return new AttributeSpecification(
8780         $left_double_angle,
8781         $attributes,
8782         $right_double_angle);
8783   }
8784   public function children(): Generator<string, EditableSyntax, void> {
8785     yield $this->_left_double_angle;
8786     yield $this->_attributes;
8787     yield $this->_right_double_angle;
8788     yield break;
8789   }
8790 }
8791 final class Attribute extends EditableSyntax {
8792   private EditableSyntax $_name;
8793   private EditableSyntax $_left_paren;
8794   private EditableSyntax $_values;
8795   private EditableSyntax $_right_paren;
8796   public function __construct(
8797     EditableSyntax $name,
8798     EditableSyntax $left_paren,
8799     EditableSyntax $values,
8800     EditableSyntax $right_paren) {
8801     parent::__construct('attribute');
8802     $this->_name = $name;
8803     $this->_left_paren = $left_paren;
8804     $this->_values = $values;
8805     $this->_right_paren = $right_paren;
8806   }
8807   public function name(): EditableSyntax {
8808     return $this->_name;
8809   }
8810   public function left_paren(): EditableSyntax {
8811     return $this->_left_paren;
8812   }
8813   public function values(): EditableSyntax {
8814     return $this->_values;
8815   }
8816   public function right_paren(): EditableSyntax {
8817     return $this->_right_paren;
8818   }
8819   public function with_name(EditableSyntax $name): Attribute {
8820     return new Attribute(
8821       $name,
8822       $this->_left_paren,
8823       $this->_values,
8824       $this->_right_paren);
8825   }
8826   public function with_left_paren(EditableSyntax $left_paren): Attribute {
8827     return new Attribute(
8828       $this->_name,
8829       $left_paren,
8830       $this->_values,
8831       $this->_right_paren);
8832   }
8833   public function with_values(EditableSyntax $values): Attribute {
8834     return new Attribute(
8835       $this->_name,
8836       $this->_left_paren,
8837       $values,
8838       $this->_right_paren);
8839   }
8840   public function with_right_paren(EditableSyntax $right_paren): Attribute {
8841     return new Attribute(
8842       $this->_name,
8843       $this->_left_paren,
8844       $this->_values,
8845       $right_paren);
8846   }
8847
8848   public function rewrite(
8849     ( function
8850       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
8851     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
8852     $new_parents = $parents ?? [];
8853     array_push($new_parents, $this);
8854     $name = $this->name()->rewrite($rewriter, $new_parents);
8855     $left_paren = $this->left_paren()->rewrite($rewriter, $new_parents);
8856     $values = $this->values()->rewrite($rewriter, $new_parents);
8857     $right_paren = $this->right_paren()->rewrite($rewriter, $new_parents);
8858     if (
8859       $name === $this->name() &&
8860       $left_paren === $this->left_paren() &&
8861       $values === $this->values() &&
8862       $right_paren === $this->right_paren()) {
8863       return $rewriter($this, $parents ?? []);
8864     } else {
8865       return $rewriter(new Attribute(
8866         $name,
8867         $left_paren,
8868         $values,
8869         $right_paren), $parents ?? []);
8870     }
8871   }
8872
8873   public static function from_json(mixed $json, int $position, string $source) {
8874     $name = EditableSyntax::from_json(
8875       $json->attribute_name, $position, $source);
8876     $position += $name->width();
8877     $left_paren = EditableSyntax::from_json(
8878       $json->attribute_left_paren, $position, $source);
8879     $position += $left_paren->width();
8880     $values = EditableSyntax::from_json(
8881       $json->attribute_values, $position, $source);
8882     $position += $values->width();
8883     $right_paren = EditableSyntax::from_json(
8884       $json->attribute_right_paren, $position, $source);
8885     $position += $right_paren->width();
8886     return new Attribute(
8887         $name,
8888         $left_paren,
8889         $values,
8890         $right_paren);
8891   }
8892   public function children(): Generator<string, EditableSyntax, void> {
8893     yield $this->_name;
8894     yield $this->_left_paren;
8895     yield $this->_values;
8896     yield $this->_right_paren;
8897     yield break;
8898   }
8899 }
8900 final class InclusionExpression extends EditableSyntax {
8901   private EditableSyntax $_require;
8902   private EditableSyntax $_filename;
8903   public function __construct(
8904     EditableSyntax $require,
8905     EditableSyntax $filename) {
8906     parent::__construct('inclusion_expression');
8907     $this->_require = $require;
8908     $this->_filename = $filename;
8909   }
8910   public function require(): EditableSyntax {
8911     return $this->_require;
8912   }
8913   public function filename(): EditableSyntax {
8914     return $this->_filename;
8915   }
8916   public function with_require(EditableSyntax $require): InclusionExpression {
8917     return new InclusionExpression(
8918       $require,
8919       $this->_filename);
8920   }
8921   public function with_filename(EditableSyntax $filename): InclusionExpression {
8922     return new InclusionExpression(
8923       $this->_require,
8924       $filename);
8925   }
8926
8927   public function rewrite(
8928     ( function
8929       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
8930     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
8931     $new_parents = $parents ?? [];
8932     array_push($new_parents, $this);
8933     $require = $this->require()->rewrite($rewriter, $new_parents);
8934     $filename = $this->filename()->rewrite($rewriter, $new_parents);
8935     if (
8936       $require === $this->require() &&
8937       $filename === $this->filename()) {
8938       return $rewriter($this, $parents ?? []);
8939     } else {
8940       return $rewriter(new InclusionExpression(
8941         $require,
8942         $filename), $parents ?? []);
8943     }
8944   }
8945
8946   public static function from_json(mixed $json, int $position, string $source) {
8947     $require = EditableSyntax::from_json(
8948       $json->inclusion_require, $position, $source);
8949     $position += $require->width();
8950     $filename = EditableSyntax::from_json(
8951       $json->inclusion_filename, $position, $source);
8952     $position += $filename->width();
8953     return new InclusionExpression(
8954         $require,
8955         $filename);
8956   }
8957   public function children(): Generator<string, EditableSyntax, void> {
8958     yield $this->_require;
8959     yield $this->_filename;
8960     yield break;
8961   }
8962 }
8963 final class InclusionDirective extends EditableSyntax {
8964   private EditableSyntax $_expression;
8965   private EditableSyntax $_semicolon;
8966   public function __construct(
8967     EditableSyntax $expression,
8968     EditableSyntax $semicolon) {
8969     parent::__construct('inclusion_directive');
8970     $this->_expression = $expression;
8971     $this->_semicolon = $semicolon;
8972   }
8973   public function expression(): EditableSyntax {
8974     return $this->_expression;
8975   }
8976   public function semicolon(): EditableSyntax {
8977     return $this->_semicolon;
8978   }
8979   public function with_expression(EditableSyntax $expression): InclusionDirective {
8980     return new InclusionDirective(
8981       $expression,
8982       $this->_semicolon);
8983   }
8984   public function with_semicolon(EditableSyntax $semicolon): InclusionDirective {
8985     return new InclusionDirective(
8986       $this->_expression,
8987       $semicolon);
8988   }
8989
8990   public function rewrite(
8991     ( function
8992       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
8993     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
8994     $new_parents = $parents ?? [];
8995     array_push($new_parents, $this);
8996     $expression = $this->expression()->rewrite($rewriter, $new_parents);
8997     $semicolon = $this->semicolon()->rewrite($rewriter, $new_parents);
8998     if (
8999       $expression === $this->expression() &&
9000       $semicolon === $this->semicolon()) {
9001       return $rewriter($this, $parents ?? []);
9002     } else {
9003       return $rewriter(new InclusionDirective(
9004         $expression,
9005         $semicolon), $parents ?? []);
9006     }
9007   }
9008
9009   public static function from_json(mixed $json, int $position, string $source) {
9010     $expression = EditableSyntax::from_json(
9011       $json->inclusion_expression, $position, $source);
9012     $position += $expression->width();
9013     $semicolon = EditableSyntax::from_json(
9014       $json->inclusion_semicolon, $position, $source);
9015     $position += $semicolon->width();
9016     return new InclusionDirective(
9017         $expression,
9018         $semicolon);
9019   }
9020   public function children(): Generator<string, EditableSyntax, void> {
9021     yield $this->_expression;
9022     yield $this->_semicolon;
9023     yield break;
9024   }
9025 }
9026 final class CompoundStatement extends EditableSyntax {
9027   private EditableSyntax $_left_brace;
9028   private EditableSyntax $_statements;
9029   private EditableSyntax $_right_brace;
9030   public function __construct(
9031     EditableSyntax $left_brace,
9032     EditableSyntax $statements,
9033     EditableSyntax $right_brace) {
9034     parent::__construct('compound_statement');
9035     $this->_left_brace = $left_brace;
9036     $this->_statements = $statements;
9037     $this->_right_brace = $right_brace;
9038   }
9039   public function left_brace(): EditableSyntax {
9040     return $this->_left_brace;
9041   }
9042   public function statements(): EditableSyntax {
9043     return $this->_statements;
9044   }
9045   public function right_brace(): EditableSyntax {
9046     return $this->_right_brace;
9047   }
9048   public function with_left_brace(EditableSyntax $left_brace): CompoundStatement {
9049     return new CompoundStatement(
9050       $left_brace,
9051       $this->_statements,
9052       $this->_right_brace);
9053   }
9054   public function with_statements(EditableSyntax $statements): CompoundStatement {
9055     return new CompoundStatement(
9056       $this->_left_brace,
9057       $statements,
9058       $this->_right_brace);
9059   }
9060   public function with_right_brace(EditableSyntax $right_brace): CompoundStatement {
9061     return new CompoundStatement(
9062       $this->_left_brace,
9063       $this->_statements,
9064       $right_brace);
9065   }
9066
9067   public function rewrite(
9068     ( function
9069       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
9070     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
9071     $new_parents = $parents ?? [];
9072     array_push($new_parents, $this);
9073     $left_brace = $this->left_brace()->rewrite($rewriter, $new_parents);
9074     $statements = $this->statements()->rewrite($rewriter, $new_parents);
9075     $right_brace = $this->right_brace()->rewrite($rewriter, $new_parents);
9076     if (
9077       $left_brace === $this->left_brace() &&
9078       $statements === $this->statements() &&
9079       $right_brace === $this->right_brace()) {
9080       return $rewriter($this, $parents ?? []);
9081     } else {
9082       return $rewriter(new CompoundStatement(
9083         $left_brace,
9084         $statements,
9085         $right_brace), $parents ?? []);
9086     }
9087   }
9088
9089   public static function from_json(mixed $json, int $position, string $source) {
9090     $left_brace = EditableSyntax::from_json(
9091       $json->compound_left_brace, $position, $source);
9092     $position += $left_brace->width();
9093     $statements = EditableSyntax::from_json(
9094       $json->compound_statements, $position, $source);
9095     $position += $statements->width();
9096     $right_brace = EditableSyntax::from_json(
9097       $json->compound_right_brace, $position, $source);
9098     $position += $right_brace->width();
9099     return new CompoundStatement(
9100         $left_brace,
9101         $statements,
9102         $right_brace);
9103   }
9104   public function children(): Generator<string, EditableSyntax, void> {
9105     yield $this->_left_brace;
9106     yield $this->_statements;
9107     yield $this->_right_brace;
9108     yield break;
9109   }
9110 }
9111 final class ExpressionStatement extends EditableSyntax {
9112   private EditableSyntax $_expression;
9113   private EditableSyntax $_semicolon;
9114   public function __construct(
9115     EditableSyntax $expression,
9116     EditableSyntax $semicolon) {
9117     parent::__construct('expression_statement');
9118     $this->_expression = $expression;
9119     $this->_semicolon = $semicolon;
9120   }
9121   public function expression(): EditableSyntax {
9122     return $this->_expression;
9123   }
9124   public function semicolon(): EditableSyntax {
9125     return $this->_semicolon;
9126   }
9127   public function with_expression(EditableSyntax $expression): ExpressionStatement {
9128     return new ExpressionStatement(
9129       $expression,
9130       $this->_semicolon);
9131   }
9132   public function with_semicolon(EditableSyntax $semicolon): ExpressionStatement {
9133     return new ExpressionStatement(
9134       $this->_expression,
9135       $semicolon);
9136   }
9137
9138   public function rewrite(
9139     ( function
9140       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
9141     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
9142     $new_parents = $parents ?? [];
9143     array_push($new_parents, $this);
9144     $expression = $this->expression()->rewrite($rewriter, $new_parents);
9145     $semicolon = $this->semicolon()->rewrite($rewriter, $new_parents);
9146     if (
9147       $expression === $this->expression() &&
9148       $semicolon === $this->semicolon()) {
9149       return $rewriter($this, $parents ?? []);
9150     } else {
9151       return $rewriter(new ExpressionStatement(
9152         $expression,
9153         $semicolon), $parents ?? []);
9154     }
9155   }
9156
9157   public static function from_json(mixed $json, int $position, string $source) {
9158     $expression = EditableSyntax::from_json(
9159       $json->expression_statement_expression, $position, $source);
9160     $position += $expression->width();
9161     $semicolon = EditableSyntax::from_json(
9162       $json->expression_statement_semicolon, $position, $source);
9163     $position += $semicolon->width();
9164     return new ExpressionStatement(
9165         $expression,
9166         $semicolon);
9167   }
9168   public function children(): Generator<string, EditableSyntax, void> {
9169     yield $this->_expression;
9170     yield $this->_semicolon;
9171     yield break;
9172   }
9173 }
9174 final class MarkupSection extends EditableSyntax {
9175   private EditableSyntax $_prefix;
9176   private EditableSyntax $_text;
9177   private EditableSyntax $_suffix;
9178   private EditableSyntax $_expression;
9179   public function __construct(
9180     EditableSyntax $prefix,
9181     EditableSyntax $text,
9182     EditableSyntax $suffix,
9183     EditableSyntax $expression) {
9184     parent::__construct('markup_section');
9185     $this->_prefix = $prefix;
9186     $this->_text = $text;
9187     $this->_suffix = $suffix;
9188     $this->_expression = $expression;
9189   }
9190   public function prefix(): EditableSyntax {
9191     return $this->_prefix;
9192   }
9193   public function text(): EditableSyntax {
9194     return $this->_text;
9195   }
9196   public function suffix(): EditableSyntax {
9197     return $this->_suffix;
9198   }
9199   public function expression(): EditableSyntax {
9200     return $this->_expression;
9201   }
9202   public function with_prefix(EditableSyntax $prefix): MarkupSection {
9203     return new MarkupSection(
9204       $prefix,
9205       $this->_text,
9206       $this->_suffix,
9207       $this->_expression);
9208   }
9209   public function with_text(EditableSyntax $text): MarkupSection {
9210     return new MarkupSection(
9211       $this->_prefix,
9212       $text,
9213       $this->_suffix,
9214       $this->_expression);
9215   }
9216   public function with_suffix(EditableSyntax $suffix): MarkupSection {
9217     return new MarkupSection(
9218       $this->_prefix,
9219       $this->_text,
9220       $suffix,
9221       $this->_expression);
9222   }
9223   public function with_expression(EditableSyntax $expression): MarkupSection {
9224     return new MarkupSection(
9225       $this->_prefix,
9226       $this->_text,
9227       $this->_suffix,
9228       $expression);
9229   }
9230
9231   public function rewrite(
9232     ( function
9233       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
9234     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
9235     $new_parents = $parents ?? [];
9236     array_push($new_parents, $this);
9237     $prefix = $this->prefix()->rewrite($rewriter, $new_parents);
9238     $text = $this->text()->rewrite($rewriter, $new_parents);
9239     $suffix = $this->suffix()->rewrite($rewriter, $new_parents);
9240     $expression = $this->expression()->rewrite($rewriter, $new_parents);
9241     if (
9242       $prefix === $this->prefix() &&
9243       $text === $this->text() &&
9244       $suffix === $this->suffix() &&
9245       $expression === $this->expression()) {
9246       return $rewriter($this, $parents ?? []);
9247     } else {
9248       return $rewriter(new MarkupSection(
9249         $prefix,
9250         $text,
9251         $suffix,
9252         $expression), $parents ?? []);
9253     }
9254   }
9255
9256   public static function from_json(mixed $json, int $position, string $source) {
9257     $prefix = EditableSyntax::from_json(
9258       $json->markup_prefix, $position, $source);
9259     $position += $prefix->width();
9260     $text = EditableSyntax::from_json(
9261       $json->markup_text, $position, $source);
9262     $position += $text->width();
9263     $suffix = EditableSyntax::from_json(
9264       $json->markup_suffix, $position, $source);
9265     $position += $suffix->width();
9266     $expression = EditableSyntax::from_json(
9267       $json->markup_expression, $position, $source);
9268     $position += $expression->width();
9269     return new MarkupSection(
9270         $prefix,
9271         $text,
9272         $suffix,
9273         $expression);
9274   }
9275   public function children(): Generator<string, EditableSyntax, void> {
9276     yield $this->_prefix;
9277     yield $this->_text;
9278     yield $this->_suffix;
9279     yield $this->_expression;
9280     yield break;
9281   }
9282 }
9283 final class MarkupSuffix extends EditableSyntax {
9284   private EditableSyntax $_less_than_question;
9285   private EditableSyntax $_name;
9286   public function __construct(
9287     EditableSyntax $less_than_question,
9288     EditableSyntax $name) {
9289     parent::__construct('markup_suffix');
9290     $this->_less_than_question = $less_than_question;
9291     $this->_name = $name;
9292   }
9293   public function less_than_question(): EditableSyntax {
9294     return $this->_less_than_question;
9295   }
9296   public function name(): EditableSyntax {
9297     return $this->_name;
9298   }
9299   public function with_less_than_question(EditableSyntax $less_than_question): MarkupSuffix {
9300     return new MarkupSuffix(
9301       $less_than_question,
9302       $this->_name);
9303   }
9304   public function with_name(EditableSyntax $name): MarkupSuffix {
9305     return new MarkupSuffix(
9306       $this->_less_than_question,
9307       $name);
9308   }
9309
9310   public function rewrite(
9311     ( function
9312       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
9313     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
9314     $new_parents = $parents ?? [];
9315     array_push($new_parents, $this);
9316     $less_than_question = $this->less_than_question()->rewrite($rewriter, $new_parents);
9317     $name = $this->name()->rewrite($rewriter, $new_parents);
9318     if (
9319       $less_than_question === $this->less_than_question() &&
9320       $name === $this->name()) {
9321       return $rewriter($this, $parents ?? []);
9322     } else {
9323       return $rewriter(new MarkupSuffix(
9324         $less_than_question,
9325         $name), $parents ?? []);
9326     }
9327   }
9328
9329   public static function from_json(mixed $json, int $position, string $source) {
9330     $less_than_question = EditableSyntax::from_json(
9331       $json->markup_suffix_less_than_question, $position, $source);
9332     $position += $less_than_question->width();
9333     $name = EditableSyntax::from_json(
9334       $json->markup_suffix_name, $position, $source);
9335     $position += $name->width();
9336     return new MarkupSuffix(
9337         $less_than_question,
9338         $name);
9339   }
9340   public function children(): Generator<string, EditableSyntax, void> {
9341     yield $this->_less_than_question;
9342     yield $this->_name;
9343     yield break;
9344   }
9345 }
9346 final class UnsetStatement extends EditableSyntax {
9347   private EditableSyntax $_keyword;
9348   private EditableSyntax $_left_paren;
9349   private EditableSyntax $_variables;
9350   private EditableSyntax $_right_paren;
9351   private EditableSyntax $_semicolon;
9352   public function __construct(
9353     EditableSyntax $keyword,
9354     EditableSyntax $left_paren,
9355     EditableSyntax $variables,
9356     EditableSyntax $right_paren,
9357     EditableSyntax $semicolon) {
9358     parent::__construct('unset_statement');
9359     $this->_keyword = $keyword;
9360     $this->_left_paren = $left_paren;
9361     $this->_variables = $variables;
9362     $this->_right_paren = $right_paren;
9363     $this->_semicolon = $semicolon;
9364   }
9365   public function keyword(): EditableSyntax {
9366     return $this->_keyword;
9367   }
9368   public function left_paren(): EditableSyntax {
9369     return $this->_left_paren;
9370   }
9371   public function variables(): EditableSyntax {
9372     return $this->_variables;
9373   }
9374   public function right_paren(): EditableSyntax {
9375     return $this->_right_paren;
9376   }
9377   public function semicolon(): EditableSyntax {
9378     return $this->_semicolon;
9379   }
9380   public function with_keyword(EditableSyntax $keyword): UnsetStatement {
9381     return new UnsetStatement(
9382       $keyword,
9383       $this->_left_paren,
9384       $this->_variables,
9385       $this->_right_paren,
9386       $this->_semicolon);
9387   }
9388   public function with_left_paren(EditableSyntax $left_paren): UnsetStatement {
9389     return new UnsetStatement(
9390       $this->_keyword,
9391       $left_paren,
9392       $this->_variables,
9393       $this->_right_paren,
9394       $this->_semicolon);
9395   }
9396   public function with_variables(EditableSyntax $variables): UnsetStatement {
9397     return new UnsetStatement(
9398       $this->_keyword,
9399       $this->_left_paren,
9400       $variables,
9401       $this->_right_paren,
9402       $this->_semicolon);
9403   }
9404   public function with_right_paren(EditableSyntax $right_paren): UnsetStatement {
9405     return new UnsetStatement(
9406       $this->_keyword,
9407       $this->_left_paren,
9408       $this->_variables,
9409       $right_paren,
9410       $this->_semicolon);
9411   }
9412   public function with_semicolon(EditableSyntax $semicolon): UnsetStatement {
9413     return new UnsetStatement(
9414       $this->_keyword,
9415       $this->_left_paren,
9416       $this->_variables,
9417       $this->_right_paren,
9418       $semicolon);
9419   }
9420
9421   public function rewrite(
9422     ( function
9423       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
9424     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
9425     $new_parents = $parents ?? [];
9426     array_push($new_parents, $this);
9427     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
9428     $left_paren = $this->left_paren()->rewrite($rewriter, $new_parents);
9429     $variables = $this->variables()->rewrite($rewriter, $new_parents);
9430     $right_paren = $this->right_paren()->rewrite($rewriter, $new_parents);
9431     $semicolon = $this->semicolon()->rewrite($rewriter, $new_parents);
9432     if (
9433       $keyword === $this->keyword() &&
9434       $left_paren === $this->left_paren() &&
9435       $variables === $this->variables() &&
9436       $right_paren === $this->right_paren() &&
9437       $semicolon === $this->semicolon()) {
9438       return $rewriter($this, $parents ?? []);
9439     } else {
9440       return $rewriter(new UnsetStatement(
9441         $keyword,
9442         $left_paren,
9443         $variables,
9444         $right_paren,
9445         $semicolon), $parents ?? []);
9446     }
9447   }
9448
9449   public static function from_json(mixed $json, int $position, string $source) {
9450     $keyword = EditableSyntax::from_json(
9451       $json->unset_keyword, $position, $source);
9452     $position += $keyword->width();
9453     $left_paren = EditableSyntax::from_json(
9454       $json->unset_left_paren, $position, $source);
9455     $position += $left_paren->width();
9456     $variables = EditableSyntax::from_json(
9457       $json->unset_variables, $position, $source);
9458     $position += $variables->width();
9459     $right_paren = EditableSyntax::from_json(
9460       $json->unset_right_paren, $position, $source);
9461     $position += $right_paren->width();
9462     $semicolon = EditableSyntax::from_json(
9463       $json->unset_semicolon, $position, $source);
9464     $position += $semicolon->width();
9465     return new UnsetStatement(
9466         $keyword,
9467         $left_paren,
9468         $variables,
9469         $right_paren,
9470         $semicolon);
9471   }
9472   public function children(): Generator<string, EditableSyntax, void> {
9473     yield $this->_keyword;
9474     yield $this->_left_paren;
9475     yield $this->_variables;
9476     yield $this->_right_paren;
9477     yield $this->_semicolon;
9478     yield break;
9479   }
9480 }
9481 final class UsingStatementBlockScoped extends EditableSyntax {
9482   private EditableSyntax $_await_keyword;
9483   private EditableSyntax $_using_keyword;
9484   private EditableSyntax $_left_paren;
9485   private EditableSyntax $_expressions;
9486   private EditableSyntax $_right_paren;
9487   private EditableSyntax $_body;
9488   public function __construct(
9489     EditableSyntax $await_keyword,
9490     EditableSyntax $using_keyword,
9491     EditableSyntax $left_paren,
9492     EditableSyntax $expressions,
9493     EditableSyntax $right_paren,
9494     EditableSyntax $body) {
9495     parent::__construct('using_statement_block_scoped');
9496     $this->_await_keyword = $await_keyword;
9497     $this->_using_keyword = $using_keyword;
9498     $this->_left_paren = $left_paren;
9499     $this->_expressions = $expressions;
9500     $this->_right_paren = $right_paren;
9501     $this->_body = $body;
9502   }
9503   public function await_keyword(): EditableSyntax {
9504     return $this->_await_keyword;
9505   }
9506   public function using_keyword(): EditableSyntax {
9507     return $this->_using_keyword;
9508   }
9509   public function left_paren(): EditableSyntax {
9510     return $this->_left_paren;
9511   }
9512   public function expressions(): EditableSyntax {
9513     return $this->_expressions;
9514   }
9515   public function right_paren(): EditableSyntax {
9516     return $this->_right_paren;
9517   }
9518   public function body(): EditableSyntax {
9519     return $this->_body;
9520   }
9521   public function with_await_keyword(EditableSyntax $await_keyword): UsingStatementBlockScoped {
9522     return new UsingStatementBlockScoped(
9523       $await_keyword,
9524       $this->_using_keyword,
9525       $this->_left_paren,
9526       $this->_expressions,
9527       $this->_right_paren,
9528       $this->_body);
9529   }
9530   public function with_using_keyword(EditableSyntax $using_keyword): UsingStatementBlockScoped {
9531     return new UsingStatementBlockScoped(
9532       $this->_await_keyword,
9533       $using_keyword,
9534       $this->_left_paren,
9535       $this->_expressions,
9536       $this->_right_paren,
9537       $this->_body);
9538   }
9539   public function with_left_paren(EditableSyntax $left_paren): UsingStatementBlockScoped {
9540     return new UsingStatementBlockScoped(
9541       $this->_await_keyword,
9542       $this->_using_keyword,
9543       $left_paren,
9544       $this->_expressions,
9545       $this->_right_paren,
9546       $this->_body);
9547   }
9548   public function with_expressions(EditableSyntax $expressions): UsingStatementBlockScoped {
9549     return new UsingStatementBlockScoped(
9550       $this->_await_keyword,
9551       $this->_using_keyword,
9552       $this->_left_paren,
9553       $expressions,
9554       $this->_right_paren,
9555       $this->_body);
9556   }
9557   public function with_right_paren(EditableSyntax $right_paren): UsingStatementBlockScoped {
9558     return new UsingStatementBlockScoped(
9559       $this->_await_keyword,
9560       $this->_using_keyword,
9561       $this->_left_paren,
9562       $this->_expressions,
9563       $right_paren,
9564       $this->_body);
9565   }
9566   public function with_body(EditableSyntax $body): UsingStatementBlockScoped {
9567     return new UsingStatementBlockScoped(
9568       $this->_await_keyword,
9569       $this->_using_keyword,
9570       $this->_left_paren,
9571       $this->_expressions,
9572       $this->_right_paren,
9573       $body);
9574   }
9575
9576   public function rewrite(
9577     ( function
9578       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
9579     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
9580     $new_parents = $parents ?? [];
9581     array_push($new_parents, $this);
9582     $await_keyword = $this->await_keyword()->rewrite($rewriter, $new_parents);
9583     $using_keyword = $this->using_keyword()->rewrite($rewriter, $new_parents);
9584     $left_paren = $this->left_paren()->rewrite($rewriter, $new_parents);
9585     $expressions = $this->expressions()->rewrite($rewriter, $new_parents);
9586     $right_paren = $this->right_paren()->rewrite($rewriter, $new_parents);
9587     $body = $this->body()->rewrite($rewriter, $new_parents);
9588     if (
9589       $await_keyword === $this->await_keyword() &&
9590       $using_keyword === $this->using_keyword() &&
9591       $left_paren === $this->left_paren() &&
9592       $expressions === $this->expressions() &&
9593       $right_paren === $this->right_paren() &&
9594       $body === $this->body()) {
9595       return $rewriter($this, $parents ?? []);
9596     } else {
9597       return $rewriter(new UsingStatementBlockScoped(
9598         $await_keyword,
9599         $using_keyword,
9600         $left_paren,
9601         $expressions,
9602         $right_paren,
9603         $body), $parents ?? []);
9604     }
9605   }
9606
9607   public static function from_json(mixed $json, int $position, string $source) {
9608     $await_keyword = EditableSyntax::from_json(
9609       $json->using_block_await_keyword, $position, $source);
9610     $position += $await_keyword->width();
9611     $using_keyword = EditableSyntax::from_json(
9612       $json->using_block_using_keyword, $position, $source);
9613     $position += $using_keyword->width();
9614     $left_paren = EditableSyntax::from_json(
9615       $json->using_block_left_paren, $position, $source);
9616     $position += $left_paren->width();
9617     $expressions = EditableSyntax::from_json(
9618       $json->using_block_expressions, $position, $source);
9619     $position += $expressions->width();
9620     $right_paren = EditableSyntax::from_json(
9621       $json->using_block_right_paren, $position, $source);
9622     $position += $right_paren->width();
9623     $body = EditableSyntax::from_json(
9624       $json->using_block_body, $position, $source);
9625     $position += $body->width();
9626     return new UsingStatementBlockScoped(
9627         $await_keyword,
9628         $using_keyword,
9629         $left_paren,
9630         $expressions,
9631         $right_paren,
9632         $body);
9633   }
9634   public function children(): Generator<string, EditableSyntax, void> {
9635     yield $this->_await_keyword;
9636     yield $this->_using_keyword;
9637     yield $this->_left_paren;
9638     yield $this->_expressions;
9639     yield $this->_right_paren;
9640     yield $this->_body;
9641     yield break;
9642   }
9643 }
9644 final class UsingStatementFunctionScoped extends EditableSyntax {
9645   private EditableSyntax $_await_keyword;
9646   private EditableSyntax $_using_keyword;
9647   private EditableSyntax $_expression;
9648   private EditableSyntax $_semicolon;
9649   public function __construct(
9650     EditableSyntax $await_keyword,
9651     EditableSyntax $using_keyword,
9652     EditableSyntax $expression,
9653     EditableSyntax $semicolon) {
9654     parent::__construct('using_statement_function_scoped');
9655     $this->_await_keyword = $await_keyword;
9656     $this->_using_keyword = $using_keyword;
9657     $this->_expression = $expression;
9658     $this->_semicolon = $semicolon;
9659   }
9660   public function await_keyword(): EditableSyntax {
9661     return $this->_await_keyword;
9662   }
9663   public function using_keyword(): EditableSyntax {
9664     return $this->_using_keyword;
9665   }
9666   public function expression(): EditableSyntax {
9667     return $this->_expression;
9668   }
9669   public function semicolon(): EditableSyntax {
9670     return $this->_semicolon;
9671   }
9672   public function with_await_keyword(EditableSyntax $await_keyword): UsingStatementFunctionScoped {
9673     return new UsingStatementFunctionScoped(
9674       $await_keyword,
9675       $this->_using_keyword,
9676       $this->_expression,
9677       $this->_semicolon);
9678   }
9679   public function with_using_keyword(EditableSyntax $using_keyword): UsingStatementFunctionScoped {
9680     return new UsingStatementFunctionScoped(
9681       $this->_await_keyword,
9682       $using_keyword,
9683       $this->_expression,
9684       $this->_semicolon);
9685   }
9686   public function with_expression(EditableSyntax $expression): UsingStatementFunctionScoped {
9687     return new UsingStatementFunctionScoped(
9688       $this->_await_keyword,
9689       $this->_using_keyword,
9690       $expression,
9691       $this->_semicolon);
9692   }
9693   public function with_semicolon(EditableSyntax $semicolon): UsingStatementFunctionScoped {
9694     return new UsingStatementFunctionScoped(
9695       $this->_await_keyword,
9696       $this->_using_keyword,
9697       $this->_expression,
9698       $semicolon);
9699   }
9700
9701   public function rewrite(
9702     ( function
9703       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
9704     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
9705     $new_parents = $parents ?? [];
9706     array_push($new_parents, $this);
9707     $await_keyword = $this->await_keyword()->rewrite($rewriter, $new_parents);
9708     $using_keyword = $this->using_keyword()->rewrite($rewriter, $new_parents);
9709     $expression = $this->expression()->rewrite($rewriter, $new_parents);
9710     $semicolon = $this->semicolon()->rewrite($rewriter, $new_parents);
9711     if (
9712       $await_keyword === $this->await_keyword() &&
9713       $using_keyword === $this->using_keyword() &&
9714       $expression === $this->expression() &&
9715       $semicolon === $this->semicolon()) {
9716       return $rewriter($this, $parents ?? []);
9717     } else {
9718       return $rewriter(new UsingStatementFunctionScoped(
9719         $await_keyword,
9720         $using_keyword,
9721         $expression,
9722         $semicolon), $parents ?? []);
9723     }
9724   }
9725
9726   public static function from_json(mixed $json, int $position, string $source) {
9727     $await_keyword = EditableSyntax::from_json(
9728       $json->using_function_await_keyword, $position, $source);
9729     $position += $await_keyword->width();
9730     $using_keyword = EditableSyntax::from_json(
9731       $json->using_function_using_keyword, $position, $source);
9732     $position += $using_keyword->width();
9733     $expression = EditableSyntax::from_json(
9734       $json->using_function_expression, $position, $source);
9735     $position += $expression->width();
9736     $semicolon = EditableSyntax::from_json(
9737       $json->using_function_semicolon, $position, $source);
9738     $position += $semicolon->width();
9739     return new UsingStatementFunctionScoped(
9740         $await_keyword,
9741         $using_keyword,
9742         $expression,
9743         $semicolon);
9744   }
9745   public function children(): Generator<string, EditableSyntax, void> {
9746     yield $this->_await_keyword;
9747     yield $this->_using_keyword;
9748     yield $this->_expression;
9749     yield $this->_semicolon;
9750     yield break;
9751   }
9752 }
9753 final class DeclareDirectiveStatement extends EditableSyntax {
9754   private EditableSyntax $_keyword;
9755   private EditableSyntax $_left_paren;
9756   private EditableSyntax $_expression;
9757   private EditableSyntax $_right_paren;
9758   private EditableSyntax $_semicolon;
9759   public function __construct(
9760     EditableSyntax $keyword,
9761     EditableSyntax $left_paren,
9762     EditableSyntax $expression,
9763     EditableSyntax $right_paren,
9764     EditableSyntax $semicolon) {
9765     parent::__construct('declare_directive_statement');
9766     $this->_keyword = $keyword;
9767     $this->_left_paren = $left_paren;
9768     $this->_expression = $expression;
9769     $this->_right_paren = $right_paren;
9770     $this->_semicolon = $semicolon;
9771   }
9772   public function keyword(): EditableSyntax {
9773     return $this->_keyword;
9774   }
9775   public function left_paren(): EditableSyntax {
9776     return $this->_left_paren;
9777   }
9778   public function expression(): EditableSyntax {
9779     return $this->_expression;
9780   }
9781   public function right_paren(): EditableSyntax {
9782     return $this->_right_paren;
9783   }
9784   public function semicolon(): EditableSyntax {
9785     return $this->_semicolon;
9786   }
9787   public function with_keyword(EditableSyntax $keyword): DeclareDirectiveStatement {
9788     return new DeclareDirectiveStatement(
9789       $keyword,
9790       $this->_left_paren,
9791       $this->_expression,
9792       $this->_right_paren,
9793       $this->_semicolon);
9794   }
9795   public function with_left_paren(EditableSyntax $left_paren): DeclareDirectiveStatement {
9796     return new DeclareDirectiveStatement(
9797       $this->_keyword,
9798       $left_paren,
9799       $this->_expression,
9800       $this->_right_paren,
9801       $this->_semicolon);
9802   }
9803   public function with_expression(EditableSyntax $expression): DeclareDirectiveStatement {
9804     return new DeclareDirectiveStatement(
9805       $this->_keyword,
9806       $this->_left_paren,
9807       $expression,
9808       $this->_right_paren,
9809       $this->_semicolon);
9810   }
9811   public function with_right_paren(EditableSyntax $right_paren): DeclareDirectiveStatement {
9812     return new DeclareDirectiveStatement(
9813       $this->_keyword,
9814       $this->_left_paren,
9815       $this->_expression,
9816       $right_paren,
9817       $this->_semicolon);
9818   }
9819   public function with_semicolon(EditableSyntax $semicolon): DeclareDirectiveStatement {
9820     return new DeclareDirectiveStatement(
9821       $this->_keyword,
9822       $this->_left_paren,
9823       $this->_expression,
9824       $this->_right_paren,
9825       $semicolon);
9826   }
9827
9828   public function rewrite(
9829     ( function
9830       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
9831     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
9832     $new_parents = $parents ?? [];
9833     array_push($new_parents, $this);
9834     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
9835     $left_paren = $this->left_paren()->rewrite($rewriter, $new_parents);
9836     $expression = $this->expression()->rewrite($rewriter, $new_parents);
9837     $right_paren = $this->right_paren()->rewrite($rewriter, $new_parents);
9838     $semicolon = $this->semicolon()->rewrite($rewriter, $new_parents);
9839     if (
9840       $keyword === $this->keyword() &&
9841       $left_paren === $this->left_paren() &&
9842       $expression === $this->expression() &&
9843       $right_paren === $this->right_paren() &&
9844       $semicolon === $this->semicolon()) {
9845       return $rewriter($this, $parents ?? []);
9846     } else {
9847       return $rewriter(new DeclareDirectiveStatement(
9848         $keyword,
9849         $left_paren,
9850         $expression,
9851         $right_paren,
9852         $semicolon), $parents ?? []);
9853     }
9854   }
9855
9856   public static function from_json(mixed $json, int $position, string $source) {
9857     $keyword = EditableSyntax::from_json(
9858       $json->declare_directive_keyword, $position, $source);
9859     $position += $keyword->width();
9860     $left_paren = EditableSyntax::from_json(
9861       $json->declare_directive_left_paren, $position, $source);
9862     $position += $left_paren->width();
9863     $expression = EditableSyntax::from_json(
9864       $json->declare_directive_expression, $position, $source);
9865     $position += $expression->width();
9866     $right_paren = EditableSyntax::from_json(
9867       $json->declare_directive_right_paren, $position, $source);
9868     $position += $right_paren->width();
9869     $semicolon = EditableSyntax::from_json(
9870       $json->declare_directive_semicolon, $position, $source);
9871     $position += $semicolon->width();
9872     return new DeclareDirectiveStatement(
9873         $keyword,
9874         $left_paren,
9875         $expression,
9876         $right_paren,
9877         $semicolon);
9878   }
9879   public function children(): Generator<string, EditableSyntax, void> {
9880     yield $this->_keyword;
9881     yield $this->_left_paren;
9882     yield $this->_expression;
9883     yield $this->_right_paren;
9884     yield $this->_semicolon;
9885     yield break;
9886   }
9887 }
9888 final class DeclareBlockStatement extends EditableSyntax {
9889   private EditableSyntax $_keyword;
9890   private EditableSyntax $_left_paren;
9891   private EditableSyntax $_expression;
9892   private EditableSyntax $_right_paren;
9893   private EditableSyntax $_body;
9894   public function __construct(
9895     EditableSyntax $keyword,
9896     EditableSyntax $left_paren,
9897     EditableSyntax $expression,
9898     EditableSyntax $right_paren,
9899     EditableSyntax $body) {
9900     parent::__construct('declare_block_statement');
9901     $this->_keyword = $keyword;
9902     $this->_left_paren = $left_paren;
9903     $this->_expression = $expression;
9904     $this->_right_paren = $right_paren;
9905     $this->_body = $body;
9906   }
9907   public function keyword(): EditableSyntax {
9908     return $this->_keyword;
9909   }
9910   public function left_paren(): EditableSyntax {
9911     return $this->_left_paren;
9912   }
9913   public function expression(): EditableSyntax {
9914     return $this->_expression;
9915   }
9916   public function right_paren(): EditableSyntax {
9917     return $this->_right_paren;
9918   }
9919   public function body(): EditableSyntax {
9920     return $this->_body;
9921   }
9922   public function with_keyword(EditableSyntax $keyword): DeclareBlockStatement {
9923     return new DeclareBlockStatement(
9924       $keyword,
9925       $this->_left_paren,
9926       $this->_expression,
9927       $this->_right_paren,
9928       $this->_body);
9929   }
9930   public function with_left_paren(EditableSyntax $left_paren): DeclareBlockStatement {
9931     return new DeclareBlockStatement(
9932       $this->_keyword,
9933       $left_paren,
9934       $this->_expression,
9935       $this->_right_paren,
9936       $this->_body);
9937   }
9938   public function with_expression(EditableSyntax $expression): DeclareBlockStatement {
9939     return new DeclareBlockStatement(
9940       $this->_keyword,
9941       $this->_left_paren,
9942       $expression,
9943       $this->_right_paren,
9944       $this->_body);
9945   }
9946   public function with_right_paren(EditableSyntax $right_paren): DeclareBlockStatement {
9947     return new DeclareBlockStatement(
9948       $this->_keyword,
9949       $this->_left_paren,
9950       $this->_expression,
9951       $right_paren,
9952       $this->_body);
9953   }
9954   public function with_body(EditableSyntax $body): DeclareBlockStatement {
9955     return new DeclareBlockStatement(
9956       $this->_keyword,
9957       $this->_left_paren,
9958       $this->_expression,
9959       $this->_right_paren,
9960       $body);
9961   }
9962
9963   public function rewrite(
9964     ( function
9965       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
9966     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
9967     $new_parents = $parents ?? [];
9968     array_push($new_parents, $this);
9969     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
9970     $left_paren = $this->left_paren()->rewrite($rewriter, $new_parents);
9971     $expression = $this->expression()->rewrite($rewriter, $new_parents);
9972     $right_paren = $this->right_paren()->rewrite($rewriter, $new_parents);
9973     $body = $this->body()->rewrite($rewriter, $new_parents);
9974     if (
9975       $keyword === $this->keyword() &&
9976       $left_paren === $this->left_paren() &&
9977       $expression === $this->expression() &&
9978       $right_paren === $this->right_paren() &&
9979       $body === $this->body()) {
9980       return $rewriter($this, $parents ?? []);
9981     } else {
9982       return $rewriter(new DeclareBlockStatement(
9983         $keyword,
9984         $left_paren,
9985         $expression,
9986         $right_paren,
9987         $body), $parents ?? []);
9988     }
9989   }
9990
9991   public static function from_json(mixed $json, int $position, string $source) {
9992     $keyword = EditableSyntax::from_json(
9993       $json->declare_block_keyword, $position, $source);
9994     $position += $keyword->width();
9995     $left_paren = EditableSyntax::from_json(
9996       $json->declare_block_left_paren, $position, $source);
9997     $position += $left_paren->width();
9998     $expression = EditableSyntax::from_json(
9999       $json->declare_block_expression, $position, $source);
10000     $position += $expression->width();
10001     $right_paren = EditableSyntax::from_json(
10002       $json->declare_block_right_paren, $position, $source);
10003     $position += $right_paren->width();
10004     $body = EditableSyntax::from_json(
10005       $json->declare_block_body, $position, $source);
10006     $position += $body->width();
10007     return new DeclareBlockStatement(
10008         $keyword,
10009         $left_paren,
10010         $expression,
10011         $right_paren,
10012         $body);
10013   }
10014   public function children(): Generator<string, EditableSyntax, void> {
10015     yield $this->_keyword;
10016     yield $this->_left_paren;
10017     yield $this->_expression;
10018     yield $this->_right_paren;
10019     yield $this->_body;
10020     yield break;
10021   }
10022 }
10023 final class WhileStatement extends EditableSyntax {
10024   private EditableSyntax $_keyword;
10025   private EditableSyntax $_left_paren;
10026   private EditableSyntax $_condition;
10027   private EditableSyntax $_right_paren;
10028   private EditableSyntax $_body;
10029   public function __construct(
10030     EditableSyntax $keyword,
10031     EditableSyntax $left_paren,
10032     EditableSyntax $condition,
10033     EditableSyntax $right_paren,
10034     EditableSyntax $body) {
10035     parent::__construct('while_statement');
10036     $this->_keyword = $keyword;
10037     $this->_left_paren = $left_paren;
10038     $this->_condition = $condition;
10039     $this->_right_paren = $right_paren;
10040     $this->_body = $body;
10041   }
10042   public function keyword(): EditableSyntax {
10043     return $this->_keyword;
10044   }
10045   public function left_paren(): EditableSyntax {
10046     return $this->_left_paren;
10047   }
10048   public function condition(): EditableSyntax {
10049     return $this->_condition;
10050   }
10051   public function right_paren(): EditableSyntax {
10052     return $this->_right_paren;
10053   }
10054   public function body(): EditableSyntax {
10055     return $this->_body;
10056   }
10057   public function with_keyword(EditableSyntax $keyword): WhileStatement {
10058     return new WhileStatement(
10059       $keyword,
10060       $this->_left_paren,
10061       $this->_condition,
10062       $this->_right_paren,
10063       $this->_body);
10064   }
10065   public function with_left_paren(EditableSyntax $left_paren): WhileStatement {
10066     return new WhileStatement(
10067       $this->_keyword,
10068       $left_paren,
10069       $this->_condition,
10070       $this->_right_paren,
10071       $this->_body);
10072   }
10073   public function with_condition(EditableSyntax $condition): WhileStatement {
10074     return new WhileStatement(
10075       $this->_keyword,
10076       $this->_left_paren,
10077       $condition,
10078       $this->_right_paren,
10079       $this->_body);
10080   }
10081   public function with_right_paren(EditableSyntax $right_paren): WhileStatement {
10082     return new WhileStatement(
10083       $this->_keyword,
10084       $this->_left_paren,
10085       $this->_condition,
10086       $right_paren,
10087       $this->_body);
10088   }
10089   public function with_body(EditableSyntax $body): WhileStatement {
10090     return new WhileStatement(
10091       $this->_keyword,
10092       $this->_left_paren,
10093       $this->_condition,
10094       $this->_right_paren,
10095       $body);
10096   }
10097
10098   public function rewrite(
10099     ( function
10100       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
10101     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
10102     $new_parents = $parents ?? [];
10103     array_push($new_parents, $this);
10104     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
10105     $left_paren = $this->left_paren()->rewrite($rewriter, $new_parents);
10106     $condition = $this->condition()->rewrite($rewriter, $new_parents);
10107     $right_paren = $this->right_paren()->rewrite($rewriter, $new_parents);
10108     $body = $this->body()->rewrite($rewriter, $new_parents);
10109     if (
10110       $keyword === $this->keyword() &&
10111       $left_paren === $this->left_paren() &&
10112       $condition === $this->condition() &&
10113       $right_paren === $this->right_paren() &&
10114       $body === $this->body()) {
10115       return $rewriter($this, $parents ?? []);
10116     } else {
10117       return $rewriter(new WhileStatement(
10118         $keyword,
10119         $left_paren,
10120         $condition,
10121         $right_paren,
10122         $body), $parents ?? []);
10123     }
10124   }
10125
10126   public static function from_json(mixed $json, int $position, string $source) {
10127     $keyword = EditableSyntax::from_json(
10128       $json->while_keyword, $position, $source);
10129     $position += $keyword->width();
10130     $left_paren = EditableSyntax::from_json(
10131       $json->while_left_paren, $position, $source);
10132     $position += $left_paren->width();
10133     $condition = EditableSyntax::from_json(
10134       $json->while_condition, $position, $source);
10135     $position += $condition->width();
10136     $right_paren = EditableSyntax::from_json(
10137       $json->while_right_paren, $position, $source);
10138     $position += $right_paren->width();
10139     $body = EditableSyntax::from_json(
10140       $json->while_body, $position, $source);
10141     $position += $body->width();
10142     return new WhileStatement(
10143         $keyword,
10144         $left_paren,
10145         $condition,
10146         $right_paren,
10147         $body);
10148   }
10149   public function children(): Generator<string, EditableSyntax, void> {
10150     yield $this->_keyword;
10151     yield $this->_left_paren;
10152     yield $this->_condition;
10153     yield $this->_right_paren;
10154     yield $this->_body;
10155     yield break;
10156   }
10157 }
10158 final class IfStatement extends EditableSyntax {
10159   private EditableSyntax $_keyword;
10160   private EditableSyntax $_left_paren;
10161   private EditableSyntax $_condition;
10162   private EditableSyntax $_right_paren;
10163   private EditableSyntax $_statement;
10164   private EditableSyntax $_elseif_clauses;
10165   private EditableSyntax $_else_clause;
10166   public function __construct(
10167     EditableSyntax $keyword,
10168     EditableSyntax $left_paren,
10169     EditableSyntax $condition,
10170     EditableSyntax $right_paren,
10171     EditableSyntax $statement,
10172     EditableSyntax $elseif_clauses,
10173     EditableSyntax $else_clause) {
10174     parent::__construct('if_statement');
10175     $this->_keyword = $keyword;
10176     $this->_left_paren = $left_paren;
10177     $this->_condition = $condition;
10178     $this->_right_paren = $right_paren;
10179     $this->_statement = $statement;
10180     $this->_elseif_clauses = $elseif_clauses;
10181     $this->_else_clause = $else_clause;
10182   }
10183   public function keyword(): EditableSyntax {
10184     return $this->_keyword;
10185   }
10186   public function left_paren(): EditableSyntax {
10187     return $this->_left_paren;
10188   }
10189   public function condition(): EditableSyntax {
10190     return $this->_condition;
10191   }
10192   public function right_paren(): EditableSyntax {
10193     return $this->_right_paren;
10194   }
10195   public function statement(): EditableSyntax {
10196     return $this->_statement;
10197   }
10198   public function elseif_clauses(): EditableSyntax {
10199     return $this->_elseif_clauses;
10200   }
10201   public function else_clause(): EditableSyntax {
10202     return $this->_else_clause;
10203   }
10204   public function with_keyword(EditableSyntax $keyword): IfStatement {
10205     return new IfStatement(
10206       $keyword,
10207       $this->_left_paren,
10208       $this->_condition,
10209       $this->_right_paren,
10210       $this->_statement,
10211       $this->_elseif_clauses,
10212       $this->_else_clause);
10213   }
10214   public function with_left_paren(EditableSyntax $left_paren): IfStatement {
10215     return new IfStatement(
10216       $this->_keyword,
10217       $left_paren,
10218       $this->_condition,
10219       $this->_right_paren,
10220       $this->_statement,
10221       $this->_elseif_clauses,
10222       $this->_else_clause);
10223   }
10224   public function with_condition(EditableSyntax $condition): IfStatement {
10225     return new IfStatement(
10226       $this->_keyword,
10227       $this->_left_paren,
10228       $condition,
10229       $this->_right_paren,
10230       $this->_statement,
10231       $this->_elseif_clauses,
10232       $this->_else_clause);
10233   }
10234   public function with_right_paren(EditableSyntax $right_paren): IfStatement {
10235     return new IfStatement(
10236       $this->_keyword,
10237       $this->_left_paren,
10238       $this->_condition,
10239       $right_paren,
10240       $this->_statement,
10241       $this->_elseif_clauses,
10242       $this->_else_clause);
10243   }
10244   public function with_statement(EditableSyntax $statement): IfStatement {
10245     return new IfStatement(
10246       $this->_keyword,
10247       $this->_left_paren,
10248       $this->_condition,
10249       $this->_right_paren,
10250       $statement,
10251       $this->_elseif_clauses,
10252       $this->_else_clause);
10253   }
10254   public function with_elseif_clauses(EditableSyntax $elseif_clauses): IfStatement {
10255     return new IfStatement(
10256       $this->_keyword,
10257       $this->_left_paren,
10258       $this->_condition,
10259       $this->_right_paren,
10260       $this->_statement,
10261       $elseif_clauses,
10262       $this->_else_clause);
10263   }
10264   public function with_else_clause(EditableSyntax $else_clause): IfStatement {
10265     return new IfStatement(
10266       $this->_keyword,
10267       $this->_left_paren,
10268       $this->_condition,
10269       $this->_right_paren,
10270       $this->_statement,
10271       $this->_elseif_clauses,
10272       $else_clause);
10273   }
10274
10275   public function rewrite(
10276     ( function
10277       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
10278     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
10279     $new_parents = $parents ?? [];
10280     array_push($new_parents, $this);
10281     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
10282     $left_paren = $this->left_paren()->rewrite($rewriter, $new_parents);
10283     $condition = $this->condition()->rewrite($rewriter, $new_parents);
10284     $right_paren = $this->right_paren()->rewrite($rewriter, $new_parents);
10285     $statement = $this->statement()->rewrite($rewriter, $new_parents);
10286     $elseif_clauses = $this->elseif_clauses()->rewrite($rewriter, $new_parents);
10287     $else_clause = $this->else_clause()->rewrite($rewriter, $new_parents);
10288     if (
10289       $keyword === $this->keyword() &&
10290       $left_paren === $this->left_paren() &&
10291       $condition === $this->condition() &&
10292       $right_paren === $this->right_paren() &&
10293       $statement === $this->statement() &&
10294       $elseif_clauses === $this->elseif_clauses() &&
10295       $else_clause === $this->else_clause()) {
10296       return $rewriter($this, $parents ?? []);
10297     } else {
10298       return $rewriter(new IfStatement(
10299         $keyword,
10300         $left_paren,
10301         $condition,
10302         $right_paren,
10303         $statement,
10304         $elseif_clauses,
10305         $else_clause), $parents ?? []);
10306     }
10307   }
10308
10309   public static function from_json(mixed $json, int $position, string $source) {
10310     $keyword = EditableSyntax::from_json(
10311       $json->if_keyword, $position, $source);
10312     $position += $keyword->width();
10313     $left_paren = EditableSyntax::from_json(
10314       $json->if_left_paren, $position, $source);
10315     $position += $left_paren->width();
10316     $condition = EditableSyntax::from_json(
10317       $json->if_condition, $position, $source);
10318     $position += $condition->width();
10319     $right_paren = EditableSyntax::from_json(
10320       $json->if_right_paren, $position, $source);
10321     $position += $right_paren->width();
10322     $statement = EditableSyntax::from_json(
10323       $json->if_statement, $position, $source);
10324     $position += $statement->width();
10325     $elseif_clauses = EditableSyntax::from_json(
10326       $json->if_elseif_clauses, $position, $source);
10327     $position += $elseif_clauses->width();
10328     $else_clause = EditableSyntax::from_json(
10329       $json->if_else_clause, $position, $source);
10330     $position += $else_clause->width();
10331     return new IfStatement(
10332         $keyword,
10333         $left_paren,
10334         $condition,
10335         $right_paren,
10336         $statement,
10337         $elseif_clauses,
10338         $else_clause);
10339   }
10340   public function children(): Generator<string, EditableSyntax, void> {
10341     yield $this->_keyword;
10342     yield $this->_left_paren;
10343     yield $this->_condition;
10344     yield $this->_right_paren;
10345     yield $this->_statement;
10346     yield $this->_elseif_clauses;
10347     yield $this->_else_clause;
10348     yield break;
10349   }
10350 }
10351 final class ElseifClause extends EditableSyntax {
10352   private EditableSyntax $_keyword;
10353   private EditableSyntax $_left_paren;
10354   private EditableSyntax $_condition;
10355   private EditableSyntax $_right_paren;
10356   private EditableSyntax $_statement;
10357   public function __construct(
10358     EditableSyntax $keyword,
10359     EditableSyntax $left_paren,
10360     EditableSyntax $condition,
10361     EditableSyntax $right_paren,
10362     EditableSyntax $statement) {
10363     parent::__construct('elseif_clause');
10364     $this->_keyword = $keyword;
10365     $this->_left_paren = $left_paren;
10366     $this->_condition = $condition;
10367     $this->_right_paren = $right_paren;
10368     $this->_statement = $statement;
10369   }
10370   public function keyword(): EditableSyntax {
10371     return $this->_keyword;
10372   }
10373   public function left_paren(): EditableSyntax {
10374     return $this->_left_paren;
10375   }
10376   public function condition(): EditableSyntax {
10377     return $this->_condition;
10378   }
10379   public function right_paren(): EditableSyntax {
10380     return $this->_right_paren;
10381   }
10382   public function statement(): EditableSyntax {
10383     return $this->_statement;
10384   }
10385   public function with_keyword(EditableSyntax $keyword): ElseifClause {
10386     return new ElseifClause(
10387       $keyword,
10388       $this->_left_paren,
10389       $this->_condition,
10390       $this->_right_paren,
10391       $this->_statement);
10392   }
10393   public function with_left_paren(EditableSyntax $left_paren): ElseifClause {
10394     return new ElseifClause(
10395       $this->_keyword,
10396       $left_paren,
10397       $this->_condition,
10398       $this->_right_paren,
10399       $this->_statement);
10400   }
10401   public function with_condition(EditableSyntax $condition): ElseifClause {
10402     return new ElseifClause(
10403       $this->_keyword,
10404       $this->_left_paren,
10405       $condition,
10406       $this->_right_paren,
10407       $this->_statement);
10408   }
10409   public function with_right_paren(EditableSyntax $right_paren): ElseifClause {
10410     return new ElseifClause(
10411       $this->_keyword,
10412       $this->_left_paren,
10413       $this->_condition,
10414       $right_paren,
10415       $this->_statement);
10416   }
10417   public function with_statement(EditableSyntax $statement): ElseifClause {
10418     return new ElseifClause(
10419       $this->_keyword,
10420       $this->_left_paren,
10421       $this->_condition,
10422       $this->_right_paren,
10423       $statement);
10424   }
10425
10426   public function rewrite(
10427     ( function
10428       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
10429     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
10430     $new_parents = $parents ?? [];
10431     array_push($new_parents, $this);
10432     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
10433     $left_paren = $this->left_paren()->rewrite($rewriter, $new_parents);
10434     $condition = $this->condition()->rewrite($rewriter, $new_parents);
10435     $right_paren = $this->right_paren()->rewrite($rewriter, $new_parents);
10436     $statement = $this->statement()->rewrite($rewriter, $new_parents);
10437     if (
10438       $keyword === $this->keyword() &&
10439       $left_paren === $this->left_paren() &&
10440       $condition === $this->condition() &&
10441       $right_paren === $this->right_paren() &&
10442       $statement === $this->statement()) {
10443       return $rewriter($this, $parents ?? []);
10444     } else {
10445       return $rewriter(new ElseifClause(
10446         $keyword,
10447         $left_paren,
10448         $condition,
10449         $right_paren,
10450         $statement), $parents ?? []);
10451     }
10452   }
10453
10454   public static function from_json(mixed $json, int $position, string $source) {
10455     $keyword = EditableSyntax::from_json(
10456       $json->elseif_keyword, $position, $source);
10457     $position += $keyword->width();
10458     $left_paren = EditableSyntax::from_json(
10459       $json->elseif_left_paren, $position, $source);
10460     $position += $left_paren->width();
10461     $condition = EditableSyntax::from_json(
10462       $json->elseif_condition, $position, $source);
10463     $position += $condition->width();
10464     $right_paren = EditableSyntax::from_json(
10465       $json->elseif_right_paren, $position, $source);
10466     $position += $right_paren->width();
10467     $statement = EditableSyntax::from_json(
10468       $json->elseif_statement, $position, $source);
10469     $position += $statement->width();
10470     return new ElseifClause(
10471         $keyword,
10472         $left_paren,
10473         $condition,
10474         $right_paren,
10475         $statement);
10476   }
10477   public function children(): Generator<string, EditableSyntax, void> {
10478     yield $this->_keyword;
10479     yield $this->_left_paren;
10480     yield $this->_condition;
10481     yield $this->_right_paren;
10482     yield $this->_statement;
10483     yield break;
10484   }
10485 }
10486 final class ElseClause extends EditableSyntax {
10487   private EditableSyntax $_keyword;
10488   private EditableSyntax $_statement;
10489   public function __construct(
10490     EditableSyntax $keyword,
10491     EditableSyntax $statement) {
10492     parent::__construct('else_clause');
10493     $this->_keyword = $keyword;
10494     $this->_statement = $statement;
10495   }
10496   public function keyword(): EditableSyntax {
10497     return $this->_keyword;
10498   }
10499   public function statement(): EditableSyntax {
10500     return $this->_statement;
10501   }
10502   public function with_keyword(EditableSyntax $keyword): ElseClause {
10503     return new ElseClause(
10504       $keyword,
10505       $this->_statement);
10506   }
10507   public function with_statement(EditableSyntax $statement): ElseClause {
10508     return new ElseClause(
10509       $this->_keyword,
10510       $statement);
10511   }
10512
10513   public function rewrite(
10514     ( function
10515       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
10516     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
10517     $new_parents = $parents ?? [];
10518     array_push($new_parents, $this);
10519     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
10520     $statement = $this->statement()->rewrite($rewriter, $new_parents);
10521     if (
10522       $keyword === $this->keyword() &&
10523       $statement === $this->statement()) {
10524       return $rewriter($this, $parents ?? []);
10525     } else {
10526       return $rewriter(new ElseClause(
10527         $keyword,
10528         $statement), $parents ?? []);
10529     }
10530   }
10531
10532   public static function from_json(mixed $json, int $position, string $source) {
10533     $keyword = EditableSyntax::from_json(
10534       $json->else_keyword, $position, $source);
10535     $position += $keyword->width();
10536     $statement = EditableSyntax::from_json(
10537       $json->else_statement, $position, $source);
10538     $position += $statement->width();
10539     return new ElseClause(
10540         $keyword,
10541         $statement);
10542   }
10543   public function children(): Generator<string, EditableSyntax, void> {
10544     yield $this->_keyword;
10545     yield $this->_statement;
10546     yield break;
10547   }
10548 }
10549 final class IfEndIfStatement extends EditableSyntax {
10550   private EditableSyntax $_keyword;
10551   private EditableSyntax $_left_paren;
10552   private EditableSyntax $_condition;
10553   private EditableSyntax $_right_paren;
10554   private EditableSyntax $_colon;
10555   private EditableSyntax $_statement;
10556   private EditableSyntax $_elseif_colon_clauses;
10557   private EditableSyntax $_else_colon_clause;
10558   private EditableSyntax $_endif_keyword;
10559   private EditableSyntax $_semicolon;
10560   public function __construct(
10561     EditableSyntax $keyword,
10562     EditableSyntax $left_paren,
10563     EditableSyntax $condition,
10564     EditableSyntax $right_paren,
10565     EditableSyntax $colon,
10566     EditableSyntax $statement,
10567     EditableSyntax $elseif_colon_clauses,
10568     EditableSyntax $else_colon_clause,
10569     EditableSyntax $endif_keyword,
10570     EditableSyntax $semicolon) {
10571     parent::__construct('if_endif_statement');
10572     $this->_keyword = $keyword;
10573     $this->_left_paren = $left_paren;
10574     $this->_condition = $condition;
10575     $this->_right_paren = $right_paren;
10576     $this->_colon = $colon;
10577     $this->_statement = $statement;
10578     $this->_elseif_colon_clauses = $elseif_colon_clauses;
10579     $this->_else_colon_clause = $else_colon_clause;
10580     $this->_endif_keyword = $endif_keyword;
10581     $this->_semicolon = $semicolon;
10582   }
10583   public function keyword(): EditableSyntax {
10584     return $this->_keyword;
10585   }
10586   public function left_paren(): EditableSyntax {
10587     return $this->_left_paren;
10588   }
10589   public function condition(): EditableSyntax {
10590     return $this->_condition;
10591   }
10592   public function right_paren(): EditableSyntax {
10593     return $this->_right_paren;
10594   }
10595   public function colon(): EditableSyntax {
10596     return $this->_colon;
10597   }
10598   public function statement(): EditableSyntax {
10599     return $this->_statement;
10600   }
10601   public function elseif_colon_clauses(): EditableSyntax {
10602     return $this->_elseif_colon_clauses;
10603   }
10604   public function else_colon_clause(): EditableSyntax {
10605     return $this->_else_colon_clause;
10606   }
10607   public function endif_keyword(): EditableSyntax {
10608     return $this->_endif_keyword;
10609   }
10610   public function semicolon(): EditableSyntax {
10611     return $this->_semicolon;
10612   }
10613   public function with_keyword(EditableSyntax $keyword): IfEndIfStatement {
10614     return new IfEndIfStatement(
10615       $keyword,
10616       $this->_left_paren,
10617       $this->_condition,
10618       $this->_right_paren,
10619       $this->_colon,
10620       $this->_statement,
10621       $this->_elseif_colon_clauses,
10622       $this->_else_colon_clause,
10623       $this->_endif_keyword,
10624       $this->_semicolon);
10625   }
10626   public function with_left_paren(EditableSyntax $left_paren): IfEndIfStatement {
10627     return new IfEndIfStatement(
10628       $this->_keyword,
10629       $left_paren,
10630       $this->_condition,
10631       $this->_right_paren,
10632       $this->_colon,
10633       $this->_statement,
10634       $this->_elseif_colon_clauses,
10635       $this->_else_colon_clause,
10636       $this->_endif_keyword,
10637       $this->_semicolon);
10638   }
10639   public function with_condition(EditableSyntax $condition): IfEndIfStatement {
10640     return new IfEndIfStatement(
10641       $this->_keyword,
10642       $this->_left_paren,
10643       $condition,
10644       $this->_right_paren,
10645       $this->_colon,
10646       $this->_statement,
10647       $this->_elseif_colon_clauses,
10648       $this->_else_colon_clause,
10649       $this->_endif_keyword,
10650       $this->_semicolon);
10651   }
10652   public function with_right_paren(EditableSyntax $right_paren): IfEndIfStatement {
10653     return new IfEndIfStatement(
10654       $this->_keyword,
10655       $this->_left_paren,
10656       $this->_condition,
10657       $right_paren,
10658       $this->_colon,
10659       $this->_statement,
10660       $this->_elseif_colon_clauses,
10661       $this->_else_colon_clause,
10662       $this->_endif_keyword,
10663       $this->_semicolon);
10664   }
10665   public function with_colon(EditableSyntax $colon): IfEndIfStatement {
10666     return new IfEndIfStatement(
10667       $this->_keyword,
10668       $this->_left_paren,
10669       $this->_condition,
10670       $this->_right_paren,
10671       $colon,
10672       $this->_statement,
10673       $this->_elseif_colon_clauses,
10674       $this->_else_colon_clause,
10675       $this->_endif_keyword,
10676       $this->_semicolon);
10677   }
10678   public function with_statement(EditableSyntax $statement): IfEndIfStatement {
10679     return new IfEndIfStatement(
10680       $this->_keyword,
10681       $this->_left_paren,
10682       $this->_condition,
10683       $this->_right_paren,
10684       $this->_colon,
10685       $statement,
10686       $this->_elseif_colon_clauses,
10687       $this->_else_colon_clause,
10688       $this->_endif_keyword,
10689       $this->_semicolon);
10690   }
10691   public function with_elseif_colon_clauses(EditableSyntax $elseif_colon_clauses): IfEndIfStatement {
10692     return new IfEndIfStatement(
10693       $this->_keyword,
10694       $this->_left_paren,
10695       $this->_condition,
10696       $this->_right_paren,
10697       $this->_colon,
10698       $this->_statement,
10699       $elseif_colon_clauses,
10700       $this->_else_colon_clause,
10701       $this->_endif_keyword,
10702       $this->_semicolon);
10703   }
10704   public function with_else_colon_clause(EditableSyntax $else_colon_clause): IfEndIfStatement {
10705     return new IfEndIfStatement(
10706       $this->_keyword,
10707       $this->_left_paren,
10708       $this->_condition,
10709       $this->_right_paren,
10710       $this->_colon,
10711       $this->_statement,
10712       $this->_elseif_colon_clauses,
10713       $else_colon_clause,
10714       $this->_endif_keyword,
10715       $this->_semicolon);
10716   }
10717   public function with_endif_keyword(EditableSyntax $endif_keyword): IfEndIfStatement {
10718     return new IfEndIfStatement(
10719       $this->_keyword,
10720       $this->_left_paren,
10721       $this->_condition,
10722       $this->_right_paren,
10723       $this->_colon,
10724       $this->_statement,
10725       $this->_elseif_colon_clauses,
10726       $this->_else_colon_clause,
10727       $endif_keyword,
10728       $this->_semicolon);
10729   }
10730   public function with_semicolon(EditableSyntax $semicolon): IfEndIfStatement {
10731     return new IfEndIfStatement(
10732       $this->_keyword,
10733       $this->_left_paren,
10734       $this->_condition,
10735       $this->_right_paren,
10736       $this->_colon,
10737       $this->_statement,
10738       $this->_elseif_colon_clauses,
10739       $this->_else_colon_clause,
10740       $this->_endif_keyword,
10741       $semicolon);
10742   }
10743
10744   public function rewrite(
10745     ( function
10746       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
10747     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
10748     $new_parents = $parents ?? [];
10749     array_push($new_parents, $this);
10750     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
10751     $left_paren = $this->left_paren()->rewrite($rewriter, $new_parents);
10752     $condition = $this->condition()->rewrite($rewriter, $new_parents);
10753     $right_paren = $this->right_paren()->rewrite($rewriter, $new_parents);
10754     $colon = $this->colon()->rewrite($rewriter, $new_parents);
10755     $statement = $this->statement()->rewrite($rewriter, $new_parents);
10756     $elseif_colon_clauses = $this->elseif_colon_clauses()->rewrite($rewriter, $new_parents);
10757     $else_colon_clause = $this->else_colon_clause()->rewrite($rewriter, $new_parents);
10758     $endif_keyword = $this->endif_keyword()->rewrite($rewriter, $new_parents);
10759     $semicolon = $this->semicolon()->rewrite($rewriter, $new_parents);
10760     if (
10761       $keyword === $this->keyword() &&
10762       $left_paren === $this->left_paren() &&
10763       $condition === $this->condition() &&
10764       $right_paren === $this->right_paren() &&
10765       $colon === $this->colon() &&
10766       $statement === $this->statement() &&
10767       $elseif_colon_clauses === $this->elseif_colon_clauses() &&
10768       $else_colon_clause === $this->else_colon_clause() &&
10769       $endif_keyword === $this->endif_keyword() &&
10770       $semicolon === $this->semicolon()) {
10771       return $rewriter($this, $parents ?? []);
10772     } else {
10773       return $rewriter(new IfEndIfStatement(
10774         $keyword,
10775         $left_paren,
10776         $condition,
10777         $right_paren,
10778         $colon,
10779         $statement,
10780         $elseif_colon_clauses,
10781         $else_colon_clause,
10782         $endif_keyword,
10783         $semicolon), $parents ?? []);
10784     }
10785   }
10786
10787   public static function from_json(mixed $json, int $position, string $source) {
10788     $keyword = EditableSyntax::from_json(
10789       $json->if_endif_keyword, $position, $source);
10790     $position += $keyword->width();
10791     $left_paren = EditableSyntax::from_json(
10792       $json->if_endif_left_paren, $position, $source);
10793     $position += $left_paren->width();
10794     $condition = EditableSyntax::from_json(
10795       $json->if_endif_condition, $position, $source);
10796     $position += $condition->width();
10797     $right_paren = EditableSyntax::from_json(
10798       $json->if_endif_right_paren, $position, $source);
10799     $position += $right_paren->width();
10800     $colon = EditableSyntax::from_json(
10801       $json->if_endif_colon, $position, $source);
10802     $position += $colon->width();
10803     $statement = EditableSyntax::from_json(
10804       $json->if_endif_statement, $position, $source);
10805     $position += $statement->width();
10806     $elseif_colon_clauses = EditableSyntax::from_json(
10807       $json->if_endif_elseif_colon_clauses, $position, $source);
10808     $position += $elseif_colon_clauses->width();
10809     $else_colon_clause = EditableSyntax::from_json(
10810       $json->if_endif_else_colon_clause, $position, $source);
10811     $position += $else_colon_clause->width();
10812     $endif_keyword = EditableSyntax::from_json(
10813       $json->if_endif_endif_keyword, $position, $source);
10814     $position += $endif_keyword->width();
10815     $semicolon = EditableSyntax::from_json(
10816       $json->if_endif_semicolon, $position, $source);
10817     $position += $semicolon->width();
10818     return new IfEndIfStatement(
10819         $keyword,
10820         $left_paren,
10821         $condition,
10822         $right_paren,
10823         $colon,
10824         $statement,
10825         $elseif_colon_clauses,
10826         $else_colon_clause,
10827         $endif_keyword,
10828         $semicolon);
10829   }
10830   public function children(): Generator<string, EditableSyntax, void> {
10831     yield $this->_keyword;
10832     yield $this->_left_paren;
10833     yield $this->_condition;
10834     yield $this->_right_paren;
10835     yield $this->_colon;
10836     yield $this->_statement;
10837     yield $this->_elseif_colon_clauses;
10838     yield $this->_else_colon_clause;
10839     yield $this->_endif_keyword;
10840     yield $this->_semicolon;
10841     yield break;
10842   }
10843 }
10844 final class ElseifColonClause extends EditableSyntax {
10845   private EditableSyntax $_keyword;
10846   private EditableSyntax $_left_paren;
10847   private EditableSyntax $_condition;
10848   private EditableSyntax $_right_paren;
10849   private EditableSyntax $_colon;
10850   private EditableSyntax $_statement;
10851   public function __construct(
10852     EditableSyntax $keyword,
10853     EditableSyntax $left_paren,
10854     EditableSyntax $condition,
10855     EditableSyntax $right_paren,
10856     EditableSyntax $colon,
10857     EditableSyntax $statement) {
10858     parent::__construct('elseif_colon_clause');
10859     $this->_keyword = $keyword;
10860     $this->_left_paren = $left_paren;
10861     $this->_condition = $condition;
10862     $this->_right_paren = $right_paren;
10863     $this->_colon = $colon;
10864     $this->_statement = $statement;
10865   }
10866   public function keyword(): EditableSyntax {
10867     return $this->_keyword;
10868   }
10869   public function left_paren(): EditableSyntax {
10870     return $this->_left_paren;
10871   }
10872   public function condition(): EditableSyntax {
10873     return $this->_condition;
10874   }
10875   public function right_paren(): EditableSyntax {
10876     return $this->_right_paren;
10877   }
10878   public function colon(): EditableSyntax {
10879     return $this->_colon;
10880   }
10881   public function statement(): EditableSyntax {
10882     return $this->_statement;
10883   }
10884   public function with_keyword(EditableSyntax $keyword): ElseifColonClause {
10885     return new ElseifColonClause(
10886       $keyword,
10887       $this->_left_paren,
10888       $this->_condition,
10889       $this->_right_paren,
10890       $this->_colon,
10891       $this->_statement);
10892   }
10893   public function with_left_paren(EditableSyntax $left_paren): ElseifColonClause {
10894     return new ElseifColonClause(
10895       $this->_keyword,
10896       $left_paren,
10897       $this->_condition,
10898       $this->_right_paren,
10899       $this->_colon,
10900       $this->_statement);
10901   }
10902   public function with_condition(EditableSyntax $condition): ElseifColonClause {
10903     return new ElseifColonClause(
10904       $this->_keyword,
10905       $this->_left_paren,
10906       $condition,
10907       $this->_right_paren,
10908       $this->_colon,
10909       $this->_statement);
10910   }
10911   public function with_right_paren(EditableSyntax $right_paren): ElseifColonClause {
10912     return new ElseifColonClause(
10913       $this->_keyword,
10914       $this->_left_paren,
10915       $this->_condition,
10916       $right_paren,
10917       $this->_colon,
10918       $this->_statement);
10919   }
10920   public function with_colon(EditableSyntax $colon): ElseifColonClause {
10921     return new ElseifColonClause(
10922       $this->_keyword,
10923       $this->_left_paren,
10924       $this->_condition,
10925       $this->_right_paren,
10926       $colon,
10927       $this->_statement);
10928   }
10929   public function with_statement(EditableSyntax $statement): ElseifColonClause {
10930     return new ElseifColonClause(
10931       $this->_keyword,
10932       $this->_left_paren,
10933       $this->_condition,
10934       $this->_right_paren,
10935       $this->_colon,
10936       $statement);
10937   }
10938
10939   public function rewrite(
10940     ( function
10941       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
10942     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
10943     $new_parents = $parents ?? [];
10944     array_push($new_parents, $this);
10945     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
10946     $left_paren = $this->left_paren()->rewrite($rewriter, $new_parents);
10947     $condition = $this->condition()->rewrite($rewriter, $new_parents);
10948     $right_paren = $this->right_paren()->rewrite($rewriter, $new_parents);
10949     $colon = $this->colon()->rewrite($rewriter, $new_parents);
10950     $statement = $this->statement()->rewrite($rewriter, $new_parents);
10951     if (
10952       $keyword === $this->keyword() &&
10953       $left_paren === $this->left_paren() &&
10954       $condition === $this->condition() &&
10955       $right_paren === $this->right_paren() &&
10956       $colon === $this->colon() &&
10957       $statement === $this->statement()) {
10958       return $rewriter($this, $parents ?? []);
10959     } else {
10960       return $rewriter(new ElseifColonClause(
10961         $keyword,
10962         $left_paren,
10963         $condition,
10964         $right_paren,
10965         $colon,
10966         $statement), $parents ?? []);
10967     }
10968   }
10969
10970   public static function from_json(mixed $json, int $position, string $source) {
10971     $keyword = EditableSyntax::from_json(
10972       $json->elseif_colon_keyword, $position, $source);
10973     $position += $keyword->width();
10974     $left_paren = EditableSyntax::from_json(
10975       $json->elseif_colon_left_paren, $position, $source);
10976     $position += $left_paren->width();
10977     $condition = EditableSyntax::from_json(
10978       $json->elseif_colon_condition, $position, $source);
10979     $position += $condition->width();
10980     $right_paren = EditableSyntax::from_json(
10981       $json->elseif_colon_right_paren, $position, $source);
10982     $position += $right_paren->width();
10983     $colon = EditableSyntax::from_json(
10984       $json->elseif_colon_colon, $position, $source);
10985     $position += $colon->width();
10986     $statement = EditableSyntax::from_json(
10987       $json->elseif_colon_statement, $position, $source);
10988     $position += $statement->width();
10989     return new ElseifColonClause(
10990         $keyword,
10991         $left_paren,
10992         $condition,
10993         $right_paren,
10994         $colon,
10995         $statement);
10996   }
10997   public function children(): Generator<string, EditableSyntax, void> {
10998     yield $this->_keyword;
10999     yield $this->_left_paren;
11000     yield $this->_condition;
11001     yield $this->_right_paren;
11002     yield $this->_colon;
11003     yield $this->_statement;
11004     yield break;
11005   }
11006 }
11007 final class ElseColonClause extends EditableSyntax {
11008   private EditableSyntax $_keyword;
11009   private EditableSyntax $_colon;
11010   private EditableSyntax $_statement;
11011   public function __construct(
11012     EditableSyntax $keyword,
11013     EditableSyntax $colon,
11014     EditableSyntax $statement) {
11015     parent::__construct('else_colon_clause');
11016     $this->_keyword = $keyword;
11017     $this->_colon = $colon;
11018     $this->_statement = $statement;
11019   }
11020   public function keyword(): EditableSyntax {
11021     return $this->_keyword;
11022   }
11023   public function colon(): EditableSyntax {
11024     return $this->_colon;
11025   }
11026   public function statement(): EditableSyntax {
11027     return $this->_statement;
11028   }
11029   public function with_keyword(EditableSyntax $keyword): ElseColonClause {
11030     return new ElseColonClause(
11031       $keyword,
11032       $this->_colon,
11033       $this->_statement);
11034   }
11035   public function with_colon(EditableSyntax $colon): ElseColonClause {
11036     return new ElseColonClause(
11037       $this->_keyword,
11038       $colon,
11039       $this->_statement);
11040   }
11041   public function with_statement(EditableSyntax $statement): ElseColonClause {
11042     return new ElseColonClause(
11043       $this->_keyword,
11044       $this->_colon,
11045       $statement);
11046   }
11047
11048   public function rewrite(
11049     ( function
11050       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
11051     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
11052     $new_parents = $parents ?? [];
11053     array_push($new_parents, $this);
11054     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
11055     $colon = $this->colon()->rewrite($rewriter, $new_parents);
11056     $statement = $this->statement()->rewrite($rewriter, $new_parents);
11057     if (
11058       $keyword === $this->keyword() &&
11059       $colon === $this->colon() &&
11060       $statement === $this->statement()) {
11061       return $rewriter($this, $parents ?? []);
11062     } else {
11063       return $rewriter(new ElseColonClause(
11064         $keyword,
11065         $colon,
11066         $statement), $parents ?? []);
11067     }
11068   }
11069
11070   public static function from_json(mixed $json, int $position, string $source) {
11071     $keyword = EditableSyntax::from_json(
11072       $json->else_colon_keyword, $position, $source);
11073     $position += $keyword->width();
11074     $colon = EditableSyntax::from_json(
11075       $json->else_colon_colon, $position, $source);
11076     $position += $colon->width();
11077     $statement = EditableSyntax::from_json(
11078       $json->else_colon_statement, $position, $source);
11079     $position += $statement->width();
11080     return new ElseColonClause(
11081         $keyword,
11082         $colon,
11083         $statement);
11084   }
11085   public function children(): Generator<string, EditableSyntax, void> {
11086     yield $this->_keyword;
11087     yield $this->_colon;
11088     yield $this->_statement;
11089     yield break;
11090   }
11091 }
11092 final class TryStatement extends EditableSyntax {
11093   private EditableSyntax $_keyword;
11094   private EditableSyntax $_compound_statement;
11095   private EditableSyntax $_catch_clauses;
11096   private EditableSyntax $_finally_clause;
11097   public function __construct(
11098     EditableSyntax $keyword,
11099     EditableSyntax $compound_statement,
11100     EditableSyntax $catch_clauses,
11101     EditableSyntax $finally_clause) {
11102     parent::__construct('try_statement');
11103     $this->_keyword = $keyword;
11104     $this->_compound_statement = $compound_statement;
11105     $this->_catch_clauses = $catch_clauses;
11106     $this->_finally_clause = $finally_clause;
11107   }
11108   public function keyword(): EditableSyntax {
11109     return $this->_keyword;
11110   }
11111   public function compound_statement(): EditableSyntax {
11112     return $this->_compound_statement;
11113   }
11114   public function catch_clauses(): EditableSyntax {
11115     return $this->_catch_clauses;
11116   }
11117   public function finally_clause(): EditableSyntax {
11118     return $this->_finally_clause;
11119   }
11120   public function with_keyword(EditableSyntax $keyword): TryStatement {
11121     return new TryStatement(
11122       $keyword,
11123       $this->_compound_statement,
11124       $this->_catch_clauses,
11125       $this->_finally_clause);
11126   }
11127   public function with_compound_statement(EditableSyntax $compound_statement): TryStatement {
11128     return new TryStatement(
11129       $this->_keyword,
11130       $compound_statement,
11131       $this->_catch_clauses,
11132       $this->_finally_clause);
11133   }
11134   public function with_catch_clauses(EditableSyntax $catch_clauses): TryStatement {
11135     return new TryStatement(
11136       $this->_keyword,
11137       $this->_compound_statement,
11138       $catch_clauses,
11139       $this->_finally_clause);
11140   }
11141   public function with_finally_clause(EditableSyntax $finally_clause): TryStatement {
11142     return new TryStatement(
11143       $this->_keyword,
11144       $this->_compound_statement,
11145       $this->_catch_clauses,
11146       $finally_clause);
11147   }
11148
11149   public function rewrite(
11150     ( function
11151       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
11152     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
11153     $new_parents = $parents ?? [];
11154     array_push($new_parents, $this);
11155     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
11156     $compound_statement = $this->compound_statement()->rewrite($rewriter, $new_parents);
11157     $catch_clauses = $this->catch_clauses()->rewrite($rewriter, $new_parents);
11158     $finally_clause = $this->finally_clause()->rewrite($rewriter, $new_parents);
11159     if (
11160       $keyword === $this->keyword() &&
11161       $compound_statement === $this->compound_statement() &&
11162       $catch_clauses === $this->catch_clauses() &&
11163       $finally_clause === $this->finally_clause()) {
11164       return $rewriter($this, $parents ?? []);
11165     } else {
11166       return $rewriter(new TryStatement(
11167         $keyword,
11168         $compound_statement,
11169         $catch_clauses,
11170         $finally_clause), $parents ?? []);
11171     }
11172   }
11173
11174   public static function from_json(mixed $json, int $position, string $source) {
11175     $keyword = EditableSyntax::from_json(
11176       $json->try_keyword, $position, $source);
11177     $position += $keyword->width();
11178     $compound_statement = EditableSyntax::from_json(
11179       $json->try_compound_statement, $position, $source);
11180     $position += $compound_statement->width();
11181     $catch_clauses = EditableSyntax::from_json(
11182       $json->try_catch_clauses, $position, $source);
11183     $position += $catch_clauses->width();
11184     $finally_clause = EditableSyntax::from_json(
11185       $json->try_finally_clause, $position, $source);
11186     $position += $finally_clause->width();
11187     return new TryStatement(
11188         $keyword,
11189         $compound_statement,
11190         $catch_clauses,
11191         $finally_clause);
11192   }
11193   public function children(): Generator<string, EditableSyntax, void> {
11194     yield $this->_keyword;
11195     yield $this->_compound_statement;
11196     yield $this->_catch_clauses;
11197     yield $this->_finally_clause;
11198     yield break;
11199   }
11200 }
11201 final class CatchClause extends EditableSyntax {
11202   private EditableSyntax $_keyword;
11203   private EditableSyntax $_left_paren;
11204   private EditableSyntax $_type;
11205   private EditableSyntax $_variable;
11206   private EditableSyntax $_right_paren;
11207   private EditableSyntax $_body;
11208   public function __construct(
11209     EditableSyntax $keyword,
11210     EditableSyntax $left_paren,
11211     EditableSyntax $type,
11212     EditableSyntax $variable,
11213     EditableSyntax $right_paren,
11214     EditableSyntax $body) {
11215     parent::__construct('catch_clause');
11216     $this->_keyword = $keyword;
11217     $this->_left_paren = $left_paren;
11218     $this->_type = $type;
11219     $this->_variable = $variable;
11220     $this->_right_paren = $right_paren;
11221     $this->_body = $body;
11222   }
11223   public function keyword(): EditableSyntax {
11224     return $this->_keyword;
11225   }
11226   public function left_paren(): EditableSyntax {
11227     return $this->_left_paren;
11228   }
11229   public function type(): EditableSyntax {
11230     return $this->_type;
11231   }
11232   public function variable(): EditableSyntax {
11233     return $this->_variable;
11234   }
11235   public function right_paren(): EditableSyntax {
11236     return $this->_right_paren;
11237   }
11238   public function body(): EditableSyntax {
11239     return $this->_body;
11240   }
11241   public function with_keyword(EditableSyntax $keyword): CatchClause {
11242     return new CatchClause(
11243       $keyword,
11244       $this->_left_paren,
11245       $this->_type,
11246       $this->_variable,
11247       $this->_right_paren,
11248       $this->_body);
11249   }
11250   public function with_left_paren(EditableSyntax $left_paren): CatchClause {
11251     return new CatchClause(
11252       $this->_keyword,
11253       $left_paren,
11254       $this->_type,
11255       $this->_variable,
11256       $this->_right_paren,
11257       $this->_body);
11258   }
11259   public function with_type(EditableSyntax $type): CatchClause {
11260     return new CatchClause(
11261       $this->_keyword,
11262       $this->_left_paren,
11263       $type,
11264       $this->_variable,
11265       $this->_right_paren,
11266       $this->_body);
11267   }
11268   public function with_variable(EditableSyntax $variable): CatchClause {
11269     return new CatchClause(
11270       $this->_keyword,
11271       $this->_left_paren,
11272       $this->_type,
11273       $variable,
11274       $this->_right_paren,
11275       $this->_body);
11276   }
11277   public function with_right_paren(EditableSyntax $right_paren): CatchClause {
11278     return new CatchClause(
11279       $this->_keyword,
11280       $this->_left_paren,
11281       $this->_type,
11282       $this->_variable,
11283       $right_paren,
11284       $this->_body);
11285   }
11286   public function with_body(EditableSyntax $body): CatchClause {
11287     return new CatchClause(
11288       $this->_keyword,
11289       $this->_left_paren,
11290       $this->_type,
11291       $this->_variable,
11292       $this->_right_paren,
11293       $body);
11294   }
11295
11296   public function rewrite(
11297     ( function
11298       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
11299     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
11300     $new_parents = $parents ?? [];
11301     array_push($new_parents, $this);
11302     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
11303     $left_paren = $this->left_paren()->rewrite($rewriter, $new_parents);
11304     $type = $this->type()->rewrite($rewriter, $new_parents);
11305     $variable = $this->variable()->rewrite($rewriter, $new_parents);
11306     $right_paren = $this->right_paren()->rewrite($rewriter, $new_parents);
11307     $body = $this->body()->rewrite($rewriter, $new_parents);
11308     if (
11309       $keyword === $this->keyword() &&
11310       $left_paren === $this->left_paren() &&
11311       $type === $this->type() &&
11312       $variable === $this->variable() &&
11313       $right_paren === $this->right_paren() &&
11314       $body === $this->body()) {
11315       return $rewriter($this, $parents ?? []);
11316     } else {
11317       return $rewriter(new CatchClause(
11318         $keyword,
11319         $left_paren,
11320         $type,
11321         $variable,
11322         $right_paren,
11323         $body), $parents ?? []);
11324     }
11325   }
11326
11327   public static function from_json(mixed $json, int $position, string $source) {
11328     $keyword = EditableSyntax::from_json(
11329       $json->catch_keyword, $position, $source);
11330     $position += $keyword->width();
11331     $left_paren = EditableSyntax::from_json(
11332       $json->catch_left_paren, $position, $source);
11333     $position += $left_paren->width();
11334     $type = EditableSyntax::from_json(
11335       $json->catch_type, $position, $source);
11336     $position += $type->width();
11337     $variable = EditableSyntax::from_json(
11338       $json->catch_variable, $position, $source);
11339     $position += $variable->width();
11340     $right_paren = EditableSyntax::from_json(
11341       $json->catch_right_paren, $position, $source);
11342     $position += $right_paren->width();
11343     $body = EditableSyntax::from_json(
11344       $json->catch_body, $position, $source);
11345     $position += $body->width();
11346     return new CatchClause(
11347         $keyword,
11348         $left_paren,
11349         $type,
11350         $variable,
11351         $right_paren,
11352         $body);
11353   }
11354   public function children(): Generator<string, EditableSyntax, void> {
11355     yield $this->_keyword;
11356     yield $this->_left_paren;
11357     yield $this->_type;
11358     yield $this->_variable;
11359     yield $this->_right_paren;
11360     yield $this->_body;
11361     yield break;
11362   }
11363 }
11364 final class FinallyClause extends EditableSyntax {
11365   private EditableSyntax $_keyword;
11366   private EditableSyntax $_body;
11367   public function __construct(
11368     EditableSyntax $keyword,
11369     EditableSyntax $body) {
11370     parent::__construct('finally_clause');
11371     $this->_keyword = $keyword;
11372     $this->_body = $body;
11373   }
11374   public function keyword(): EditableSyntax {
11375     return $this->_keyword;
11376   }
11377   public function body(): EditableSyntax {
11378     return $this->_body;
11379   }
11380   public function with_keyword(EditableSyntax $keyword): FinallyClause {
11381     return new FinallyClause(
11382       $keyword,
11383       $this->_body);
11384   }
11385   public function with_body(EditableSyntax $body): FinallyClause {
11386     return new FinallyClause(
11387       $this->_keyword,
11388       $body);
11389   }
11390
11391   public function rewrite(
11392     ( function
11393       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
11394     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
11395     $new_parents = $parents ?? [];
11396     array_push($new_parents, $this);
11397     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
11398     $body = $this->body()->rewrite($rewriter, $new_parents);
11399     if (
11400       $keyword === $this->keyword() &&
11401       $body === $this->body()) {
11402       return $rewriter($this, $parents ?? []);
11403     } else {
11404       return $rewriter(new FinallyClause(
11405         $keyword,
11406         $body), $parents ?? []);
11407     }
11408   }
11409
11410   public static function from_json(mixed $json, int $position, string $source) {
11411     $keyword = EditableSyntax::from_json(
11412       $json->finally_keyword, $position, $source);
11413     $position += $keyword->width();
11414     $body = EditableSyntax::from_json(
11415       $json->finally_body, $position, $source);
11416     $position += $body->width();
11417     return new FinallyClause(
11418         $keyword,
11419         $body);
11420   }
11421   public function children(): Generator<string, EditableSyntax, void> {
11422     yield $this->_keyword;
11423     yield $this->_body;
11424     yield break;
11425   }
11426 }
11427 final class DoStatement extends EditableSyntax {
11428   private EditableSyntax $_keyword;
11429   private EditableSyntax $_body;
11430   private EditableSyntax $_while_keyword;
11431   private EditableSyntax $_left_paren;
11432   private EditableSyntax $_condition;
11433   private EditableSyntax $_right_paren;
11434   private EditableSyntax $_semicolon;
11435   public function __construct(
11436     EditableSyntax $keyword,
11437     EditableSyntax $body,
11438     EditableSyntax $while_keyword,
11439     EditableSyntax $left_paren,
11440     EditableSyntax $condition,
11441     EditableSyntax $right_paren,
11442     EditableSyntax $semicolon) {
11443     parent::__construct('do_statement');
11444     $this->_keyword = $keyword;
11445     $this->_body = $body;
11446     $this->_while_keyword = $while_keyword;
11447     $this->_left_paren = $left_paren;
11448     $this->_condition = $condition;
11449     $this->_right_paren = $right_paren;
11450     $this->_semicolon = $semicolon;
11451   }
11452   public function keyword(): EditableSyntax {
11453     return $this->_keyword;
11454   }
11455   public function body(): EditableSyntax {
11456     return $this->_body;
11457   }
11458   public function while_keyword(): EditableSyntax {
11459     return $this->_while_keyword;
11460   }
11461   public function left_paren(): EditableSyntax {
11462     return $this->_left_paren;
11463   }
11464   public function condition(): EditableSyntax {
11465     return $this->_condition;
11466   }
11467   public function right_paren(): EditableSyntax {
11468     return $this->_right_paren;
11469   }
11470   public function semicolon(): EditableSyntax {
11471     return $this->_semicolon;
11472   }
11473   public function with_keyword(EditableSyntax $keyword): DoStatement {
11474     return new DoStatement(
11475       $keyword,
11476       $this->_body,
11477       $this->_while_keyword,
11478       $this->_left_paren,
11479       $this->_condition,
11480       $this->_right_paren,
11481       $this->_semicolon);
11482   }
11483   public function with_body(EditableSyntax $body): DoStatement {
11484     return new DoStatement(
11485       $this->_keyword,
11486       $body,
11487       $this->_while_keyword,
11488       $this->_left_paren,
11489       $this->_condition,
11490       $this->_right_paren,
11491       $this->_semicolon);
11492   }
11493   public function with_while_keyword(EditableSyntax $while_keyword): DoStatement {
11494     return new DoStatement(
11495       $this->_keyword,
11496       $this->_body,
11497       $while_keyword,
11498       $this->_left_paren,
11499       $this->_condition,
11500       $this->_right_paren,
11501       $this->_semicolon);
11502   }
11503   public function with_left_paren(EditableSyntax $left_paren): DoStatement {
11504     return new DoStatement(
11505       $this->_keyword,
11506       $this->_body,
11507       $this->_while_keyword,
11508       $left_paren,
11509       $this->_condition,
11510       $this->_right_paren,
11511       $this->_semicolon);
11512   }
11513   public function with_condition(EditableSyntax $condition): DoStatement {
11514     return new DoStatement(
11515       $this->_keyword,
11516       $this->_body,
11517       $this->_while_keyword,
11518       $this->_left_paren,
11519       $condition,
11520       $this->_right_paren,
11521       $this->_semicolon);
11522   }
11523   public function with_right_paren(EditableSyntax $right_paren): DoStatement {
11524     return new DoStatement(
11525       $this->_keyword,
11526       $this->_body,
11527       $this->_while_keyword,
11528       $this->_left_paren,
11529       $this->_condition,
11530       $right_paren,
11531       $this->_semicolon);
11532   }
11533   public function with_semicolon(EditableSyntax $semicolon): DoStatement {
11534     return new DoStatement(
11535       $this->_keyword,
11536       $this->_body,
11537       $this->_while_keyword,
11538       $this->_left_paren,
11539       $this->_condition,
11540       $this->_right_paren,
11541       $semicolon);
11542   }
11543
11544   public function rewrite(
11545     ( function
11546       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
11547     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
11548     $new_parents = $parents ?? [];
11549     array_push($new_parents, $this);
11550     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
11551     $body = $this->body()->rewrite($rewriter, $new_parents);
11552     $while_keyword = $this->while_keyword()->rewrite($rewriter, $new_parents);
11553     $left_paren = $this->left_paren()->rewrite($rewriter, $new_parents);
11554     $condition = $this->condition()->rewrite($rewriter, $new_parents);
11555     $right_paren = $this->right_paren()->rewrite($rewriter, $new_parents);
11556     $semicolon = $this->semicolon()->rewrite($rewriter, $new_parents);
11557     if (
11558       $keyword === $this->keyword() &&
11559       $body === $this->body() &&
11560       $while_keyword === $this->while_keyword() &&
11561       $left_paren === $this->left_paren() &&
11562       $condition === $this->condition() &&
11563       $right_paren === $this->right_paren() &&
11564       $semicolon === $this->semicolon()) {
11565       return $rewriter($this, $parents ?? []);
11566     } else {
11567       return $rewriter(new DoStatement(
11568         $keyword,
11569         $body,
11570         $while_keyword,
11571         $left_paren,
11572         $condition,
11573         $right_paren,
11574         $semicolon), $parents ?? []);
11575     }
11576   }
11577
11578   public static function from_json(mixed $json, int $position, string $source) {
11579     $keyword = EditableSyntax::from_json(
11580       $json->do_keyword, $position, $source);
11581     $position += $keyword->width();
11582     $body = EditableSyntax::from_json(
11583       $json->do_body, $position, $source);
11584     $position += $body->width();
11585     $while_keyword = EditableSyntax::from_json(
11586       $json->do_while_keyword, $position, $source);
11587     $position += $while_keyword->width();
11588     $left_paren = EditableSyntax::from_json(
11589       $json->do_left_paren, $position, $source);
11590     $position += $left_paren->width();
11591     $condition = EditableSyntax::from_json(
11592       $json->do_condition, $position, $source);
11593     $position += $condition->width();
11594     $right_paren = EditableSyntax::from_json(
11595       $json->do_right_paren, $position, $source);
11596     $position += $right_paren->width();
11597     $semicolon = EditableSyntax::from_json(
11598       $json->do_semicolon, $position, $source);
11599     $position += $semicolon->width();
11600     return new DoStatement(
11601         $keyword,
11602         $body,
11603         $while_keyword,
11604         $left_paren,
11605         $condition,
11606         $right_paren,
11607         $semicolon);
11608   }
11609   public function children(): Generator<string, EditableSyntax, void> {
11610     yield $this->_keyword;
11611     yield $this->_body;
11612     yield $this->_while_keyword;
11613     yield $this->_left_paren;
11614     yield $this->_condition;
11615     yield $this->_right_paren;
11616     yield $this->_semicolon;
11617     yield break;
11618   }
11619 }
11620 final class ForStatement extends EditableSyntax {
11621   private EditableSyntax $_keyword;
11622   private EditableSyntax $_left_paren;
11623   private EditableSyntax $_initializer;
11624   private EditableSyntax $_first_semicolon;
11625   private EditableSyntax $_control;
11626   private EditableSyntax $_second_semicolon;
11627   private EditableSyntax $_end_of_loop;
11628   private EditableSyntax $_right_paren;
11629   private EditableSyntax $_body;
11630   public function __construct(
11631     EditableSyntax $keyword,
11632     EditableSyntax $left_paren,
11633     EditableSyntax $initializer,
11634     EditableSyntax $first_semicolon,
11635     EditableSyntax $control,
11636     EditableSyntax $second_semicolon,
11637     EditableSyntax $end_of_loop,
11638     EditableSyntax $right_paren,
11639     EditableSyntax $body) {
11640     parent::__construct('for_statement');
11641     $this->_keyword = $keyword;
11642     $this->_left_paren = $left_paren;
11643     $this->_initializer = $initializer;
11644     $this->_first_semicolon = $first_semicolon;
11645     $this->_control = $control;
11646     $this->_second_semicolon = $second_semicolon;
11647     $this->_end_of_loop = $end_of_loop;
11648     $this->_right_paren = $right_paren;
11649     $this->_body = $body;
11650   }
11651   public function keyword(): EditableSyntax {
11652     return $this->_keyword;
11653   }
11654   public function left_paren(): EditableSyntax {
11655     return $this->_left_paren;
11656   }
11657   public function initializer(): EditableSyntax {
11658     return $this->_initializer;
11659   }
11660   public function first_semicolon(): EditableSyntax {
11661     return $this->_first_semicolon;
11662   }
11663   public function control(): EditableSyntax {
11664     return $this->_control;
11665   }
11666   public function second_semicolon(): EditableSyntax {
11667     return $this->_second_semicolon;
11668   }
11669   public function end_of_loop(): EditableSyntax {
11670     return $this->_end_of_loop;
11671   }
11672   public function right_paren(): EditableSyntax {
11673     return $this->_right_paren;
11674   }
11675   public function body(): EditableSyntax {
11676     return $this->_body;
11677   }
11678   public function with_keyword(EditableSyntax $keyword): ForStatement {
11679     return new ForStatement(
11680       $keyword,
11681       $this->_left_paren,
11682       $this->_initializer,
11683       $this->_first_semicolon,
11684       $this->_control,
11685       $this->_second_semicolon,
11686       $this->_end_of_loop,
11687       $this->_right_paren,
11688       $this->_body);
11689   }
11690   public function with_left_paren(EditableSyntax $left_paren): ForStatement {
11691     return new ForStatement(
11692       $this->_keyword,
11693       $left_paren,
11694       $this->_initializer,
11695       $this->_first_semicolon,
11696       $this->_control,
11697       $this->_second_semicolon,
11698       $this->_end_of_loop,
11699       $this->_right_paren,
11700       $this->_body);
11701   }
11702   public function with_initializer(EditableSyntax $initializer): ForStatement {
11703     return new ForStatement(
11704       $this->_keyword,
11705       $this->_left_paren,
11706       $initializer,
11707       $this->_first_semicolon,
11708       $this->_control,
11709       $this->_second_semicolon,
11710       $this->_end_of_loop,
11711       $this->_right_paren,
11712       $this->_body);
11713   }
11714   public function with_first_semicolon(EditableSyntax $first_semicolon): ForStatement {
11715     return new ForStatement(
11716       $this->_keyword,
11717       $this->_left_paren,
11718       $this->_initializer,
11719       $first_semicolon,
11720       $this->_control,
11721       $this->_second_semicolon,
11722       $this->_end_of_loop,
11723       $this->_right_paren,
11724       $this->_body);
11725   }
11726   public function with_control(EditableSyntax $control): ForStatement {
11727     return new ForStatement(
11728       $this->_keyword,
11729       $this->_left_paren,
11730       $this->_initializer,
11731       $this->_first_semicolon,
11732       $control,
11733       $this->_second_semicolon,
11734       $this->_end_of_loop,
11735       $this->_right_paren,
11736       $this->_body);
11737   }
11738   public function with_second_semicolon(EditableSyntax $second_semicolon): ForStatement {
11739     return new ForStatement(
11740       $this->_keyword,
11741       $this->_left_paren,
11742       $this->_initializer,
11743       $this->_first_semicolon,
11744       $this->_control,
11745       $second_semicolon,
11746       $this->_end_of_loop,
11747       $this->_right_paren,
11748       $this->_body);
11749   }
11750   public function with_end_of_loop(EditableSyntax $end_of_loop): ForStatement {
11751     return new ForStatement(
11752       $this->_keyword,
11753       $this->_left_paren,
11754       $this->_initializer,
11755       $this->_first_semicolon,
11756       $this->_control,
11757       $this->_second_semicolon,
11758       $end_of_loop,
11759       $this->_right_paren,
11760       $this->_body);
11761   }
11762   public function with_right_paren(EditableSyntax $right_paren): ForStatement {
11763     return new ForStatement(
11764       $this->_keyword,
11765       $this->_left_paren,
11766       $this->_initializer,
11767       $this->_first_semicolon,
11768       $this->_control,
11769       $this->_second_semicolon,
11770       $this->_end_of_loop,
11771       $right_paren,
11772       $this->_body);
11773   }
11774   public function with_body(EditableSyntax $body): ForStatement {
11775     return new ForStatement(
11776       $this->_keyword,
11777       $this->_left_paren,
11778       $this->_initializer,
11779       $this->_first_semicolon,
11780       $this->_control,
11781       $this->_second_semicolon,
11782       $this->_end_of_loop,
11783       $this->_right_paren,
11784       $body);
11785   }
11786
11787   public function rewrite(
11788     ( function
11789       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
11790     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
11791     $new_parents = $parents ?? [];
11792     array_push($new_parents, $this);
11793     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
11794     $left_paren = $this->left_paren()->rewrite($rewriter, $new_parents);
11795     $initializer = $this->initializer()->rewrite($rewriter, $new_parents);
11796     $first_semicolon = $this->first_semicolon()->rewrite($rewriter, $new_parents);
11797     $control = $this->control()->rewrite($rewriter, $new_parents);
11798     $second_semicolon = $this->second_semicolon()->rewrite($rewriter, $new_parents);
11799     $end_of_loop = $this->end_of_loop()->rewrite($rewriter, $new_parents);
11800     $right_paren = $this->right_paren()->rewrite($rewriter, $new_parents);
11801     $body = $this->body()->rewrite($rewriter, $new_parents);
11802     if (
11803       $keyword === $this->keyword() &&
11804       $left_paren === $this->left_paren() &&
11805       $initializer === $this->initializer() &&
11806       $first_semicolon === $this->first_semicolon() &&
11807       $control === $this->control() &&
11808       $second_semicolon === $this->second_semicolon() &&
11809       $end_of_loop === $this->end_of_loop() &&
11810       $right_paren === $this->right_paren() &&
11811       $body === $this->body()) {
11812       return $rewriter($this, $parents ?? []);
11813     } else {
11814       return $rewriter(new ForStatement(
11815         $keyword,
11816         $left_paren,
11817         $initializer,
11818         $first_semicolon,
11819         $control,
11820         $second_semicolon,
11821         $end_of_loop,
11822         $right_paren,
11823         $body), $parents ?? []);
11824     }
11825   }
11826
11827   public static function from_json(mixed $json, int $position, string $source) {
11828     $keyword = EditableSyntax::from_json(
11829       $json->for_keyword, $position, $source);
11830     $position += $keyword->width();
11831     $left_paren = EditableSyntax::from_json(
11832       $json->for_left_paren, $position, $source);
11833     $position += $left_paren->width();
11834     $initializer = EditableSyntax::from_json(
11835       $json->for_initializer, $position, $source);
11836     $position += $initializer->width();
11837     $first_semicolon = EditableSyntax::from_json(
11838       $json->for_first_semicolon, $position, $source);
11839     $position += $first_semicolon->width();
11840     $control = EditableSyntax::from_json(
11841       $json->for_control, $position, $source);
11842     $position += $control->width();
11843     $second_semicolon = EditableSyntax::from_json(
11844       $json->for_second_semicolon, $position, $source);
11845     $position += $second_semicolon->width();
11846     $end_of_loop = EditableSyntax::from_json(
11847       $json->for_end_of_loop, $position, $source);
11848     $position += $end_of_loop->width();
11849     $right_paren = EditableSyntax::from_json(
11850       $json->for_right_paren, $position, $source);
11851     $position += $right_paren->width();
11852     $body = EditableSyntax::from_json(
11853       $json->for_body, $position, $source);
11854     $position += $body->width();
11855     return new ForStatement(
11856         $keyword,
11857         $left_paren,
11858         $initializer,
11859         $first_semicolon,
11860         $control,
11861         $second_semicolon,
11862         $end_of_loop,
11863         $right_paren,
11864         $body);
11865   }
11866   public function children(): Generator<string, EditableSyntax, void> {
11867     yield $this->_keyword;
11868     yield $this->_left_paren;
11869     yield $this->_initializer;
11870     yield $this->_first_semicolon;
11871     yield $this->_control;
11872     yield $this->_second_semicolon;
11873     yield $this->_end_of_loop;
11874     yield $this->_right_paren;
11875     yield $this->_body;
11876     yield break;
11877   }
11878 }
11879 final class ForeachStatement extends EditableSyntax {
11880   private EditableSyntax $_keyword;
11881   private EditableSyntax $_left_paren;
11882   private EditableSyntax $_collection;
11883   private EditableSyntax $_await_keyword;
11884   private EditableSyntax $_as;
11885   private EditableSyntax $_key;
11886   private EditableSyntax $_arrow;
11887   private EditableSyntax $_value;
11888   private EditableSyntax $_right_paren;
11889   private EditableSyntax $_body;
11890   public function __construct(
11891     EditableSyntax $keyword,
11892     EditableSyntax $left_paren,
11893     EditableSyntax $collection,
11894     EditableSyntax $await_keyword,
11895     EditableSyntax $as,
11896     EditableSyntax $key,
11897     EditableSyntax $arrow,
11898     EditableSyntax $value,
11899     EditableSyntax $right_paren,
11900     EditableSyntax $body) {
11901     parent::__construct('foreach_statement');
11902     $this->_keyword = $keyword;
11903     $this->_left_paren = $left_paren;
11904     $this->_collection = $collection;
11905     $this->_await_keyword = $await_keyword;
11906     $this->_as = $as;
11907     $this->_key = $key;
11908     $this->_arrow = $arrow;
11909     $this->_value = $value;
11910     $this->_right_paren = $right_paren;
11911     $this->_body = $body;
11912   }
11913   public function keyword(): EditableSyntax {
11914     return $this->_keyword;
11915   }
11916   public function left_paren(): EditableSyntax {
11917     return $this->_left_paren;
11918   }
11919   public function collection(): EditableSyntax {
11920     return $this->_collection;
11921   }
11922   public function await_keyword(): EditableSyntax {
11923     return $this->_await_keyword;
11924   }
11925   public function as(): EditableSyntax {
11926     return $this->_as;
11927   }
11928   public function key(): EditableSyntax {
11929     return $this->_key;
11930   }
11931   public function arrow(): EditableSyntax {
11932     return $this->_arrow;
11933   }
11934   public function value(): EditableSyntax {
11935     return $this->_value;
11936   }
11937   public function right_paren(): EditableSyntax {
11938     return $this->_right_paren;
11939   }
11940   public function body(): EditableSyntax {
11941     return $this->_body;
11942   }
11943   public function with_keyword(EditableSyntax $keyword): ForeachStatement {
11944     return new ForeachStatement(
11945       $keyword,
11946       $this->_left_paren,
11947       $this->_collection,
11948       $this->_await_keyword,
11949       $this->_as,
11950       $this->_key,
11951       $this->_arrow,
11952       $this->_value,
11953       $this->_right_paren,
11954       $this->_body);
11955   }
11956   public function with_left_paren(EditableSyntax $left_paren): ForeachStatement {
11957     return new ForeachStatement(
11958       $this->_keyword,
11959       $left_paren,
11960       $this->_collection,
11961       $this->_await_keyword,
11962       $this->_as,
11963       $this->_key,
11964       $this->_arrow,
11965       $this->_value,
11966       $this->_right_paren,
11967       $this->_body);
11968   }
11969   public function with_collection(EditableSyntax $collection): ForeachStatement {
11970     return new ForeachStatement(
11971       $this->_keyword,
11972       $this->_left_paren,
11973       $collection,
11974       $this->_await_keyword,
11975       $this->_as,
11976       $this->_key,
11977       $this->_arrow,
11978       $this->_value,
11979       $this->_right_paren,
11980       $this->_body);
11981   }
11982   public function with_await_keyword(EditableSyntax $await_keyword): ForeachStatement {
11983     return new ForeachStatement(
11984       $this->_keyword,
11985       $this->_left_paren,
11986       $this->_collection,
11987       $await_keyword,
11988       $this->_as,
11989       $this->_key,
11990       $this->_arrow,
11991       $this->_value,
11992       $this->_right_paren,
11993       $this->_body);
11994   }
11995   public function with_as(EditableSyntax $as): ForeachStatement {
11996     return new ForeachStatement(
11997       $this->_keyword,
11998       $this->_left_paren,
11999       $this->_collection,
12000       $this->_await_keyword,
12001       $as,
12002       $this->_key,
12003       $this->_arrow,
12004       $this->_value,
12005       $this->_right_paren,
12006       $this->_body);
12007   }
12008   public function with_key(EditableSyntax $key): ForeachStatement {
12009     return new ForeachStatement(
12010       $this->_keyword,
12011       $this->_left_paren,
12012       $this->_collection,
12013       $this->_await_keyword,
12014       $this->_as,
12015       $key,
12016       $this->_arrow,
12017       $this->_value,
12018       $this->_right_paren,
12019       $this->_body);
12020   }
12021   public function with_arrow(EditableSyntax $arrow): ForeachStatement {
12022     return new ForeachStatement(
12023       $this->_keyword,
12024       $this->_left_paren,
12025       $this->_collection,
12026       $this->_await_keyword,
12027       $this->_as,
12028       $this->_key,
12029       $arrow,
12030       $this->_value,
12031       $this->_right_paren,
12032       $this->_body);
12033   }
12034   public function with_value(EditableSyntax $value): ForeachStatement {
12035     return new ForeachStatement(
12036       $this->_keyword,
12037       $this->_left_paren,
12038       $this->_collection,
12039       $this->_await_keyword,
12040       $this->_as,
12041       $this->_key,
12042       $this->_arrow,
12043       $value,
12044       $this->_right_paren,
12045       $this->_body);
12046   }
12047   public function with_right_paren(EditableSyntax $right_paren): ForeachStatement {
12048     return new ForeachStatement(
12049       $this->_keyword,
12050       $this->_left_paren,
12051       $this->_collection,
12052       $this->_await_keyword,
12053       $this->_as,
12054       $this->_key,
12055       $this->_arrow,
12056       $this->_value,
12057       $right_paren,
12058       $this->_body);
12059   }
12060   public function with_body(EditableSyntax $body): ForeachStatement {
12061     return new ForeachStatement(
12062       $this->_keyword,
12063       $this->_left_paren,
12064       $this->_collection,
12065       $this->_await_keyword,
12066       $this->_as,
12067       $this->_key,
12068       $this->_arrow,
12069       $this->_value,
12070       $this->_right_paren,
12071       $body);
12072   }
12073
12074   public function rewrite(
12075     ( function
12076       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
12077     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
12078     $new_parents = $parents ?? [];
12079     array_push($new_parents, $this);
12080     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
12081     $left_paren = $this->left_paren()->rewrite($rewriter, $new_parents);
12082     $collection = $this->collection()->rewrite($rewriter, $new_parents);
12083     $await_keyword = $this->await_keyword()->rewrite($rewriter, $new_parents);
12084     $as = $this->as()->rewrite($rewriter, $new_parents);
12085     $key = $this->key()->rewrite($rewriter, $new_parents);
12086     $arrow = $this->arrow()->rewrite($rewriter, $new_parents);
12087     $value = $this->value()->rewrite($rewriter, $new_parents);
12088     $right_paren = $this->right_paren()->rewrite($rewriter, $new_parents);
12089     $body = $this->body()->rewrite($rewriter, $new_parents);
12090     if (
12091       $keyword === $this->keyword() &&
12092       $left_paren === $this->left_paren() &&
12093       $collection === $this->collection() &&
12094       $await_keyword === $this->await_keyword() &&
12095       $as === $this->as() &&
12096       $key === $this->key() &&
12097       $arrow === $this->arrow() &&
12098       $value === $this->value() &&
12099       $right_paren === $this->right_paren() &&
12100       $body === $this->body()) {
12101       return $rewriter($this, $parents ?? []);
12102     } else {
12103       return $rewriter(new ForeachStatement(
12104         $keyword,
12105         $left_paren,
12106         $collection,
12107         $await_keyword,
12108         $as,
12109         $key,
12110         $arrow,
12111         $value,
12112         $right_paren,
12113         $body), $parents ?? []);
12114     }
12115   }
12116
12117   public static function from_json(mixed $json, int $position, string $source) {
12118     $keyword = EditableSyntax::from_json(
12119       $json->foreach_keyword, $position, $source);
12120     $position += $keyword->width();
12121     $left_paren = EditableSyntax::from_json(
12122       $json->foreach_left_paren, $position, $source);
12123     $position += $left_paren->width();
12124     $collection = EditableSyntax::from_json(
12125       $json->foreach_collection, $position, $source);
12126     $position += $collection->width();
12127     $await_keyword = EditableSyntax::from_json(
12128       $json->foreach_await_keyword, $position, $source);
12129     $position += $await_keyword->width();
12130     $as = EditableSyntax::from_json(
12131       $json->foreach_as, $position, $source);
12132     $position += $as->width();
12133     $key = EditableSyntax::from_json(
12134       $json->foreach_key, $position, $source);
12135     $position += $key->width();
12136     $arrow = EditableSyntax::from_json(
12137       $json->foreach_arrow, $position, $source);
12138     $position += $arrow->width();
12139     $value = EditableSyntax::from_json(
12140       $json->foreach_value, $position, $source);
12141     $position += $value->width();
12142     $right_paren = EditableSyntax::from_json(
12143       $json->foreach_right_paren, $position, $source);
12144     $position += $right_paren->width();
12145     $body = EditableSyntax::from_json(
12146       $json->foreach_body, $position, $source);
12147     $position += $body->width();
12148     return new ForeachStatement(
12149         $keyword,
12150         $left_paren,
12151         $collection,
12152         $await_keyword,
12153         $as,
12154         $key,
12155         $arrow,
12156         $value,
12157         $right_paren,
12158         $body);
12159   }
12160   public function children(): Generator<string, EditableSyntax, void> {
12161     yield $this->_keyword;
12162     yield $this->_left_paren;
12163     yield $this->_collection;
12164     yield $this->_await_keyword;
12165     yield $this->_as;
12166     yield $this->_key;
12167     yield $this->_arrow;
12168     yield $this->_value;
12169     yield $this->_right_paren;
12170     yield $this->_body;
12171     yield break;
12172   }
12173 }
12174 final class SwitchStatement extends EditableSyntax {
12175   private EditableSyntax $_keyword;
12176   private EditableSyntax $_left_paren;
12177   private EditableSyntax $_expression;
12178   private EditableSyntax $_right_paren;
12179   private EditableSyntax $_left_brace;
12180   private EditableSyntax $_sections;
12181   private EditableSyntax $_right_brace;
12182   public function __construct(
12183     EditableSyntax $keyword,
12184     EditableSyntax $left_paren,
12185     EditableSyntax $expression,
12186     EditableSyntax $right_paren,
12187     EditableSyntax $left_brace,
12188     EditableSyntax $sections,
12189     EditableSyntax $right_brace) {
12190     parent::__construct('switch_statement');
12191     $this->_keyword = $keyword;
12192     $this->_left_paren = $left_paren;
12193     $this->_expression = $expression;
12194     $this->_right_paren = $right_paren;
12195     $this->_left_brace = $left_brace;
12196     $this->_sections = $sections;
12197     $this->_right_brace = $right_brace;
12198   }
12199   public function keyword(): EditableSyntax {
12200     return $this->_keyword;
12201   }
12202   public function left_paren(): EditableSyntax {
12203     return $this->_left_paren;
12204   }
12205   public function expression(): EditableSyntax {
12206     return $this->_expression;
12207   }
12208   public function right_paren(): EditableSyntax {
12209     return $this->_right_paren;
12210   }
12211   public function left_brace(): EditableSyntax {
12212     return $this->_left_brace;
12213   }
12214   public function sections(): EditableSyntax {
12215     return $this->_sections;
12216   }
12217   public function right_brace(): EditableSyntax {
12218     return $this->_right_brace;
12219   }
12220   public function with_keyword(EditableSyntax $keyword): SwitchStatement {
12221     return new SwitchStatement(
12222       $keyword,
12223       $this->_left_paren,
12224       $this->_expression,
12225       $this->_right_paren,
12226       $this->_left_brace,
12227       $this->_sections,
12228       $this->_right_brace);
12229   }
12230   public function with_left_paren(EditableSyntax $left_paren): SwitchStatement {
12231     return new SwitchStatement(
12232       $this->_keyword,
12233       $left_paren,
12234       $this->_expression,
12235       $this->_right_paren,
12236       $this->_left_brace,
12237       $this->_sections,
12238       $this->_right_brace);
12239   }
12240   public function with_expression(EditableSyntax $expression): SwitchStatement {
12241     return new SwitchStatement(
12242       $this->_keyword,
12243       $this->_left_paren,
12244       $expression,
12245       $this->_right_paren,
12246       $this->_left_brace,
12247       $this->_sections,
12248       $this->_right_brace);
12249   }
12250   public function with_right_paren(EditableSyntax $right_paren): SwitchStatement {
12251     return new SwitchStatement(
12252       $this->_keyword,
12253       $this->_left_paren,
12254       $this->_expression,
12255       $right_paren,
12256       $this->_left_brace,
12257       $this->_sections,
12258       $this->_right_brace);
12259   }
12260   public function with_left_brace(EditableSyntax $left_brace): SwitchStatement {
12261     return new SwitchStatement(
12262       $this->_keyword,
12263       $this->_left_paren,
12264       $this->_expression,
12265       $this->_right_paren,
12266       $left_brace,
12267       $this->_sections,
12268       $this->_right_brace);
12269   }
12270   public function with_sections(EditableSyntax $sections): SwitchStatement {
12271     return new SwitchStatement(
12272       $this->_keyword,
12273       $this->_left_paren,
12274       $this->_expression,
12275       $this->_right_paren,
12276       $this->_left_brace,
12277       $sections,
12278       $this->_right_brace);
12279   }
12280   public function with_right_brace(EditableSyntax $right_brace): SwitchStatement {
12281     return new SwitchStatement(
12282       $this->_keyword,
12283       $this->_left_paren,
12284       $this->_expression,
12285       $this->_right_paren,
12286       $this->_left_brace,
12287       $this->_sections,
12288       $right_brace);
12289   }
12290
12291   public function rewrite(
12292     ( function
12293       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
12294     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
12295     $new_parents = $parents ?? [];
12296     array_push($new_parents, $this);
12297     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
12298     $left_paren = $this->left_paren()->rewrite($rewriter, $new_parents);
12299     $expression = $this->expression()->rewrite($rewriter, $new_parents);
12300     $right_paren = $this->right_paren()->rewrite($rewriter, $new_parents);
12301     $left_brace = $this->left_brace()->rewrite($rewriter, $new_parents);
12302     $sections = $this->sections()->rewrite($rewriter, $new_parents);
12303     $right_brace = $this->right_brace()->rewrite($rewriter, $new_parents);
12304     if (
12305       $keyword === $this->keyword() &&
12306       $left_paren === $this->left_paren() &&
12307       $expression === $this->expression() &&
12308       $right_paren === $this->right_paren() &&
12309       $left_brace === $this->left_brace() &&
12310       $sections === $this->sections() &&
12311       $right_brace === $this->right_brace()) {
12312       return $rewriter($this, $parents ?? []);
12313     } else {
12314       return $rewriter(new SwitchStatement(
12315         $keyword,
12316         $left_paren,
12317         $expression,
12318         $right_paren,
12319         $left_brace,
12320         $sections,
12321         $right_brace), $parents ?? []);
12322     }
12323   }
12324
12325   public static function from_json(mixed $json, int $position, string $source) {
12326     $keyword = EditableSyntax::from_json(
12327       $json->switch_keyword, $position, $source);
12328     $position += $keyword->width();
12329     $left_paren = EditableSyntax::from_json(
12330       $json->switch_left_paren, $position, $source);
12331     $position += $left_paren->width();
12332     $expression = EditableSyntax::from_json(
12333       $json->switch_expression, $position, $source);
12334     $position += $expression->width();
12335     $right_paren = EditableSyntax::from_json(
12336       $json->switch_right_paren, $position, $source);
12337     $position += $right_paren->width();
12338     $left_brace = EditableSyntax::from_json(
12339       $json->switch_left_brace, $position, $source);
12340     $position += $left_brace->width();
12341     $sections = EditableSyntax::from_json(
12342       $json->switch_sections, $position, $source);
12343     $position += $sections->width();
12344     $right_brace = EditableSyntax::from_json(
12345       $json->switch_right_brace, $position, $source);
12346     $position += $right_brace->width();
12347     return new SwitchStatement(
12348         $keyword,
12349         $left_paren,
12350         $expression,
12351         $right_paren,
12352         $left_brace,
12353         $sections,
12354         $right_brace);
12355   }
12356   public function children(): Generator<string, EditableSyntax, void> {
12357     yield $this->_keyword;
12358     yield $this->_left_paren;
12359     yield $this->_expression;
12360     yield $this->_right_paren;
12361     yield $this->_left_brace;
12362     yield $this->_sections;
12363     yield $this->_right_brace;
12364     yield break;
12365   }
12366 }
12367 final class SwitchSection extends EditableSyntax {
12368   private EditableSyntax $_labels;
12369   private EditableSyntax $_statements;
12370   private EditableSyntax $_fallthrough;
12371   public function __construct(
12372     EditableSyntax $labels,
12373     EditableSyntax $statements,
12374     EditableSyntax $fallthrough) {
12375     parent::__construct('switch_section');
12376     $this->_labels = $labels;
12377     $this->_statements = $statements;
12378     $this->_fallthrough = $fallthrough;
12379   }
12380   public function labels(): EditableSyntax {
12381     return $this->_labels;
12382   }
12383   public function statements(): EditableSyntax {
12384     return $this->_statements;
12385   }
12386   public function fallthrough(): EditableSyntax {
12387     return $this->_fallthrough;
12388   }
12389   public function with_labels(EditableSyntax $labels): SwitchSection {
12390     return new SwitchSection(
12391       $labels,
12392       $this->_statements,
12393       $this->_fallthrough);
12394   }
12395   public function with_statements(EditableSyntax $statements): SwitchSection {
12396     return new SwitchSection(
12397       $this->_labels,
12398       $statements,
12399       $this->_fallthrough);
12400   }
12401   public function with_fallthrough(EditableSyntax $fallthrough): SwitchSection {
12402     return new SwitchSection(
12403       $this->_labels,
12404       $this->_statements,
12405       $fallthrough);
12406   }
12407
12408   public function rewrite(
12409     ( function
12410       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
12411     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
12412     $new_parents = $parents ?? [];
12413     array_push($new_parents, $this);
12414     $labels = $this->labels()->rewrite($rewriter, $new_parents);
12415     $statements = $this->statements()->rewrite($rewriter, $new_parents);
12416     $fallthrough = $this->fallthrough()->rewrite($rewriter, $new_parents);
12417     if (
12418       $labels === $this->labels() &&
12419       $statements === $this->statements() &&
12420       $fallthrough === $this->fallthrough()) {
12421       return $rewriter($this, $parents ?? []);
12422     } else {
12423       return $rewriter(new SwitchSection(
12424         $labels,
12425         $statements,
12426         $fallthrough), $parents ?? []);
12427     }
12428   }
12429
12430   public static function from_json(mixed $json, int $position, string $source) {
12431     $labels = EditableSyntax::from_json(
12432       $json->switch_section_labels, $position, $source);
12433     $position += $labels->width();
12434     $statements = EditableSyntax::from_json(
12435       $json->switch_section_statements, $position, $source);
12436     $position += $statements->width();
12437     $fallthrough = EditableSyntax::from_json(
12438       $json->switch_section_fallthrough, $position, $source);
12439     $position += $fallthrough->width();
12440     return new SwitchSection(
12441         $labels,
12442         $statements,
12443         $fallthrough);
12444   }
12445   public function children(): Generator<string, EditableSyntax, void> {
12446     yield $this->_labels;
12447     yield $this->_statements;
12448     yield $this->_fallthrough;
12449     yield break;
12450   }
12451 }
12452 final class SwitchFallthrough extends EditableSyntax {
12453   private EditableSyntax $_keyword;
12454   private EditableSyntax $_semicolon;
12455   public function __construct(
12456     EditableSyntax $keyword,
12457     EditableSyntax $semicolon) {
12458     parent::__construct('switch_fallthrough');
12459     $this->_keyword = $keyword;
12460     $this->_semicolon = $semicolon;
12461   }
12462   public function keyword(): EditableSyntax {
12463     return $this->_keyword;
12464   }
12465   public function semicolon(): EditableSyntax {
12466     return $this->_semicolon;
12467   }
12468   public function with_keyword(EditableSyntax $keyword): SwitchFallthrough {
12469     return new SwitchFallthrough(
12470       $keyword,
12471       $this->_semicolon);
12472   }
12473   public function with_semicolon(EditableSyntax $semicolon): SwitchFallthrough {
12474     return new SwitchFallthrough(
12475       $this->_keyword,
12476       $semicolon);
12477   }
12478
12479   public function rewrite(
12480     ( function
12481       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
12482     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
12483     $new_parents = $parents ?? [];
12484     array_push($new_parents, $this);
12485     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
12486     $semicolon = $this->semicolon()->rewrite($rewriter, $new_parents);
12487     if (
12488       $keyword === $this->keyword() &&
12489       $semicolon === $this->semicolon()) {
12490       return $rewriter($this, $parents ?? []);
12491     } else {
12492       return $rewriter(new SwitchFallthrough(
12493         $keyword,
12494         $semicolon), $parents ?? []);
12495     }
12496   }
12497
12498   public static function from_json(mixed $json, int $position, string $source) {
12499     $keyword = EditableSyntax::from_json(
12500       $json->fallthrough_keyword, $position, $source);
12501     $position += $keyword->width();
12502     $semicolon = EditableSyntax::from_json(
12503       $json->fallthrough_semicolon, $position, $source);
12504     $position += $semicolon->width();
12505     return new SwitchFallthrough(
12506         $keyword,
12507         $semicolon);
12508   }
12509   public function children(): Generator<string, EditableSyntax, void> {
12510     yield $this->_keyword;
12511     yield $this->_semicolon;
12512     yield break;
12513   }
12514 }
12515 final class CaseLabel extends EditableSyntax {
12516   private EditableSyntax $_keyword;
12517   private EditableSyntax $_expression;
12518   private EditableSyntax $_colon;
12519   public function __construct(
12520     EditableSyntax $keyword,
12521     EditableSyntax $expression,
12522     EditableSyntax $colon) {
12523     parent::__construct('case_label');
12524     $this->_keyword = $keyword;
12525     $this->_expression = $expression;
12526     $this->_colon = $colon;
12527   }
12528   public function keyword(): EditableSyntax {
12529     return $this->_keyword;
12530   }
12531   public function expression(): EditableSyntax {
12532     return $this->_expression;
12533   }
12534   public function colon(): EditableSyntax {
12535     return $this->_colon;
12536   }
12537   public function with_keyword(EditableSyntax $keyword): CaseLabel {
12538     return new CaseLabel(
12539       $keyword,
12540       $this->_expression,
12541       $this->_colon);
12542   }
12543   public function with_expression(EditableSyntax $expression): CaseLabel {
12544     return new CaseLabel(
12545       $this->_keyword,
12546       $expression,
12547       $this->_colon);
12548   }
12549   public function with_colon(EditableSyntax $colon): CaseLabel {
12550     return new CaseLabel(
12551       $this->_keyword,
12552       $this->_expression,
12553       $colon);
12554   }
12555
12556   public function rewrite(
12557     ( function
12558       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
12559     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
12560     $new_parents = $parents ?? [];
12561     array_push($new_parents, $this);
12562     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
12563     $expression = $this->expression()->rewrite($rewriter, $new_parents);
12564     $colon = $this->colon()->rewrite($rewriter, $new_parents);
12565     if (
12566       $keyword === $this->keyword() &&
12567       $expression === $this->expression() &&
12568       $colon === $this->colon()) {
12569       return $rewriter($this, $parents ?? []);
12570     } else {
12571       return $rewriter(new CaseLabel(
12572         $keyword,
12573         $expression,
12574         $colon), $parents ?? []);
12575     }
12576   }
12577
12578   public static function from_json(mixed $json, int $position, string $source) {
12579     $keyword = EditableSyntax::from_json(
12580       $json->case_keyword, $position, $source);
12581     $position += $keyword->width();
12582     $expression = EditableSyntax::from_json(
12583       $json->case_expression, $position, $source);
12584     $position += $expression->width();
12585     $colon = EditableSyntax::from_json(
12586       $json->case_colon, $position, $source);
12587     $position += $colon->width();
12588     return new CaseLabel(
12589         $keyword,
12590         $expression,
12591         $colon);
12592   }
12593   public function children(): Generator<string, EditableSyntax, void> {
12594     yield $this->_keyword;
12595     yield $this->_expression;
12596     yield $this->_colon;
12597     yield break;
12598   }
12599 }
12600 final class DefaultLabel extends EditableSyntax {
12601   private EditableSyntax $_keyword;
12602   private EditableSyntax $_colon;
12603   public function __construct(
12604     EditableSyntax $keyword,
12605     EditableSyntax $colon) {
12606     parent::__construct('default_label');
12607     $this->_keyword = $keyword;
12608     $this->_colon = $colon;
12609   }
12610   public function keyword(): EditableSyntax {
12611     return $this->_keyword;
12612   }
12613   public function colon(): EditableSyntax {
12614     return $this->_colon;
12615   }
12616   public function with_keyword(EditableSyntax $keyword): DefaultLabel {
12617     return new DefaultLabel(
12618       $keyword,
12619       $this->_colon);
12620   }
12621   public function with_colon(EditableSyntax $colon): DefaultLabel {
12622     return new DefaultLabel(
12623       $this->_keyword,
12624       $colon);
12625   }
12626
12627   public function rewrite(
12628     ( function
12629       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
12630     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
12631     $new_parents = $parents ?? [];
12632     array_push($new_parents, $this);
12633     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
12634     $colon = $this->colon()->rewrite($rewriter, $new_parents);
12635     if (
12636       $keyword === $this->keyword() &&
12637       $colon === $this->colon()) {
12638       return $rewriter($this, $parents ?? []);
12639     } else {
12640       return $rewriter(new DefaultLabel(
12641         $keyword,
12642         $colon), $parents ?? []);
12643     }
12644   }
12645
12646   public static function from_json(mixed $json, int $position, string $source) {
12647     $keyword = EditableSyntax::from_json(
12648       $json->default_keyword, $position, $source);
12649     $position += $keyword->width();
12650     $colon = EditableSyntax::from_json(
12651       $json->default_colon, $position, $source);
12652     $position += $colon->width();
12653     return new DefaultLabel(
12654         $keyword,
12655         $colon);
12656   }
12657   public function children(): Generator<string, EditableSyntax, void> {
12658     yield $this->_keyword;
12659     yield $this->_colon;
12660     yield break;
12661   }
12662 }
12663 final class ReturnStatement extends EditableSyntax {
12664   private EditableSyntax $_keyword;
12665   private EditableSyntax $_expression;
12666   private EditableSyntax $_semicolon;
12667   public function __construct(
12668     EditableSyntax $keyword,
12669     EditableSyntax $expression,
12670     EditableSyntax $semicolon) {
12671     parent::__construct('return_statement');
12672     $this->_keyword = $keyword;
12673     $this->_expression = $expression;
12674     $this->_semicolon = $semicolon;
12675   }
12676   public function keyword(): EditableSyntax {
12677     return $this->_keyword;
12678   }
12679   public function expression(): EditableSyntax {
12680     return $this->_expression;
12681   }
12682   public function semicolon(): EditableSyntax {
12683     return $this->_semicolon;
12684   }
12685   public function with_keyword(EditableSyntax $keyword): ReturnStatement {
12686     return new ReturnStatement(
12687       $keyword,
12688       $this->_expression,
12689       $this->_semicolon);
12690   }
12691   public function with_expression(EditableSyntax $expression): ReturnStatement {
12692     return new ReturnStatement(
12693       $this->_keyword,
12694       $expression,
12695       $this->_semicolon);
12696   }
12697   public function with_semicolon(EditableSyntax $semicolon): ReturnStatement {
12698     return new ReturnStatement(
12699       $this->_keyword,
12700       $this->_expression,
12701       $semicolon);
12702   }
12703
12704   public function rewrite(
12705     ( function
12706       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
12707     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
12708     $new_parents = $parents ?? [];
12709     array_push($new_parents, $this);
12710     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
12711     $expression = $this->expression()->rewrite($rewriter, $new_parents);
12712     $semicolon = $this->semicolon()->rewrite($rewriter, $new_parents);
12713     if (
12714       $keyword === $this->keyword() &&
12715       $expression === $this->expression() &&
12716       $semicolon === $this->semicolon()) {
12717       return $rewriter($this, $parents ?? []);
12718     } else {
12719       return $rewriter(new ReturnStatement(
12720         $keyword,
12721         $expression,
12722         $semicolon), $parents ?? []);
12723     }
12724   }
12725
12726   public static function from_json(mixed $json, int $position, string $source) {
12727     $keyword = EditableSyntax::from_json(
12728       $json->return_keyword, $position, $source);
12729     $position += $keyword->width();
12730     $expression = EditableSyntax::from_json(
12731       $json->return_expression, $position, $source);
12732     $position += $expression->width();
12733     $semicolon = EditableSyntax::from_json(
12734       $json->return_semicolon, $position, $source);
12735     $position += $semicolon->width();
12736     return new ReturnStatement(
12737         $keyword,
12738         $expression,
12739         $semicolon);
12740   }
12741   public function children(): Generator<string, EditableSyntax, void> {
12742     yield $this->_keyword;
12743     yield $this->_expression;
12744     yield $this->_semicolon;
12745     yield break;
12746   }
12747 }
12748 final class GotoLabel extends EditableSyntax {
12749   private EditableSyntax $_name;
12750   private EditableSyntax $_colon;
12751   public function __construct(
12752     EditableSyntax $name,
12753     EditableSyntax $colon) {
12754     parent::__construct('goto_label');
12755     $this->_name = $name;
12756     $this->_colon = $colon;
12757   }
12758   public function name(): EditableSyntax {
12759     return $this->_name;
12760   }
12761   public function colon(): EditableSyntax {
12762     return $this->_colon;
12763   }
12764   public function with_name(EditableSyntax $name): GotoLabel {
12765     return new GotoLabel(
12766       $name,
12767       $this->_colon);
12768   }
12769   public function with_colon(EditableSyntax $colon): GotoLabel {
12770     return new GotoLabel(
12771       $this->_name,
12772       $colon);
12773   }
12774
12775   public function rewrite(
12776     ( function
12777       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
12778     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
12779     $new_parents = $parents ?? [];
12780     array_push($new_parents, $this);
12781     $name = $this->name()->rewrite($rewriter, $new_parents);
12782     $colon = $this->colon()->rewrite($rewriter, $new_parents);
12783     if (
12784       $name === $this->name() &&
12785       $colon === $this->colon()) {
12786       return $rewriter($this, $parents ?? []);
12787     } else {
12788       return $rewriter(new GotoLabel(
12789         $name,
12790         $colon), $parents ?? []);
12791     }
12792   }
12793
12794   public static function from_json(mixed $json, int $position, string $source) {
12795     $name = EditableSyntax::from_json(
12796       $json->goto_label_name, $position, $source);
12797     $position += $name->width();
12798     $colon = EditableSyntax::from_json(
12799       $json->goto_label_colon, $position, $source);
12800     $position += $colon->width();
12801     return new GotoLabel(
12802         $name,
12803         $colon);
12804   }
12805   public function children(): Generator<string, EditableSyntax, void> {
12806     yield $this->_name;
12807     yield $this->_colon;
12808     yield break;
12809   }
12810 }
12811 final class GotoStatement extends EditableSyntax {
12812   private EditableSyntax $_keyword;
12813   private EditableSyntax $_label_name;
12814   private EditableSyntax $_semicolon;
12815   public function __construct(
12816     EditableSyntax $keyword,
12817     EditableSyntax $label_name,
12818     EditableSyntax $semicolon) {
12819     parent::__construct('goto_statement');
12820     $this->_keyword = $keyword;
12821     $this->_label_name = $label_name;
12822     $this->_semicolon = $semicolon;
12823   }
12824   public function keyword(): EditableSyntax {
12825     return $this->_keyword;
12826   }
12827   public function label_name(): EditableSyntax {
12828     return $this->_label_name;
12829   }
12830   public function semicolon(): EditableSyntax {
12831     return $this->_semicolon;
12832   }
12833   public function with_keyword(EditableSyntax $keyword): GotoStatement {
12834     return new GotoStatement(
12835       $keyword,
12836       $this->_label_name,
12837       $this->_semicolon);
12838   }
12839   public function with_label_name(EditableSyntax $label_name): GotoStatement {
12840     return new GotoStatement(
12841       $this->_keyword,
12842       $label_name,
12843       $this->_semicolon);
12844   }
12845   public function with_semicolon(EditableSyntax $semicolon): GotoStatement {
12846     return new GotoStatement(
12847       $this->_keyword,
12848       $this->_label_name,
12849       $semicolon);
12850   }
12851
12852   public function rewrite(
12853     ( function
12854       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
12855     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
12856     $new_parents = $parents ?? [];
12857     array_push($new_parents, $this);
12858     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
12859     $label_name = $this->label_name()->rewrite($rewriter, $new_parents);
12860     $semicolon = $this->semicolon()->rewrite($rewriter, $new_parents);
12861     if (
12862       $keyword === $this->keyword() &&
12863       $label_name === $this->label_name() &&
12864       $semicolon === $this->semicolon()) {
12865       return $rewriter($this, $parents ?? []);
12866     } else {
12867       return $rewriter(new GotoStatement(
12868         $keyword,
12869         $label_name,
12870         $semicolon), $parents ?? []);
12871     }
12872   }
12873
12874   public static function from_json(mixed $json, int $position, string $source) {
12875     $keyword = EditableSyntax::from_json(
12876       $json->goto_statement_keyword, $position, $source);
12877     $position += $keyword->width();
12878     $label_name = EditableSyntax::from_json(
12879       $json->goto_statement_label_name, $position, $source);
12880     $position += $label_name->width();
12881     $semicolon = EditableSyntax::from_json(
12882       $json->goto_statement_semicolon, $position, $source);
12883     $position += $semicolon->width();
12884     return new GotoStatement(
12885         $keyword,
12886         $label_name,
12887         $semicolon);
12888   }
12889   public function children(): Generator<string, EditableSyntax, void> {
12890     yield $this->_keyword;
12891     yield $this->_label_name;
12892     yield $this->_semicolon;
12893     yield break;
12894   }
12895 }
12896 final class ThrowStatement extends EditableSyntax {
12897   private EditableSyntax $_keyword;
12898   private EditableSyntax $_expression;
12899   private EditableSyntax $_semicolon;
12900   public function __construct(
12901     EditableSyntax $keyword,
12902     EditableSyntax $expression,
12903     EditableSyntax $semicolon) {
12904     parent::__construct('throw_statement');
12905     $this->_keyword = $keyword;
12906     $this->_expression = $expression;
12907     $this->_semicolon = $semicolon;
12908   }
12909   public function keyword(): EditableSyntax {
12910     return $this->_keyword;
12911   }
12912   public function expression(): EditableSyntax {
12913     return $this->_expression;
12914   }
12915   public function semicolon(): EditableSyntax {
12916     return $this->_semicolon;
12917   }
12918   public function with_keyword(EditableSyntax $keyword): ThrowStatement {
12919     return new ThrowStatement(
12920       $keyword,
12921       $this->_expression,
12922       $this->_semicolon);
12923   }
12924   public function with_expression(EditableSyntax $expression): ThrowStatement {
12925     return new ThrowStatement(
12926       $this->_keyword,
12927       $expression,
12928       $this->_semicolon);
12929   }
12930   public function with_semicolon(EditableSyntax $semicolon): ThrowStatement {
12931     return new ThrowStatement(
12932       $this->_keyword,
12933       $this->_expression,
12934       $semicolon);
12935   }
12936
12937   public function rewrite(
12938     ( function
12939       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
12940     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
12941     $new_parents = $parents ?? [];
12942     array_push($new_parents, $this);
12943     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
12944     $expression = $this->expression()->rewrite($rewriter, $new_parents);
12945     $semicolon = $this->semicolon()->rewrite($rewriter, $new_parents);
12946     if (
12947       $keyword === $this->keyword() &&
12948       $expression === $this->expression() &&
12949       $semicolon === $this->semicolon()) {
12950       return $rewriter($this, $parents ?? []);
12951     } else {
12952       return $rewriter(new ThrowStatement(
12953         $keyword,
12954         $expression,
12955         $semicolon), $parents ?? []);
12956     }
12957   }
12958
12959   public static function from_json(mixed $json, int $position, string $source) {
12960     $keyword = EditableSyntax::from_json(
12961       $json->throw_keyword, $position, $source);
12962     $position += $keyword->width();
12963     $expression = EditableSyntax::from_json(
12964       $json->throw_expression, $position, $source);
12965     $position += $expression->width();
12966     $semicolon = EditableSyntax::from_json(
12967       $json->throw_semicolon, $position, $source);
12968     $position += $semicolon->width();
12969     return new ThrowStatement(
12970         $keyword,
12971         $expression,
12972         $semicolon);
12973   }
12974   public function children(): Generator<string, EditableSyntax, void> {
12975     yield $this->_keyword;
12976     yield $this->_expression;
12977     yield $this->_semicolon;
12978     yield break;
12979   }
12980 }
12981 final class BreakStatement extends EditableSyntax {
12982   private EditableSyntax $_keyword;
12983   private EditableSyntax $_level;
12984   private EditableSyntax $_semicolon;
12985   public function __construct(
12986     EditableSyntax $keyword,
12987     EditableSyntax $level,
12988     EditableSyntax $semicolon) {
12989     parent::__construct('break_statement');
12990     $this->_keyword = $keyword;
12991     $this->_level = $level;
12992     $this->_semicolon = $semicolon;
12993   }
12994   public function keyword(): EditableSyntax {
12995     return $this->_keyword;
12996   }
12997   public function level(): EditableSyntax {
12998     return $this->_level;
12999   }
13000   public function semicolon(): EditableSyntax {
13001     return $this->_semicolon;
13002   }
13003   public function with_keyword(EditableSyntax $keyword): BreakStatement {
13004     return new BreakStatement(
13005       $keyword,
13006       $this->_level,
13007       $this->_semicolon);
13008   }
13009   public function with_level(EditableSyntax $level): BreakStatement {
13010     return new BreakStatement(
13011       $this->_keyword,
13012       $level,
13013       $this->_semicolon);
13014   }
13015   public function with_semicolon(EditableSyntax $semicolon): BreakStatement {
13016     return new BreakStatement(
13017       $this->_keyword,
13018       $this->_level,
13019       $semicolon);
13020   }
13021
13022   public function rewrite(
13023     ( function
13024       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
13025     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
13026     $new_parents = $parents ?? [];
13027     array_push($new_parents, $this);
13028     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
13029     $level = $this->level()->rewrite($rewriter, $new_parents);
13030     $semicolon = $this->semicolon()->rewrite($rewriter, $new_parents);
13031     if (
13032       $keyword === $this->keyword() &&
13033       $level === $this->level() &&
13034       $semicolon === $this->semicolon()) {
13035       return $rewriter($this, $parents ?? []);
13036     } else {
13037       return $rewriter(new BreakStatement(
13038         $keyword,
13039         $level,
13040         $semicolon), $parents ?? []);
13041     }
13042   }
13043
13044   public static function from_json(mixed $json, int $position, string $source) {
13045     $keyword = EditableSyntax::from_json(
13046       $json->break_keyword, $position, $source);
13047     $position += $keyword->width();
13048     $level = EditableSyntax::from_json(
13049       $json->break_level, $position, $source);
13050     $position += $level->width();
13051     $semicolon = EditableSyntax::from_json(
13052       $json->break_semicolon, $position, $source);
13053     $position += $semicolon->width();
13054     return new BreakStatement(
13055         $keyword,
13056         $level,
13057         $semicolon);
13058   }
13059   public function children(): Generator<string, EditableSyntax, void> {
13060     yield $this->_keyword;
13061     yield $this->_level;
13062     yield $this->_semicolon;
13063     yield break;
13064   }
13065 }
13066 final class ContinueStatement extends EditableSyntax {
13067   private EditableSyntax $_keyword;
13068   private EditableSyntax $_level;
13069   private EditableSyntax $_semicolon;
13070   public function __construct(
13071     EditableSyntax $keyword,
13072     EditableSyntax $level,
13073     EditableSyntax $semicolon) {
13074     parent::__construct('continue_statement');
13075     $this->_keyword = $keyword;
13076     $this->_level = $level;
13077     $this->_semicolon = $semicolon;
13078   }
13079   public function keyword(): EditableSyntax {
13080     return $this->_keyword;
13081   }
13082   public function level(): EditableSyntax {
13083     return $this->_level;
13084   }
13085   public function semicolon(): EditableSyntax {
13086     return $this->_semicolon;
13087   }
13088   public function with_keyword(EditableSyntax $keyword): ContinueStatement {
13089     return new ContinueStatement(
13090       $keyword,
13091       $this->_level,
13092       $this->_semicolon);
13093   }
13094   public function with_level(EditableSyntax $level): ContinueStatement {
13095     return new ContinueStatement(
13096       $this->_keyword,
13097       $level,
13098       $this->_semicolon);
13099   }
13100   public function with_semicolon(EditableSyntax $semicolon): ContinueStatement {
13101     return new ContinueStatement(
13102       $this->_keyword,
13103       $this->_level,
13104       $semicolon);
13105   }
13106
13107   public function rewrite(
13108     ( function
13109       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
13110     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
13111     $new_parents = $parents ?? [];
13112     array_push($new_parents, $this);
13113     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
13114     $level = $this->level()->rewrite($rewriter, $new_parents);
13115     $semicolon = $this->semicolon()->rewrite($rewriter, $new_parents);
13116     if (
13117       $keyword === $this->keyword() &&
13118       $level === $this->level() &&
13119       $semicolon === $this->semicolon()) {
13120       return $rewriter($this, $parents ?? []);
13121     } else {
13122       return $rewriter(new ContinueStatement(
13123         $keyword,
13124         $level,
13125         $semicolon), $parents ?? []);
13126     }
13127   }
13128
13129   public static function from_json(mixed $json, int $position, string $source) {
13130     $keyword = EditableSyntax::from_json(
13131       $json->continue_keyword, $position, $source);
13132     $position += $keyword->width();
13133     $level = EditableSyntax::from_json(
13134       $json->continue_level, $position, $source);
13135     $position += $level->width();
13136     $semicolon = EditableSyntax::from_json(
13137       $json->continue_semicolon, $position, $source);
13138     $position += $semicolon->width();
13139     return new ContinueStatement(
13140         $keyword,
13141         $level,
13142         $semicolon);
13143   }
13144   public function children(): Generator<string, EditableSyntax, void> {
13145     yield $this->_keyword;
13146     yield $this->_level;
13147     yield $this->_semicolon;
13148     yield break;
13149   }
13150 }
13151 final class FunctionStaticStatement extends EditableSyntax {
13152   private EditableSyntax $_static_keyword;
13153   private EditableSyntax $_declarations;
13154   private EditableSyntax $_semicolon;
13155   public function __construct(
13156     EditableSyntax $static_keyword,
13157     EditableSyntax $declarations,
13158     EditableSyntax $semicolon) {
13159     parent::__construct('function_static_statement');
13160     $this->_static_keyword = $static_keyword;
13161     $this->_declarations = $declarations;
13162     $this->_semicolon = $semicolon;
13163   }
13164   public function static_keyword(): EditableSyntax {
13165     return $this->_static_keyword;
13166   }
13167   public function declarations(): EditableSyntax {
13168     return $this->_declarations;
13169   }
13170   public function semicolon(): EditableSyntax {
13171     return $this->_semicolon;
13172   }
13173   public function with_static_keyword(EditableSyntax $static_keyword): FunctionStaticStatement {
13174     return new FunctionStaticStatement(
13175       $static_keyword,
13176       $this->_declarations,
13177       $this->_semicolon);
13178   }
13179   public function with_declarations(EditableSyntax $declarations): FunctionStaticStatement {
13180     return new FunctionStaticStatement(
13181       $this->_static_keyword,
13182       $declarations,
13183       $this->_semicolon);
13184   }
13185   public function with_semicolon(EditableSyntax $semicolon): FunctionStaticStatement {
13186     return new FunctionStaticStatement(
13187       $this->_static_keyword,
13188       $this->_declarations,
13189       $semicolon);
13190   }
13191
13192   public function rewrite(
13193     ( function
13194       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
13195     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
13196     $new_parents = $parents ?? [];
13197     array_push($new_parents, $this);
13198     $static_keyword = $this->static_keyword()->rewrite($rewriter, $new_parents);
13199     $declarations = $this->declarations()->rewrite($rewriter, $new_parents);
13200     $semicolon = $this->semicolon()->rewrite($rewriter, $new_parents);
13201     if (
13202       $static_keyword === $this->static_keyword() &&
13203       $declarations === $this->declarations() &&
13204       $semicolon === $this->semicolon()) {
13205       return $rewriter($this, $parents ?? []);
13206     } else {
13207       return $rewriter(new FunctionStaticStatement(
13208         $static_keyword,
13209         $declarations,
13210         $semicolon), $parents ?? []);
13211     }
13212   }
13213
13214   public static function from_json(mixed $json, int $position, string $source) {
13215     $static_keyword = EditableSyntax::from_json(
13216       $json->static_static_keyword, $position, $source);
13217     $position += $static_keyword->width();
13218     $declarations = EditableSyntax::from_json(
13219       $json->static_declarations, $position, $source);
13220     $position += $declarations->width();
13221     $semicolon = EditableSyntax::from_json(
13222       $json->static_semicolon, $position, $source);
13223     $position += $semicolon->width();
13224     return new FunctionStaticStatement(
13225         $static_keyword,
13226         $declarations,
13227         $semicolon);
13228   }
13229   public function children(): Generator<string, EditableSyntax, void> {
13230     yield $this->_static_keyword;
13231     yield $this->_declarations;
13232     yield $this->_semicolon;
13233     yield break;
13234   }
13235 }
13236 final class StaticDeclarator extends EditableSyntax {
13237   private EditableSyntax $_name;
13238   private EditableSyntax $_initializer;
13239   public function __construct(
13240     EditableSyntax $name,
13241     EditableSyntax $initializer) {
13242     parent::__construct('static_declarator');
13243     $this->_name = $name;
13244     $this->_initializer = $initializer;
13245   }
13246   public function name(): EditableSyntax {
13247     return $this->_name;
13248   }
13249   public function initializer(): EditableSyntax {
13250     return $this->_initializer;
13251   }
13252   public function with_name(EditableSyntax $name): StaticDeclarator {
13253     return new StaticDeclarator(
13254       $name,
13255       $this->_initializer);
13256   }
13257   public function with_initializer(EditableSyntax $initializer): StaticDeclarator {
13258     return new StaticDeclarator(
13259       $this->_name,
13260       $initializer);
13261   }
13262
13263   public function rewrite(
13264     ( function
13265       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
13266     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
13267     $new_parents = $parents ?? [];
13268     array_push($new_parents, $this);
13269     $name = $this->name()->rewrite($rewriter, $new_parents);
13270     $initializer = $this->initializer()->rewrite($rewriter, $new_parents);
13271     if (
13272       $name === $this->name() &&
13273       $initializer === $this->initializer()) {
13274       return $rewriter($this, $parents ?? []);
13275     } else {
13276       return $rewriter(new StaticDeclarator(
13277         $name,
13278         $initializer), $parents ?? []);
13279     }
13280   }
13281
13282   public static function from_json(mixed $json, int $position, string $source) {
13283     $name = EditableSyntax::from_json(
13284       $json->static_name, $position, $source);
13285     $position += $name->width();
13286     $initializer = EditableSyntax::from_json(
13287       $json->static_initializer, $position, $source);
13288     $position += $initializer->width();
13289     return new StaticDeclarator(
13290         $name,
13291         $initializer);
13292   }
13293   public function children(): Generator<string, EditableSyntax, void> {
13294     yield $this->_name;
13295     yield $this->_initializer;
13296     yield break;
13297   }
13298 }
13299 final class EchoStatement extends EditableSyntax {
13300   private EditableSyntax $_keyword;
13301   private EditableSyntax $_expressions;
13302   private EditableSyntax $_semicolon;
13303   public function __construct(
13304     EditableSyntax $keyword,
13305     EditableSyntax $expressions,
13306     EditableSyntax $semicolon) {
13307     parent::__construct('echo_statement');
13308     $this->_keyword = $keyword;
13309     $this->_expressions = $expressions;
13310     $this->_semicolon = $semicolon;
13311   }
13312   public function keyword(): EditableSyntax {
13313     return $this->_keyword;
13314   }
13315   public function expressions(): EditableSyntax {
13316     return $this->_expressions;
13317   }
13318   public function semicolon(): EditableSyntax {
13319     return $this->_semicolon;
13320   }
13321   public function with_keyword(EditableSyntax $keyword): EchoStatement {
13322     return new EchoStatement(
13323       $keyword,
13324       $this->_expressions,
13325       $this->_semicolon);
13326   }
13327   public function with_expressions(EditableSyntax $expressions): EchoStatement {
13328     return new EchoStatement(
13329       $this->_keyword,
13330       $expressions,
13331       $this->_semicolon);
13332   }
13333   public function with_semicolon(EditableSyntax $semicolon): EchoStatement {
13334     return new EchoStatement(
13335       $this->_keyword,
13336       $this->_expressions,
13337       $semicolon);
13338   }
13339
13340   public function rewrite(
13341     ( function
13342       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
13343     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
13344     $new_parents = $parents ?? [];
13345     array_push($new_parents, $this);
13346     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
13347     $expressions = $this->expressions()->rewrite($rewriter, $new_parents);
13348     $semicolon = $this->semicolon()->rewrite($rewriter, $new_parents);
13349     if (
13350       $keyword === $this->keyword() &&
13351       $expressions === $this->expressions() &&
13352       $semicolon === $this->semicolon()) {
13353       return $rewriter($this, $parents ?? []);
13354     } else {
13355       return $rewriter(new EchoStatement(
13356         $keyword,
13357         $expressions,
13358         $semicolon), $parents ?? []);
13359     }
13360   }
13361
13362   public static function from_json(mixed $json, int $position, string $source) {
13363     $keyword = EditableSyntax::from_json(
13364       $json->echo_keyword, $position, $source);
13365     $position += $keyword->width();
13366     $expressions = EditableSyntax::from_json(
13367       $json->echo_expressions, $position, $source);
13368     $position += $expressions->width();
13369     $semicolon = EditableSyntax::from_json(
13370       $json->echo_semicolon, $position, $source);
13371     $position += $semicolon->width();
13372     return new EchoStatement(
13373         $keyword,
13374         $expressions,
13375         $semicolon);
13376   }
13377   public function children(): Generator<string, EditableSyntax, void> {
13378     yield $this->_keyword;
13379     yield $this->_expressions;
13380     yield $this->_semicolon;
13381     yield break;
13382   }
13383 }
13384 final class GlobalStatement extends EditableSyntax {
13385   private EditableSyntax $_keyword;
13386   private EditableSyntax $_variables;
13387   private EditableSyntax $_semicolon;
13388   public function __construct(
13389     EditableSyntax $keyword,
13390     EditableSyntax $variables,
13391     EditableSyntax $semicolon) {
13392     parent::__construct('global_statement');
13393     $this->_keyword = $keyword;
13394     $this->_variables = $variables;
13395     $this->_semicolon = $semicolon;
13396   }
13397   public function keyword(): EditableSyntax {
13398     return $this->_keyword;
13399   }
13400   public function variables(): EditableSyntax {
13401     return $this->_variables;
13402   }
13403   public function semicolon(): EditableSyntax {
13404     return $this->_semicolon;
13405   }
13406   public function with_keyword(EditableSyntax $keyword): GlobalStatement {
13407     return new GlobalStatement(
13408       $keyword,
13409       $this->_variables,
13410       $this->_semicolon);
13411   }
13412   public function with_variables(EditableSyntax $variables): GlobalStatement {
13413     return new GlobalStatement(
13414       $this->_keyword,
13415       $variables,
13416       $this->_semicolon);
13417   }
13418   public function with_semicolon(EditableSyntax $semicolon): GlobalStatement {
13419     return new GlobalStatement(
13420       $this->_keyword,
13421       $this->_variables,
13422       $semicolon);
13423   }
13424
13425   public function rewrite(
13426     ( function
13427       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
13428     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
13429     $new_parents = $parents ?? [];
13430     array_push($new_parents, $this);
13431     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
13432     $variables = $this->variables()->rewrite($rewriter, $new_parents);
13433     $semicolon = $this->semicolon()->rewrite($rewriter, $new_parents);
13434     if (
13435       $keyword === $this->keyword() &&
13436       $variables === $this->variables() &&
13437       $semicolon === $this->semicolon()) {
13438       return $rewriter($this, $parents ?? []);
13439     } else {
13440       return $rewriter(new GlobalStatement(
13441         $keyword,
13442         $variables,
13443         $semicolon), $parents ?? []);
13444     }
13445   }
13446
13447   public static function from_json(mixed $json, int $position, string $source) {
13448     $keyword = EditableSyntax::from_json(
13449       $json->global_keyword, $position, $source);
13450     $position += $keyword->width();
13451     $variables = EditableSyntax::from_json(
13452       $json->global_variables, $position, $source);
13453     $position += $variables->width();
13454     $semicolon = EditableSyntax::from_json(
13455       $json->global_semicolon, $position, $source);
13456     $position += $semicolon->width();
13457     return new GlobalStatement(
13458         $keyword,
13459         $variables,
13460         $semicolon);
13461   }
13462   public function children(): Generator<string, EditableSyntax, void> {
13463     yield $this->_keyword;
13464     yield $this->_variables;
13465     yield $this->_semicolon;
13466     yield break;
13467   }
13468 }
13469 final class SimpleInitializer extends EditableSyntax {
13470   private EditableSyntax $_equal;
13471   private EditableSyntax $_value;
13472   public function __construct(
13473     EditableSyntax $equal,
13474     EditableSyntax $value) {
13475     parent::__construct('simple_initializer');
13476     $this->_equal = $equal;
13477     $this->_value = $value;
13478   }
13479   public function equal(): EditableSyntax {
13480     return $this->_equal;
13481   }
13482   public function value(): EditableSyntax {
13483     return $this->_value;
13484   }
13485   public function with_equal(EditableSyntax $equal): SimpleInitializer {
13486     return new SimpleInitializer(
13487       $equal,
13488       $this->_value);
13489   }
13490   public function with_value(EditableSyntax $value): SimpleInitializer {
13491     return new SimpleInitializer(
13492       $this->_equal,
13493       $value);
13494   }
13495
13496   public function rewrite(
13497     ( function
13498       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
13499     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
13500     $new_parents = $parents ?? [];
13501     array_push($new_parents, $this);
13502     $equal = $this->equal()->rewrite($rewriter, $new_parents);
13503     $value = $this->value()->rewrite($rewriter, $new_parents);
13504     if (
13505       $equal === $this->equal() &&
13506       $value === $this->value()) {
13507       return $rewriter($this, $parents ?? []);
13508     } else {
13509       return $rewriter(new SimpleInitializer(
13510         $equal,
13511         $value), $parents ?? []);
13512     }
13513   }
13514
13515   public static function from_json(mixed $json, int $position, string $source) {
13516     $equal = EditableSyntax::from_json(
13517       $json->simple_initializer_equal, $position, $source);
13518     $position += $equal->width();
13519     $value = EditableSyntax::from_json(
13520       $json->simple_initializer_value, $position, $source);
13521     $position += $value->width();
13522     return new SimpleInitializer(
13523         $equal,
13524         $value);
13525   }
13526   public function children(): Generator<string, EditableSyntax, void> {
13527     yield $this->_equal;
13528     yield $this->_value;
13529     yield break;
13530   }
13531 }
13532 final class AnonymousClass extends EditableSyntax {
13533   private EditableSyntax $_class_keyword;
13534   private EditableSyntax $_left_paren;
13535   private EditableSyntax $_argument_list;
13536   private EditableSyntax $_right_paren;
13537   private EditableSyntax $_extends_keyword;
13538   private EditableSyntax $_extends_list;
13539   private EditableSyntax $_implements_keyword;
13540   private EditableSyntax $_implements_list;
13541   private EditableSyntax $_body;
13542   public function __construct(
13543     EditableSyntax $class_keyword,
13544     EditableSyntax $left_paren,
13545     EditableSyntax $argument_list,
13546     EditableSyntax $right_paren,
13547     EditableSyntax $extends_keyword,
13548     EditableSyntax $extends_list,
13549     EditableSyntax $implements_keyword,
13550     EditableSyntax $implements_list,
13551     EditableSyntax $body) {
13552     parent::__construct('anonymous_class');
13553     $this->_class_keyword = $class_keyword;
13554     $this->_left_paren = $left_paren;
13555     $this->_argument_list = $argument_list;
13556     $this->_right_paren = $right_paren;
13557     $this->_extends_keyword = $extends_keyword;
13558     $this->_extends_list = $extends_list;
13559     $this->_implements_keyword = $implements_keyword;
13560     $this->_implements_list = $implements_list;
13561     $this->_body = $body;
13562   }
13563   public function class_keyword(): EditableSyntax {
13564     return $this->_class_keyword;
13565   }
13566   public function left_paren(): EditableSyntax {
13567     return $this->_left_paren;
13568   }
13569   public function argument_list(): EditableSyntax {
13570     return $this->_argument_list;
13571   }
13572   public function right_paren(): EditableSyntax {
13573     return $this->_right_paren;
13574   }
13575   public function extends_keyword(): EditableSyntax {
13576     return $this->_extends_keyword;
13577   }
13578   public function extends_list(): EditableSyntax {
13579     return $this->_extends_list;
13580   }
13581   public function implements_keyword(): EditableSyntax {
13582     return $this->_implements_keyword;
13583   }
13584   public function implements_list(): EditableSyntax {
13585     return $this->_implements_list;
13586   }
13587   public function body(): EditableSyntax {
13588     return $this->_body;
13589   }
13590   public function with_class_keyword(EditableSyntax $class_keyword): AnonymousClass {
13591     return new AnonymousClass(
13592       $class_keyword,
13593       $this->_left_paren,
13594       $this->_argument_list,
13595       $this->_right_paren,
13596       $this->_extends_keyword,
13597       $this->_extends_list,
13598       $this->_implements_keyword,
13599       $this->_implements_list,
13600       $this->_body);
13601   }
13602   public function with_left_paren(EditableSyntax $left_paren): AnonymousClass {
13603     return new AnonymousClass(
13604       $this->_class_keyword,
13605       $left_paren,
13606       $this->_argument_list,
13607       $this->_right_paren,
13608       $this->_extends_keyword,
13609       $this->_extends_list,
13610       $this->_implements_keyword,
13611       $this->_implements_list,
13612       $this->_body);
13613   }
13614   public function with_argument_list(EditableSyntax $argument_list): AnonymousClass {
13615     return new AnonymousClass(
13616       $this->_class_keyword,
13617       $this->_left_paren,
13618       $argument_list,
13619       $this->_right_paren,
13620       $this->_extends_keyword,
13621       $this->_extends_list,
13622       $this->_implements_keyword,
13623       $this->_implements_list,
13624       $this->_body);
13625   }
13626   public function with_right_paren(EditableSyntax $right_paren): AnonymousClass {
13627     return new AnonymousClass(
13628       $this->_class_keyword,
13629       $this->_left_paren,
13630       $this->_argument_list,
13631       $right_paren,
13632       $this->_extends_keyword,
13633       $this->_extends_list,
13634       $this->_implements_keyword,
13635       $this->_implements_list,
13636       $this->_body);
13637   }
13638   public function with_extends_keyword(EditableSyntax $extends_keyword): AnonymousClass {
13639     return new AnonymousClass(
13640       $this->_class_keyword,
13641       $this->_left_paren,
13642       $this->_argument_list,
13643       $this->_right_paren,
13644       $extends_keyword,
13645       $this->_extends_list,
13646       $this->_implements_keyword,
13647       $this->_implements_list,
13648       $this->_body);
13649   }
13650   public function with_extends_list(EditableSyntax $extends_list): AnonymousClass {
13651     return new AnonymousClass(
13652       $this->_class_keyword,
13653       $this->_left_paren,
13654       $this->_argument_list,
13655       $this->_right_paren,
13656       $this->_extends_keyword,
13657       $extends_list,
13658       $this->_implements_keyword,
13659       $this->_implements_list,
13660       $this->_body);
13661   }
13662   public function with_implements_keyword(EditableSyntax $implements_keyword): AnonymousClass {
13663     return new AnonymousClass(
13664       $this->_class_keyword,
13665       $this->_left_paren,
13666       $this->_argument_list,
13667       $this->_right_paren,
13668       $this->_extends_keyword,
13669       $this->_extends_list,
13670       $implements_keyword,
13671       $this->_implements_list,
13672       $this->_body);
13673   }
13674   public function with_implements_list(EditableSyntax $implements_list): AnonymousClass {
13675     return new AnonymousClass(
13676       $this->_class_keyword,
13677       $this->_left_paren,
13678       $this->_argument_list,
13679       $this->_right_paren,
13680       $this->_extends_keyword,
13681       $this->_extends_list,
13682       $this->_implements_keyword,
13683       $implements_list,
13684       $this->_body);
13685   }
13686   public function with_body(EditableSyntax $body): AnonymousClass {
13687     return new AnonymousClass(
13688       $this->_class_keyword,
13689       $this->_left_paren,
13690       $this->_argument_list,
13691       $this->_right_paren,
13692       $this->_extends_keyword,
13693       $this->_extends_list,
13694       $this->_implements_keyword,
13695       $this->_implements_list,
13696       $body);
13697   }
13698
13699   public function rewrite(
13700     ( function
13701       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
13702     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
13703     $new_parents = $parents ?? [];
13704     array_push($new_parents, $this);
13705     $class_keyword = $this->class_keyword()->rewrite($rewriter, $new_parents);
13706     $left_paren = $this->left_paren()->rewrite($rewriter, $new_parents);
13707     $argument_list = $this->argument_list()->rewrite($rewriter, $new_parents);
13708     $right_paren = $this->right_paren()->rewrite($rewriter, $new_parents);
13709     $extends_keyword = $this->extends_keyword()->rewrite($rewriter, $new_parents);
13710     $extends_list = $this->extends_list()->rewrite($rewriter, $new_parents);
13711     $implements_keyword = $this->implements_keyword()->rewrite($rewriter, $new_parents);
13712     $implements_list = $this->implements_list()->rewrite($rewriter, $new_parents);
13713     $body = $this->body()->rewrite($rewriter, $new_parents);
13714     if (
13715       $class_keyword === $this->class_keyword() &&
13716       $left_paren === $this->left_paren() &&
13717       $argument_list === $this->argument_list() &&
13718       $right_paren === $this->right_paren() &&
13719       $extends_keyword === $this->extends_keyword() &&
13720       $extends_list === $this->extends_list() &&
13721       $implements_keyword === $this->implements_keyword() &&
13722       $implements_list === $this->implements_list() &&
13723       $body === $this->body()) {
13724       return $rewriter($this, $parents ?? []);
13725     } else {
13726       return $rewriter(new AnonymousClass(
13727         $class_keyword,
13728         $left_paren,
13729         $argument_list,
13730         $right_paren,
13731         $extends_keyword,
13732         $extends_list,
13733         $implements_keyword,
13734         $implements_list,
13735         $body), $parents ?? []);
13736     }
13737   }
13738
13739   public static function from_json(mixed $json, int $position, string $source) {
13740     $class_keyword = EditableSyntax::from_json(
13741       $json->anonymous_class_class_keyword, $position, $source);
13742     $position += $class_keyword->width();
13743     $left_paren = EditableSyntax::from_json(
13744       $json->anonymous_class_left_paren, $position, $source);
13745     $position += $left_paren->width();
13746     $argument_list = EditableSyntax::from_json(
13747       $json->anonymous_class_argument_list, $position, $source);
13748     $position += $argument_list->width();
13749     $right_paren = EditableSyntax::from_json(
13750       $json->anonymous_class_right_paren, $position, $source);
13751     $position += $right_paren->width();
13752     $extends_keyword = EditableSyntax::from_json(
13753       $json->anonymous_class_extends_keyword, $position, $source);
13754     $position += $extends_keyword->width();
13755     $extends_list = EditableSyntax::from_json(
13756       $json->anonymous_class_extends_list, $position, $source);
13757     $position += $extends_list->width();
13758     $implements_keyword = EditableSyntax::from_json(
13759       $json->anonymous_class_implements_keyword, $position, $source);
13760     $position += $implements_keyword->width();
13761     $implements_list = EditableSyntax::from_json(
13762       $json->anonymous_class_implements_list, $position, $source);
13763     $position += $implements_list->width();
13764     $body = EditableSyntax::from_json(
13765       $json->anonymous_class_body, $position, $source);
13766     $position += $body->width();
13767     return new AnonymousClass(
13768         $class_keyword,
13769         $left_paren,
13770         $argument_list,
13771         $right_paren,
13772         $extends_keyword,
13773         $extends_list,
13774         $implements_keyword,
13775         $implements_list,
13776         $body);
13777   }
13778   public function children(): Generator<string, EditableSyntax, void> {
13779     yield $this->_class_keyword;
13780     yield $this->_left_paren;
13781     yield $this->_argument_list;
13782     yield $this->_right_paren;
13783     yield $this->_extends_keyword;
13784     yield $this->_extends_list;
13785     yield $this->_implements_keyword;
13786     yield $this->_implements_list;
13787     yield $this->_body;
13788     yield break;
13789   }
13790 }
13791 final class AnonymousFunction extends EditableSyntax {
13792   private EditableSyntax $_static_keyword;
13793   private EditableSyntax $_async_keyword;
13794   private EditableSyntax $_coroutine_keyword;
13795   private EditableSyntax $_function_keyword;
13796   private EditableSyntax $_left_paren;
13797   private EditableSyntax $_parameters;
13798   private EditableSyntax $_right_paren;
13799   private EditableSyntax $_colon;
13800   private EditableSyntax $_type;
13801   private EditableSyntax $_use;
13802   private EditableSyntax $_body;
13803   public function __construct(
13804     EditableSyntax $static_keyword,
13805     EditableSyntax $async_keyword,
13806     EditableSyntax $coroutine_keyword,
13807     EditableSyntax $function_keyword,
13808     EditableSyntax $left_paren,
13809     EditableSyntax $parameters,
13810     EditableSyntax $right_paren,
13811     EditableSyntax $colon,
13812     EditableSyntax $type,
13813     EditableSyntax $use,
13814     EditableSyntax $body) {
13815     parent::__construct('anonymous_function');
13816     $this->_static_keyword = $static_keyword;
13817     $this->_async_keyword = $async_keyword;
13818     $this->_coroutine_keyword = $coroutine_keyword;
13819     $this->_function_keyword = $function_keyword;
13820     $this->_left_paren = $left_paren;
13821     $this->_parameters = $parameters;
13822     $this->_right_paren = $right_paren;
13823     $this->_colon = $colon;
13824     $this->_type = $type;
13825     $this->_use = $use;
13826     $this->_body = $body;
13827   }
13828   public function static_keyword(): EditableSyntax {
13829     return $this->_static_keyword;
13830   }
13831   public function async_keyword(): EditableSyntax {
13832     return $this->_async_keyword;
13833   }
13834   public function coroutine_keyword(): EditableSyntax {
13835     return $this->_coroutine_keyword;
13836   }
13837   public function function_keyword(): EditableSyntax {
13838     return $this->_function_keyword;
13839   }
13840   public function left_paren(): EditableSyntax {
13841     return $this->_left_paren;
13842   }
13843   public function parameters(): EditableSyntax {
13844     return $this->_parameters;
13845   }
13846   public function right_paren(): EditableSyntax {
13847     return $this->_right_paren;
13848   }
13849   public function colon(): EditableSyntax {
13850     return $this->_colon;
13851   }
13852   public function type(): EditableSyntax {
13853     return $this->_type;
13854   }
13855   public function use(): EditableSyntax {
13856     return $this->_use;
13857   }
13858   public function body(): EditableSyntax {
13859     return $this->_body;
13860   }
13861   public function with_static_keyword(EditableSyntax $static_keyword): AnonymousFunction {
13862     return new AnonymousFunction(
13863       $static_keyword,
13864       $this->_async_keyword,
13865       $this->_coroutine_keyword,
13866       $this->_function_keyword,
13867       $this->_left_paren,
13868       $this->_parameters,
13869       $this->_right_paren,
13870       $this->_colon,
13871       $this->_type,
13872       $this->_use,
13873       $this->_body);
13874   }
13875   public function with_async_keyword(EditableSyntax $async_keyword): AnonymousFunction {
13876     return new AnonymousFunction(
13877       $this->_static_keyword,
13878       $async_keyword,
13879       $this->_coroutine_keyword,
13880       $this->_function_keyword,
13881       $this->_left_paren,
13882       $this->_parameters,
13883       $this->_right_paren,
13884       $this->_colon,
13885       $this->_type,
13886       $this->_use,
13887       $this->_body);
13888   }
13889   public function with_coroutine_keyword(EditableSyntax $coroutine_keyword): AnonymousFunction {
13890     return new AnonymousFunction(
13891       $this->_static_keyword,
13892       $this->_async_keyword,
13893       $coroutine_keyword,
13894       $this->_function_keyword,
13895       $this->_left_paren,
13896       $this->_parameters,
13897       $this->_right_paren,
13898       $this->_colon,
13899       $this->_type,
13900       $this->_use,
13901       $this->_body);
13902   }
13903   public function with_function_keyword(EditableSyntax $function_keyword): AnonymousFunction {
13904     return new AnonymousFunction(
13905       $this->_static_keyword,
13906       $this->_async_keyword,
13907       $this->_coroutine_keyword,
13908       $function_keyword,
13909       $this->_left_paren,
13910       $this->_parameters,
13911       $this->_right_paren,
13912       $this->_colon,
13913       $this->_type,
13914       $this->_use,
13915       $this->_body);
13916   }
13917   public function with_left_paren(EditableSyntax $left_paren): AnonymousFunction {
13918     return new AnonymousFunction(
13919       $this->_static_keyword,
13920       $this->_async_keyword,
13921       $this->_coroutine_keyword,
13922       $this->_function_keyword,
13923       $left_paren,
13924       $this->_parameters,
13925       $this->_right_paren,
13926       $this->_colon,
13927       $this->_type,
13928       $this->_use,
13929       $this->_body);
13930   }
13931   public function with_parameters(EditableSyntax $parameters): AnonymousFunction {
13932     return new AnonymousFunction(
13933       $this->_static_keyword,
13934       $this->_async_keyword,
13935       $this->_coroutine_keyword,
13936       $this->_function_keyword,
13937       $this->_left_paren,
13938       $parameters,
13939       $this->_right_paren,
13940       $this->_colon,
13941       $this->_type,
13942       $this->_use,
13943       $this->_body);
13944   }
13945   public function with_right_paren(EditableSyntax $right_paren): AnonymousFunction {
13946     return new AnonymousFunction(
13947       $this->_static_keyword,
13948       $this->_async_keyword,
13949       $this->_coroutine_keyword,
13950       $this->_function_keyword,
13951       $this->_left_paren,
13952       $this->_parameters,
13953       $right_paren,
13954       $this->_colon,
13955       $this->_type,
13956       $this->_use,
13957       $this->_body);
13958   }
13959   public function with_colon(EditableSyntax $colon): AnonymousFunction {
13960     return new AnonymousFunction(
13961       $this->_static_keyword,
13962       $this->_async_keyword,
13963       $this->_coroutine_keyword,
13964       $this->_function_keyword,
13965       $this->_left_paren,
13966       $this->_parameters,
13967       $this->_right_paren,
13968       $colon,
13969       $this->_type,
13970       $this->_use,
13971       $this->_body);
13972   }
13973   public function with_type(EditableSyntax $type): AnonymousFunction {
13974     return new AnonymousFunction(
13975       $this->_static_keyword,
13976       $this->_async_keyword,
13977       $this->_coroutine_keyword,
13978       $this->_function_keyword,
13979       $this->_left_paren,
13980       $this->_parameters,
13981       $this->_right_paren,
13982       $this->_colon,
13983       $type,
13984       $this->_use,
13985       $this->_body);
13986   }
13987   public function with_use(EditableSyntax $use): AnonymousFunction {
13988     return new AnonymousFunction(
13989       $this->_static_keyword,
13990       $this->_async_keyword,
13991       $this->_coroutine_keyword,
13992       $this->_function_keyword,
13993       $this->_left_paren,
13994       $this->_parameters,
13995       $this->_right_paren,
13996       $this->_colon,
13997       $this->_type,
13998       $use,
13999       $this->_body);
14000   }
14001   public function with_body(EditableSyntax $body): AnonymousFunction {
14002     return new AnonymousFunction(
14003       $this->_static_keyword,
14004       $this->_async_keyword,
14005       $this->_coroutine_keyword,
14006       $this->_function_keyword,
14007       $this->_left_paren,
14008       $this->_parameters,
14009       $this->_right_paren,
14010       $this->_colon,
14011       $this->_type,
14012       $this->_use,
14013       $body);
14014   }
14015
14016   public function rewrite(
14017     ( function
14018       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
14019     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
14020     $new_parents = $parents ?? [];
14021     array_push($new_parents, $this);
14022     $static_keyword = $this->static_keyword()->rewrite($rewriter, $new_parents);
14023     $async_keyword = $this->async_keyword()->rewrite($rewriter, $new_parents);
14024     $coroutine_keyword = $this->coroutine_keyword()->rewrite($rewriter, $new_parents);
14025     $function_keyword = $this->function_keyword()->rewrite($rewriter, $new_parents);
14026     $left_paren = $this->left_paren()->rewrite($rewriter, $new_parents);
14027     $parameters = $this->parameters()->rewrite($rewriter, $new_parents);
14028     $right_paren = $this->right_paren()->rewrite($rewriter, $new_parents);
14029     $colon = $this->colon()->rewrite($rewriter, $new_parents);
14030     $type = $this->type()->rewrite($rewriter, $new_parents);
14031     $use = $this->use()->rewrite($rewriter, $new_parents);
14032     $body = $this->body()->rewrite($rewriter, $new_parents);
14033     if (
14034       $static_keyword === $this->static_keyword() &&
14035       $async_keyword === $this->async_keyword() &&
14036       $coroutine_keyword === $this->coroutine_keyword() &&
14037       $function_keyword === $this->function_keyword() &&
14038       $left_paren === $this->left_paren() &&
14039       $parameters === $this->parameters() &&
14040       $right_paren === $this->right_paren() &&
14041       $colon === $this->colon() &&
14042       $type === $this->type() &&
14043       $use === $this->use() &&
14044       $body === $this->body()) {
14045       return $rewriter($this, $parents ?? []);
14046     } else {
14047       return $rewriter(new AnonymousFunction(
14048         $static_keyword,
14049         $async_keyword,
14050         $coroutine_keyword,
14051         $function_keyword,
14052         $left_paren,
14053         $parameters,
14054         $right_paren,
14055         $colon,
14056         $type,
14057         $use,
14058         $body), $parents ?? []);
14059     }
14060   }
14061
14062   public static function from_json(mixed $json, int $position, string $source) {
14063     $static_keyword = EditableSyntax::from_json(
14064       $json->anonymous_static_keyword, $position, $source);
14065     $position += $static_keyword->width();
14066     $async_keyword = EditableSyntax::from_json(
14067       $json->anonymous_async_keyword, $position, $source);
14068     $position += $async_keyword->width();
14069     $coroutine_keyword = EditableSyntax::from_json(
14070       $json->anonymous_coroutine_keyword, $position, $source);
14071     $position += $coroutine_keyword->width();
14072     $function_keyword = EditableSyntax::from_json(
14073       $json->anonymous_function_keyword, $position, $source);
14074     $position += $function_keyword->width();
14075     $left_paren = EditableSyntax::from_json(
14076       $json->anonymous_left_paren, $position, $source);
14077     $position += $left_paren->width();
14078     $parameters = EditableSyntax::from_json(
14079       $json->anonymous_parameters, $position, $source);
14080     $position += $parameters->width();
14081     $right_paren = EditableSyntax::from_json(
14082       $json->anonymous_right_paren, $position, $source);
14083     $position += $right_paren->width();
14084     $colon = EditableSyntax::from_json(
14085       $json->anonymous_colon, $position, $source);
14086     $position += $colon->width();
14087     $type = EditableSyntax::from_json(
14088       $json->anonymous_type, $position, $source);
14089     $position += $type->width();
14090     $use = EditableSyntax::from_json(
14091       $json->anonymous_use, $position, $source);
14092     $position += $use->width();
14093     $body = EditableSyntax::from_json(
14094       $json->anonymous_body, $position, $source);
14095     $position += $body->width();
14096     return new AnonymousFunction(
14097         $static_keyword,
14098         $async_keyword,
14099         $coroutine_keyword,
14100         $function_keyword,
14101         $left_paren,
14102         $parameters,
14103         $right_paren,
14104         $colon,
14105         $type,
14106         $use,
14107         $body);
14108   }
14109   public function children(): Generator<string, EditableSyntax, void> {
14110     yield $this->_static_keyword;
14111     yield $this->_async_keyword;
14112     yield $this->_coroutine_keyword;
14113     yield $this->_function_keyword;
14114     yield $this->_left_paren;
14115     yield $this->_parameters;
14116     yield $this->_right_paren;
14117     yield $this->_colon;
14118     yield $this->_type;
14119     yield $this->_use;
14120     yield $this->_body;
14121     yield break;
14122   }
14123 }
14124 final class Php7AnonymousFunction extends EditableSyntax {
14125   private EditableSyntax $_static_keyword;
14126   private EditableSyntax $_async_keyword;
14127   private EditableSyntax $_coroutine_keyword;
14128   private EditableSyntax $_function_keyword;
14129   private EditableSyntax $_left_paren;
14130   private EditableSyntax $_parameters;
14131   private EditableSyntax $_right_paren;
14132   private EditableSyntax $_use;
14133   private EditableSyntax $_colon;
14134   private EditableSyntax $_type;
14135   private EditableSyntax $_body;
14136   public function __construct(
14137     EditableSyntax $static_keyword,
14138     EditableSyntax $async_keyword,
14139     EditableSyntax $coroutine_keyword,
14140     EditableSyntax $function_keyword,
14141     EditableSyntax $left_paren,
14142     EditableSyntax $parameters,
14143     EditableSyntax $right_paren,
14144     EditableSyntax $use,
14145     EditableSyntax $colon,
14146     EditableSyntax $type,
14147     EditableSyntax $body) {
14148     parent::__construct('php7_anonymous_function');
14149     $this->_static_keyword = $static_keyword;
14150     $this->_async_keyword = $async_keyword;
14151     $this->_coroutine_keyword = $coroutine_keyword;
14152     $this->_function_keyword = $function_keyword;
14153     $this->_left_paren = $left_paren;
14154     $this->_parameters = $parameters;
14155     $this->_right_paren = $right_paren;
14156     $this->_use = $use;
14157     $this->_colon = $colon;
14158     $this->_type = $type;
14159     $this->_body = $body;
14160   }
14161   public function static_keyword(): EditableSyntax {
14162     return $this->_static_keyword;
14163   }
14164   public function async_keyword(): EditableSyntax {
14165     return $this->_async_keyword;
14166   }
14167   public function coroutine_keyword(): EditableSyntax {
14168     return $this->_coroutine_keyword;
14169   }
14170   public function function_keyword(): EditableSyntax {
14171     return $this->_function_keyword;
14172   }
14173   public function left_paren(): EditableSyntax {
14174     return $this->_left_paren;
14175   }
14176   public function parameters(): EditableSyntax {
14177     return $this->_parameters;
14178   }
14179   public function right_paren(): EditableSyntax {
14180     return $this->_right_paren;
14181   }
14182   public function use(): EditableSyntax {
14183     return $this->_use;
14184   }
14185   public function colon(): EditableSyntax {
14186     return $this->_colon;
14187   }
14188   public function type(): EditableSyntax {
14189     return $this->_type;
14190   }
14191   public function body(): EditableSyntax {
14192     return $this->_body;
14193   }
14194   public function with_static_keyword(EditableSyntax $static_keyword): Php7AnonymousFunction {
14195     return new Php7AnonymousFunction(
14196       $static_keyword,
14197       $this->_async_keyword,
14198       $this->_coroutine_keyword,
14199       $this->_function_keyword,
14200       $this->_left_paren,
14201       $this->_parameters,
14202       $this->_right_paren,
14203       $this->_use,
14204       $this->_colon,
14205       $this->_type,
14206       $this->_body);
14207   }
14208   public function with_async_keyword(EditableSyntax $async_keyword): Php7AnonymousFunction {
14209     return new Php7AnonymousFunction(
14210       $this->_static_keyword,
14211       $async_keyword,
14212       $this->_coroutine_keyword,
14213       $this->_function_keyword,
14214       $this->_left_paren,
14215       $this->_parameters,
14216       $this->_right_paren,
14217       $this->_use,
14218       $this->_colon,
14219       $this->_type,
14220       $this->_body);
14221   }
14222   public function with_coroutine_keyword(EditableSyntax $coroutine_keyword): Php7AnonymousFunction {
14223     return new Php7AnonymousFunction(
14224       $this->_static_keyword,
14225       $this->_async_keyword,
14226       $coroutine_keyword,
14227       $this->_function_keyword,
14228       $this->_left_paren,
14229       $this->_parameters,
14230       $this->_right_paren,
14231       $this->_use,
14232       $this->_colon,
14233       $this->_type,
14234       $this->_body);
14235   }
14236   public function with_function_keyword(EditableSyntax $function_keyword): Php7AnonymousFunction {
14237     return new Php7AnonymousFunction(
14238       $this->_static_keyword,
14239       $this->_async_keyword,
14240       $this->_coroutine_keyword,
14241       $function_keyword,
14242       $this->_left_paren,
14243       $this->_parameters,
14244       $this->_right_paren,
14245       $this->_use,
14246       $this->_colon,
14247       $this->_type,
14248       $this->_body);
14249   }
14250   public function with_left_paren(EditableSyntax $left_paren): Php7AnonymousFunction {
14251     return new Php7AnonymousFunction(
14252       $this->_static_keyword,
14253       $this->_async_keyword,
14254       $this->_coroutine_keyword,
14255       $this->_function_keyword,
14256       $left_paren,
14257       $this->_parameters,
14258       $this->_right_paren,
14259       $this->_use,
14260       $this->_colon,
14261       $this->_type,
14262       $this->_body);
14263   }
14264   public function with_parameters(EditableSyntax $parameters): Php7AnonymousFunction {
14265     return new Php7AnonymousFunction(
14266       $this->_static_keyword,
14267       $this->_async_keyword,
14268       $this->_coroutine_keyword,
14269       $this->_function_keyword,
14270       $this->_left_paren,
14271       $parameters,
14272       $this->_right_paren,
14273       $this->_use,
14274       $this->_colon,
14275       $this->_type,
14276       $this->_body);
14277   }
14278   public function with_right_paren(EditableSyntax $right_paren): Php7AnonymousFunction {
14279     return new Php7AnonymousFunction(
14280       $this->_static_keyword,
14281       $this->_async_keyword,
14282       $this->_coroutine_keyword,
14283       $this->_function_keyword,
14284       $this->_left_paren,
14285       $this->_parameters,
14286       $right_paren,
14287       $this->_use,
14288       $this->_colon,
14289       $this->_type,
14290       $this->_body);
14291   }
14292   public function with_use(EditableSyntax $use): Php7AnonymousFunction {
14293     return new Php7AnonymousFunction(
14294       $this->_static_keyword,
14295       $this->_async_keyword,
14296       $this->_coroutine_keyword,
14297       $this->_function_keyword,
14298       $this->_left_paren,
14299       $this->_parameters,
14300       $this->_right_paren,
14301       $use,
14302       $this->_colon,
14303       $this->_type,
14304       $this->_body);
14305   }
14306   public function with_colon(EditableSyntax $colon): Php7AnonymousFunction {
14307     return new Php7AnonymousFunction(
14308       $this->_static_keyword,
14309       $this->_async_keyword,
14310       $this->_coroutine_keyword,
14311       $this->_function_keyword,
14312       $this->_left_paren,
14313       $this->_parameters,
14314       $this->_right_paren,
14315       $this->_use,
14316       $colon,
14317       $this->_type,
14318       $this->_body);
14319   }
14320   public function with_type(EditableSyntax $type): Php7AnonymousFunction {
14321     return new Php7AnonymousFunction(
14322       $this->_static_keyword,
14323       $this->_async_keyword,
14324       $this->_coroutine_keyword,
14325       $this->_function_keyword,
14326       $this->_left_paren,
14327       $this->_parameters,
14328       $this->_right_paren,
14329       $this->_use,
14330       $this->_colon,
14331       $type,
14332       $this->_body);
14333   }
14334   public function with_body(EditableSyntax $body): Php7AnonymousFunction {
14335     return new Php7AnonymousFunction(
14336       $this->_static_keyword,
14337       $this->_async_keyword,
14338       $this->_coroutine_keyword,
14339       $this->_function_keyword,
14340       $this->_left_paren,
14341       $this->_parameters,
14342       $this->_right_paren,
14343       $this->_use,
14344       $this->_colon,
14345       $this->_type,
14346       $body);
14347   }
14348
14349   public function rewrite(
14350     ( function
14351       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
14352     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
14353     $new_parents = $parents ?? [];
14354     array_push($new_parents, $this);
14355     $static_keyword = $this->static_keyword()->rewrite($rewriter, $new_parents);
14356     $async_keyword = $this->async_keyword()->rewrite($rewriter, $new_parents);
14357     $coroutine_keyword = $this->coroutine_keyword()->rewrite($rewriter, $new_parents);
14358     $function_keyword = $this->function_keyword()->rewrite($rewriter, $new_parents);
14359     $left_paren = $this->left_paren()->rewrite($rewriter, $new_parents);
14360     $parameters = $this->parameters()->rewrite($rewriter, $new_parents);
14361     $right_paren = $this->right_paren()->rewrite($rewriter, $new_parents);
14362     $use = $this->use()->rewrite($rewriter, $new_parents);
14363     $colon = $this->colon()->rewrite($rewriter, $new_parents);
14364     $type = $this->type()->rewrite($rewriter, $new_parents);
14365     $body = $this->body()->rewrite($rewriter, $new_parents);
14366     if (
14367       $static_keyword === $this->static_keyword() &&
14368       $async_keyword === $this->async_keyword() &&
14369       $coroutine_keyword === $this->coroutine_keyword() &&
14370       $function_keyword === $this->function_keyword() &&
14371       $left_paren === $this->left_paren() &&
14372       $parameters === $this->parameters() &&
14373       $right_paren === $this->right_paren() &&
14374       $use === $this->use() &&
14375       $colon === $this->colon() &&
14376       $type === $this->type() &&
14377       $body === $this->body()) {
14378       return $rewriter($this, $parents ?? []);
14379     } else {
14380       return $rewriter(new Php7AnonymousFunction(
14381         $static_keyword,
14382         $async_keyword,
14383         $coroutine_keyword,
14384         $function_keyword,
14385         $left_paren,
14386         $parameters,
14387         $right_paren,
14388         $use,
14389         $colon,
14390         $type,
14391         $body), $parents ?? []);
14392     }
14393   }
14394
14395   public static function from_json(mixed $json, int $position, string $source) {
14396     $static_keyword = EditableSyntax::from_json(
14397       $json->php7_anonymous_static_keyword, $position, $source);
14398     $position += $static_keyword->width();
14399     $async_keyword = EditableSyntax::from_json(
14400       $json->php7_anonymous_async_keyword, $position, $source);
14401     $position += $async_keyword->width();
14402     $coroutine_keyword = EditableSyntax::from_json(
14403       $json->php7_anonymous_coroutine_keyword, $position, $source);
14404     $position += $coroutine_keyword->width();
14405     $function_keyword = EditableSyntax::from_json(
14406       $json->php7_anonymous_function_keyword, $position, $source);
14407     $position += $function_keyword->width();
14408     $left_paren = EditableSyntax::from_json(
14409       $json->php7_anonymous_left_paren, $position, $source);
14410     $position += $left_paren->width();
14411     $parameters = EditableSyntax::from_json(
14412       $json->php7_anonymous_parameters, $position, $source);
14413     $position += $parameters->width();
14414     $right_paren = EditableSyntax::from_json(
14415       $json->php7_anonymous_right_paren, $position, $source);
14416     $position += $right_paren->width();
14417     $use = EditableSyntax::from_json(
14418       $json->php7_anonymous_use, $position, $source);
14419     $position += $use->width();
14420     $colon = EditableSyntax::from_json(
14421       $json->php7_anonymous_colon, $position, $source);
14422     $position += $colon->width();
14423     $type = EditableSyntax::from_json(
14424       $json->php7_anonymous_type, $position, $source);
14425     $position += $type->width();
14426     $body = EditableSyntax::from_json(
14427       $json->php7_anonymous_body, $position, $source);
14428     $position += $body->width();
14429     return new Php7AnonymousFunction(
14430         $static_keyword,
14431         $async_keyword,
14432         $coroutine_keyword,
14433         $function_keyword,
14434         $left_paren,
14435         $parameters,
14436         $right_paren,
14437         $use,
14438         $colon,
14439         $type,
14440         $body);
14441   }
14442   public function children(): Generator<string, EditableSyntax, void> {
14443     yield $this->_static_keyword;
14444     yield $this->_async_keyword;
14445     yield $this->_coroutine_keyword;
14446     yield $this->_function_keyword;
14447     yield $this->_left_paren;
14448     yield $this->_parameters;
14449     yield $this->_right_paren;
14450     yield $this->_use;
14451     yield $this->_colon;
14452     yield $this->_type;
14453     yield $this->_body;
14454     yield break;
14455   }
14456 }
14457 final class AnonymousFunctionUseClause extends EditableSyntax {
14458   private EditableSyntax $_keyword;
14459   private EditableSyntax $_left_paren;
14460   private EditableSyntax $_variables;
14461   private EditableSyntax $_right_paren;
14462   public function __construct(
14463     EditableSyntax $keyword,
14464     EditableSyntax $left_paren,
14465     EditableSyntax $variables,
14466     EditableSyntax $right_paren) {
14467     parent::__construct('anonymous_function_use_clause');
14468     $this->_keyword = $keyword;
14469     $this->_left_paren = $left_paren;
14470     $this->_variables = $variables;
14471     $this->_right_paren = $right_paren;
14472   }
14473   public function keyword(): EditableSyntax {
14474     return $this->_keyword;
14475   }
14476   public function left_paren(): EditableSyntax {
14477     return $this->_left_paren;
14478   }
14479   public function variables(): EditableSyntax {
14480     return $this->_variables;
14481   }
14482   public function right_paren(): EditableSyntax {
14483     return $this->_right_paren;
14484   }
14485   public function with_keyword(EditableSyntax $keyword): AnonymousFunctionUseClause {
14486     return new AnonymousFunctionUseClause(
14487       $keyword,
14488       $this->_left_paren,
14489       $this->_variables,
14490       $this->_right_paren);
14491   }
14492   public function with_left_paren(EditableSyntax $left_paren): AnonymousFunctionUseClause {
14493     return new AnonymousFunctionUseClause(
14494       $this->_keyword,
14495       $left_paren,
14496       $this->_variables,
14497       $this->_right_paren);
14498   }
14499   public function with_variables(EditableSyntax $variables): AnonymousFunctionUseClause {
14500     return new AnonymousFunctionUseClause(
14501       $this->_keyword,
14502       $this->_left_paren,
14503       $variables,
14504       $this->_right_paren);
14505   }
14506   public function with_right_paren(EditableSyntax $right_paren): AnonymousFunctionUseClause {
14507     return new AnonymousFunctionUseClause(
14508       $this->_keyword,
14509       $this->_left_paren,
14510       $this->_variables,
14511       $right_paren);
14512   }
14513
14514   public function rewrite(
14515     ( function
14516       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
14517     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
14518     $new_parents = $parents ?? [];
14519     array_push($new_parents, $this);
14520     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
14521     $left_paren = $this->left_paren()->rewrite($rewriter, $new_parents);
14522     $variables = $this->variables()->rewrite($rewriter, $new_parents);
14523     $right_paren = $this->right_paren()->rewrite($rewriter, $new_parents);
14524     if (
14525       $keyword === $this->keyword() &&
14526       $left_paren === $this->left_paren() &&
14527       $variables === $this->variables() &&
14528       $right_paren === $this->right_paren()) {
14529       return $rewriter($this, $parents ?? []);
14530     } else {
14531       return $rewriter(new AnonymousFunctionUseClause(
14532         $keyword,
14533         $left_paren,
14534         $variables,
14535         $right_paren), $parents ?? []);
14536     }
14537   }
14538
14539   public static function from_json(mixed $json, int $position, string $source) {
14540     $keyword = EditableSyntax::from_json(
14541       $json->anonymous_use_keyword, $position, $source);
14542     $position += $keyword->width();
14543     $left_paren = EditableSyntax::from_json(
14544       $json->anonymous_use_left_paren, $position, $source);
14545     $position += $left_paren->width();
14546     $variables = EditableSyntax::from_json(
14547       $json->anonymous_use_variables, $position, $source);
14548     $position += $variables->width();
14549     $right_paren = EditableSyntax::from_json(
14550       $json->anonymous_use_right_paren, $position, $source);
14551     $position += $right_paren->width();
14552     return new AnonymousFunctionUseClause(
14553         $keyword,
14554         $left_paren,
14555         $variables,
14556         $right_paren);
14557   }
14558   public function children(): Generator<string, EditableSyntax, void> {
14559     yield $this->_keyword;
14560     yield $this->_left_paren;
14561     yield $this->_variables;
14562     yield $this->_right_paren;
14563     yield break;
14564   }
14565 }
14566 final class LambdaExpression extends EditableSyntax {
14567   private EditableSyntax $_async;
14568   private EditableSyntax $_coroutine;
14569   private EditableSyntax $_signature;
14570   private EditableSyntax $_arrow;
14571   private EditableSyntax $_body;
14572   public function __construct(
14573     EditableSyntax $async,
14574     EditableSyntax $coroutine,
14575     EditableSyntax $signature,
14576     EditableSyntax $arrow,
14577     EditableSyntax $body) {
14578     parent::__construct('lambda_expression');
14579     $this->_async = $async;
14580     $this->_coroutine = $coroutine;
14581     $this->_signature = $signature;
14582     $this->_arrow = $arrow;
14583     $this->_body = $body;
14584   }
14585   public function async(): EditableSyntax {
14586     return $this->_async;
14587   }
14588   public function coroutine(): EditableSyntax {
14589     return $this->_coroutine;
14590   }
14591   public function signature(): EditableSyntax {
14592     return $this->_signature;
14593   }
14594   public function arrow(): EditableSyntax {
14595     return $this->_arrow;
14596   }
14597   public function body(): EditableSyntax {
14598     return $this->_body;
14599   }
14600   public function with_async(EditableSyntax $async): LambdaExpression {
14601     return new LambdaExpression(
14602       $async,
14603       $this->_coroutine,
14604       $this->_signature,
14605       $this->_arrow,
14606       $this->_body);
14607   }
14608   public function with_coroutine(EditableSyntax $coroutine): LambdaExpression {
14609     return new LambdaExpression(
14610       $this->_async,
14611       $coroutine,
14612       $this->_signature,
14613       $this->_arrow,
14614       $this->_body);
14615   }
14616   public function with_signature(EditableSyntax $signature): LambdaExpression {
14617     return new LambdaExpression(
14618       $this->_async,
14619       $this->_coroutine,
14620       $signature,
14621       $this->_arrow,
14622       $this->_body);
14623   }
14624   public function with_arrow(EditableSyntax $arrow): LambdaExpression {
14625     return new LambdaExpression(
14626       $this->_async,
14627       $this->_coroutine,
14628       $this->_signature,
14629       $arrow,
14630       $this->_body);
14631   }
14632   public function with_body(EditableSyntax $body): LambdaExpression {
14633     return new LambdaExpression(
14634       $this->_async,
14635       $this->_coroutine,
14636       $this->_signature,
14637       $this->_arrow,
14638       $body);
14639   }
14640
14641   public function rewrite(
14642     ( function
14643       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
14644     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
14645     $new_parents = $parents ?? [];
14646     array_push($new_parents, $this);
14647     $async = $this->async()->rewrite($rewriter, $new_parents);
14648     $coroutine = $this->coroutine()->rewrite($rewriter, $new_parents);
14649     $signature = $this->signature()->rewrite($rewriter, $new_parents);
14650     $arrow = $this->arrow()->rewrite($rewriter, $new_parents);
14651     $body = $this->body()->rewrite($rewriter, $new_parents);
14652     if (
14653       $async === $this->async() &&
14654       $coroutine === $this->coroutine() &&
14655       $signature === $this->signature() &&
14656       $arrow === $this->arrow() &&
14657       $body === $this->body()) {
14658       return $rewriter($this, $parents ?? []);
14659     } else {
14660       return $rewriter(new LambdaExpression(
14661         $async,
14662         $coroutine,
14663         $signature,
14664         $arrow,
14665         $body), $parents ?? []);
14666     }
14667   }
14668
14669   public static function from_json(mixed $json, int $position, string $source) {
14670     $async = EditableSyntax::from_json(
14671       $json->lambda_async, $position, $source);
14672     $position += $async->width();
14673     $coroutine = EditableSyntax::from_json(
14674       $json->lambda_coroutine, $position, $source);
14675     $position += $coroutine->width();
14676     $signature = EditableSyntax::from_json(
14677       $json->lambda_signature, $position, $source);
14678     $position += $signature->width();
14679     $arrow = EditableSyntax::from_json(
14680       $json->lambda_arrow, $position, $source);
14681     $position += $arrow->width();
14682     $body = EditableSyntax::from_json(
14683       $json->lambda_body, $position, $source);
14684     $position += $body->width();
14685     return new LambdaExpression(
14686         $async,
14687         $coroutine,
14688         $signature,
14689         $arrow,
14690         $body);
14691   }
14692   public function children(): Generator<string, EditableSyntax, void> {
14693     yield $this->_async;
14694     yield $this->_coroutine;
14695     yield $this->_signature;
14696     yield $this->_arrow;
14697     yield $this->_body;
14698     yield break;
14699   }
14700 }
14701 final class LambdaSignature extends EditableSyntax {
14702   private EditableSyntax $_left_paren;
14703   private EditableSyntax $_parameters;
14704   private EditableSyntax $_right_paren;
14705   private EditableSyntax $_colon;
14706   private EditableSyntax $_type;
14707   public function __construct(
14708     EditableSyntax $left_paren,
14709     EditableSyntax $parameters,
14710     EditableSyntax $right_paren,
14711     EditableSyntax $colon,
14712     EditableSyntax $type) {
14713     parent::__construct('lambda_signature');
14714     $this->_left_paren = $left_paren;
14715     $this->_parameters = $parameters;
14716     $this->_right_paren = $right_paren;
14717     $this->_colon = $colon;
14718     $this->_type = $type;
14719   }
14720   public function left_paren(): EditableSyntax {
14721     return $this->_left_paren;
14722   }
14723   public function parameters(): EditableSyntax {
14724     return $this->_parameters;
14725   }
14726   public function right_paren(): EditableSyntax {
14727     return $this->_right_paren;
14728   }
14729   public function colon(): EditableSyntax {
14730     return $this->_colon;
14731   }
14732   public function type(): EditableSyntax {
14733     return $this->_type;
14734   }
14735   public function with_left_paren(EditableSyntax $left_paren): LambdaSignature {
14736     return new LambdaSignature(
14737       $left_paren,
14738       $this->_parameters,
14739       $this->_right_paren,
14740       $this->_colon,
14741       $this->_type);
14742   }
14743   public function with_parameters(EditableSyntax $parameters): LambdaSignature {
14744     return new LambdaSignature(
14745       $this->_left_paren,
14746       $parameters,
14747       $this->_right_paren,
14748       $this->_colon,
14749       $this->_type);
14750   }
14751   public function with_right_paren(EditableSyntax $right_paren): LambdaSignature {
14752     return new LambdaSignature(
14753       $this->_left_paren,
14754       $this->_parameters,
14755       $right_paren,
14756       $this->_colon,
14757       $this->_type);
14758   }
14759   public function with_colon(EditableSyntax $colon): LambdaSignature {
14760     return new LambdaSignature(
14761       $this->_left_paren,
14762       $this->_parameters,
14763       $this->_right_paren,
14764       $colon,
14765       $this->_type);
14766   }
14767   public function with_type(EditableSyntax $type): LambdaSignature {
14768     return new LambdaSignature(
14769       $this->_left_paren,
14770       $this->_parameters,
14771       $this->_right_paren,
14772       $this->_colon,
14773       $type);
14774   }
14775
14776   public function rewrite(
14777     ( function
14778       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
14779     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
14780     $new_parents = $parents ?? [];
14781     array_push($new_parents, $this);
14782     $left_paren = $this->left_paren()->rewrite($rewriter, $new_parents);
14783     $parameters = $this->parameters()->rewrite($rewriter, $new_parents);
14784     $right_paren = $this->right_paren()->rewrite($rewriter, $new_parents);
14785     $colon = $this->colon()->rewrite($rewriter, $new_parents);
14786     $type = $this->type()->rewrite($rewriter, $new_parents);
14787     if (
14788       $left_paren === $this->left_paren() &&
14789       $parameters === $this->parameters() &&
14790       $right_paren === $this->right_paren() &&
14791       $colon === $this->colon() &&
14792       $type === $this->type()) {
14793       return $rewriter($this, $parents ?? []);
14794     } else {
14795       return $rewriter(new LambdaSignature(
14796         $left_paren,
14797         $parameters,
14798         $right_paren,
14799         $colon,
14800         $type), $parents ?? []);
14801     }
14802   }
14803
14804   public static function from_json(mixed $json, int $position, string $source) {
14805     $left_paren = EditableSyntax::from_json(
14806       $json->lambda_left_paren, $position, $source);
14807     $position += $left_paren->width();
14808     $parameters = EditableSyntax::from_json(
14809       $json->lambda_parameters, $position, $source);
14810     $position += $parameters->width();
14811     $right_paren = EditableSyntax::from_json(
14812       $json->lambda_right_paren, $position, $source);
14813     $position += $right_paren->width();
14814     $colon = EditableSyntax::from_json(
14815       $json->lambda_colon, $position, $source);
14816     $position += $colon->width();
14817     $type = EditableSyntax::from_json(
14818       $json->lambda_type, $position, $source);
14819     $position += $type->width();
14820     return new LambdaSignature(
14821         $left_paren,
14822         $parameters,
14823         $right_paren,
14824         $colon,
14825         $type);
14826   }
14827   public function children(): Generator<string, EditableSyntax, void> {
14828     yield $this->_left_paren;
14829     yield $this->_parameters;
14830     yield $this->_right_paren;
14831     yield $this->_colon;
14832     yield $this->_type;
14833     yield break;
14834   }
14835 }
14836 final class CastExpression extends EditableSyntax {
14837   private EditableSyntax $_left_paren;
14838   private EditableSyntax $_type;
14839   private EditableSyntax $_right_paren;
14840   private EditableSyntax $_operand;
14841   public function __construct(
14842     EditableSyntax $left_paren,
14843     EditableSyntax $type,
14844     EditableSyntax $right_paren,
14845     EditableSyntax $operand) {
14846     parent::__construct('cast_expression');
14847     $this->_left_paren = $left_paren;
14848     $this->_type = $type;
14849     $this->_right_paren = $right_paren;
14850     $this->_operand = $operand;
14851   }
14852   public function left_paren(): EditableSyntax {
14853     return $this->_left_paren;
14854   }
14855   public function type(): EditableSyntax {
14856     return $this->_type;
14857   }
14858   public function right_paren(): EditableSyntax {
14859     return $this->_right_paren;
14860   }
14861   public function operand(): EditableSyntax {
14862     return $this->_operand;
14863   }
14864   public function with_left_paren(EditableSyntax $left_paren): CastExpression {
14865     return new CastExpression(
14866       $left_paren,
14867       $this->_type,
14868       $this->_right_paren,
14869       $this->_operand);
14870   }
14871   public function with_type(EditableSyntax $type): CastExpression {
14872     return new CastExpression(
14873       $this->_left_paren,
14874       $type,
14875       $this->_right_paren,
14876       $this->_operand);
14877   }
14878   public function with_right_paren(EditableSyntax $right_paren): CastExpression {
14879     return new CastExpression(
14880       $this->_left_paren,
14881       $this->_type,
14882       $right_paren,
14883       $this->_operand);
14884   }
14885   public function with_operand(EditableSyntax $operand): CastExpression {
14886     return new CastExpression(
14887       $this->_left_paren,
14888       $this->_type,
14889       $this->_right_paren,
14890       $operand);
14891   }
14892
14893   public function rewrite(
14894     ( function
14895       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
14896     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
14897     $new_parents = $parents ?? [];
14898     array_push($new_parents, $this);
14899     $left_paren = $this->left_paren()->rewrite($rewriter, $new_parents);
14900     $type = $this->type()->rewrite($rewriter, $new_parents);
14901     $right_paren = $this->right_paren()->rewrite($rewriter, $new_parents);
14902     $operand = $this->operand()->rewrite($rewriter, $new_parents);
14903     if (
14904       $left_paren === $this->left_paren() &&
14905       $type === $this->type() &&
14906       $right_paren === $this->right_paren() &&
14907       $operand === $this->operand()) {
14908       return $rewriter($this, $parents ?? []);
14909     } else {
14910       return $rewriter(new CastExpression(
14911         $left_paren,
14912         $type,
14913         $right_paren,
14914         $operand), $parents ?? []);
14915     }
14916   }
14917
14918   public static function from_json(mixed $json, int $position, string $source) {
14919     $left_paren = EditableSyntax::from_json(
14920       $json->cast_left_paren, $position, $source);
14921     $position += $left_paren->width();
14922     $type = EditableSyntax::from_json(
14923       $json->cast_type, $position, $source);
14924     $position += $type->width();
14925     $right_paren = EditableSyntax::from_json(
14926       $json->cast_right_paren, $position, $source);
14927     $position += $right_paren->width();
14928     $operand = EditableSyntax::from_json(
14929       $json->cast_operand, $position, $source);
14930     $position += $operand->width();
14931     return new CastExpression(
14932         $left_paren,
14933         $type,
14934         $right_paren,
14935         $operand);
14936   }
14937   public function children(): Generator<string, EditableSyntax, void> {
14938     yield $this->_left_paren;
14939     yield $this->_type;
14940     yield $this->_right_paren;
14941     yield $this->_operand;
14942     yield break;
14943   }
14944 }
14945 final class ScopeResolutionExpression extends EditableSyntax {
14946   private EditableSyntax $_qualifier;
14947   private EditableSyntax $_operator;
14948   private EditableSyntax $_name;
14949   public function __construct(
14950     EditableSyntax $qualifier,
14951     EditableSyntax $operator,
14952     EditableSyntax $name) {
14953     parent::__construct('scope_resolution_expression');
14954     $this->_qualifier = $qualifier;
14955     $this->_operator = $operator;
14956     $this->_name = $name;
14957   }
14958   public function qualifier(): EditableSyntax {
14959     return $this->_qualifier;
14960   }
14961   public function operator(): EditableSyntax {
14962     return $this->_operator;
14963   }
14964   public function name(): EditableSyntax {
14965     return $this->_name;
14966   }
14967   public function with_qualifier(EditableSyntax $qualifier): ScopeResolutionExpression {
14968     return new ScopeResolutionExpression(
14969       $qualifier,
14970       $this->_operator,
14971       $this->_name);
14972   }
14973   public function with_operator(EditableSyntax $operator): ScopeResolutionExpression {
14974     return new ScopeResolutionExpression(
14975       $this->_qualifier,
14976       $operator,
14977       $this->_name);
14978   }
14979   public function with_name(EditableSyntax $name): ScopeResolutionExpression {
14980     return new ScopeResolutionExpression(
14981       $this->_qualifier,
14982       $this->_operator,
14983       $name);
14984   }
14985
14986   public function rewrite(
14987     ( function
14988       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
14989     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
14990     $new_parents = $parents ?? [];
14991     array_push($new_parents, $this);
14992     $qualifier = $this->qualifier()->rewrite($rewriter, $new_parents);
14993     $operator = $this->operator()->rewrite($rewriter, $new_parents);
14994     $name = $this->name()->rewrite($rewriter, $new_parents);
14995     if (
14996       $qualifier === $this->qualifier() &&
14997       $operator === $this->operator() &&
14998       $name === $this->name()) {
14999       return $rewriter($this, $parents ?? []);
15000     } else {
15001       return $rewriter(new ScopeResolutionExpression(
15002         $qualifier,
15003         $operator,
15004         $name), $parents ?? []);
15005     }
15006   }
15007
15008   public static function from_json(mixed $json, int $position, string $source) {
15009     $qualifier = EditableSyntax::from_json(
15010       $json->scope_resolution_qualifier, $position, $source);
15011     $position += $qualifier->width();
15012     $operator = EditableSyntax::from_json(
15013       $json->scope_resolution_operator, $position, $source);
15014     $position += $operator->width();
15015     $name = EditableSyntax::from_json(
15016       $json->scope_resolution_name, $position, $source);
15017     $position += $name->width();
15018     return new ScopeResolutionExpression(
15019         $qualifier,
15020         $operator,
15021         $name);
15022   }
15023   public function children(): Generator<string, EditableSyntax, void> {
15024     yield $this->_qualifier;
15025     yield $this->_operator;
15026     yield $this->_name;
15027     yield break;
15028   }
15029 }
15030 final class MemberSelectionExpression extends EditableSyntax {
15031   private EditableSyntax $_object;
15032   private EditableSyntax $_operator;
15033   private EditableSyntax $_name;
15034   public function __construct(
15035     EditableSyntax $object,
15036     EditableSyntax $operator,
15037     EditableSyntax $name) {
15038     parent::__construct('member_selection_expression');
15039     $this->_object = $object;
15040     $this->_operator = $operator;
15041     $this->_name = $name;
15042   }
15043   public function object(): EditableSyntax {
15044     return $this->_object;
15045   }
15046   public function operator(): EditableSyntax {
15047     return $this->_operator;
15048   }
15049   public function name(): EditableSyntax {
15050     return $this->_name;
15051   }
15052   public function with_object(EditableSyntax $object): MemberSelectionExpression {
15053     return new MemberSelectionExpression(
15054       $object,
15055       $this->_operator,
15056       $this->_name);
15057   }
15058   public function with_operator(EditableSyntax $operator): MemberSelectionExpression {
15059     return new MemberSelectionExpression(
15060       $this->_object,
15061       $operator,
15062       $this->_name);
15063   }
15064   public function with_name(EditableSyntax $name): MemberSelectionExpression {
15065     return new MemberSelectionExpression(
15066       $this->_object,
15067       $this->_operator,
15068       $name);
15069   }
15070
15071   public function rewrite(
15072     ( function
15073       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
15074     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
15075     $new_parents = $parents ?? [];
15076     array_push($new_parents, $this);
15077     $object = $this->object()->rewrite($rewriter, $new_parents);
15078     $operator = $this->operator()->rewrite($rewriter, $new_parents);
15079     $name = $this->name()->rewrite($rewriter, $new_parents);
15080     if (
15081       $object === $this->object() &&
15082       $operator === $this->operator() &&
15083       $name === $this->name()) {
15084       return $rewriter($this, $parents ?? []);
15085     } else {
15086       return $rewriter(new MemberSelectionExpression(
15087         $object,
15088         $operator,
15089         $name), $parents ?? []);
15090     }
15091   }
15092
15093   public static function from_json(mixed $json, int $position, string $source) {
15094     $object = EditableSyntax::from_json(
15095       $json->member_object, $position, $source);
15096     $position += $object->width();
15097     $operator = EditableSyntax::from_json(
15098       $json->member_operator, $position, $source);
15099     $position += $operator->width();
15100     $name = EditableSyntax::from_json(
15101       $json->member_name, $position, $source);
15102     $position += $name->width();
15103     return new MemberSelectionExpression(
15104         $object,
15105         $operator,
15106         $name);
15107   }
15108   public function children(): Generator<string, EditableSyntax, void> {
15109     yield $this->_object;
15110     yield $this->_operator;
15111     yield $this->_name;
15112     yield break;
15113   }
15114 }
15115 final class SafeMemberSelectionExpression extends EditableSyntax {
15116   private EditableSyntax $_object;
15117   private EditableSyntax $_operator;
15118   private EditableSyntax $_name;
15119   public function __construct(
15120     EditableSyntax $object,
15121     EditableSyntax $operator,
15122     EditableSyntax $name) {
15123     parent::__construct('safe_member_selection_expression');
15124     $this->_object = $object;
15125     $this->_operator = $operator;
15126     $this->_name = $name;
15127   }
15128   public function object(): EditableSyntax {
15129     return $this->_object;
15130   }
15131   public function operator(): EditableSyntax {
15132     return $this->_operator;
15133   }
15134   public function name(): EditableSyntax {
15135     return $this->_name;
15136   }
15137   public function with_object(EditableSyntax $object): SafeMemberSelectionExpression {
15138     return new SafeMemberSelectionExpression(
15139       $object,
15140       $this->_operator,
15141       $this->_name);
15142   }
15143   public function with_operator(EditableSyntax $operator): SafeMemberSelectionExpression {
15144     return new SafeMemberSelectionExpression(
15145       $this->_object,
15146       $operator,
15147       $this->_name);
15148   }
15149   public function with_name(EditableSyntax $name): SafeMemberSelectionExpression {
15150     return new SafeMemberSelectionExpression(
15151       $this->_object,
15152       $this->_operator,
15153       $name);
15154   }
15155
15156   public function rewrite(
15157     ( function
15158       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
15159     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
15160     $new_parents = $parents ?? [];
15161     array_push($new_parents, $this);
15162     $object = $this->object()->rewrite($rewriter, $new_parents);
15163     $operator = $this->operator()->rewrite($rewriter, $new_parents);
15164     $name = $this->name()->rewrite($rewriter, $new_parents);
15165     if (
15166       $object === $this->object() &&
15167       $operator === $this->operator() &&
15168       $name === $this->name()) {
15169       return $rewriter($this, $parents ?? []);
15170     } else {
15171       return $rewriter(new SafeMemberSelectionExpression(
15172         $object,
15173         $operator,
15174         $name), $parents ?? []);
15175     }
15176   }
15177
15178   public static function from_json(mixed $json, int $position, string $source) {
15179     $object = EditableSyntax::from_json(
15180       $json->safe_member_object, $position, $source);
15181     $position += $object->width();
15182     $operator = EditableSyntax::from_json(
15183       $json->safe_member_operator, $position, $source);
15184     $position += $operator->width();
15185     $name = EditableSyntax::from_json(
15186       $json->safe_member_name, $position, $source);
15187     $position += $name->width();
15188     return new SafeMemberSelectionExpression(
15189         $object,
15190         $operator,
15191         $name);
15192   }
15193   public function children(): Generator<string, EditableSyntax, void> {
15194     yield $this->_object;
15195     yield $this->_operator;
15196     yield $this->_name;
15197     yield break;
15198   }
15199 }
15200 final class EmbeddedMemberSelectionExpression extends EditableSyntax {
15201   private EditableSyntax $_object;
15202   private EditableSyntax $_operator;
15203   private EditableSyntax $_name;
15204   public function __construct(
15205     EditableSyntax $object,
15206     EditableSyntax $operator,
15207     EditableSyntax $name) {
15208     parent::__construct('embedded_member_selection_expression');
15209     $this->_object = $object;
15210     $this->_operator = $operator;
15211     $this->_name = $name;
15212   }
15213   public function object(): EditableSyntax {
15214     return $this->_object;
15215   }
15216   public function operator(): EditableSyntax {
15217     return $this->_operator;
15218   }
15219   public function name(): EditableSyntax {
15220     return $this->_name;
15221   }
15222   public function with_object(EditableSyntax $object): EmbeddedMemberSelectionExpression {
15223     return new EmbeddedMemberSelectionExpression(
15224       $object,
15225       $this->_operator,
15226       $this->_name);
15227   }
15228   public function with_operator(EditableSyntax $operator): EmbeddedMemberSelectionExpression {
15229     return new EmbeddedMemberSelectionExpression(
15230       $this->_object,
15231       $operator,
15232       $this->_name);
15233   }
15234   public function with_name(EditableSyntax $name): EmbeddedMemberSelectionExpression {
15235     return new EmbeddedMemberSelectionExpression(
15236       $this->_object,
15237       $this->_operator,
15238       $name);
15239   }
15240
15241   public function rewrite(
15242     ( function
15243       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
15244     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
15245     $new_parents = $parents ?? [];
15246     array_push($new_parents, $this);
15247     $object = $this->object()->rewrite($rewriter, $new_parents);
15248     $operator = $this->operator()->rewrite($rewriter, $new_parents);
15249     $name = $this->name()->rewrite($rewriter, $new_parents);
15250     if (
15251       $object === $this->object() &&
15252       $operator === $this->operator() &&
15253       $name === $this->name()) {
15254       return $rewriter($this, $parents ?? []);
15255     } else {
15256       return $rewriter(new EmbeddedMemberSelectionExpression(
15257         $object,
15258         $operator,
15259         $name), $parents ?? []);
15260     }
15261   }
15262
15263   public static function from_json(mixed $json, int $position, string $source) {
15264     $object = EditableSyntax::from_json(
15265       $json->embedded_member_object, $position, $source);
15266     $position += $object->width();
15267     $operator = EditableSyntax::from_json(
15268       $json->embedded_member_operator, $position, $source);
15269     $position += $operator->width();
15270     $name = EditableSyntax::from_json(
15271       $json->embedded_member_name, $position, $source);
15272     $position += $name->width();
15273     return new EmbeddedMemberSelectionExpression(
15274         $object,
15275         $operator,
15276         $name);
15277   }
15278   public function children(): Generator<string, EditableSyntax, void> {
15279     yield $this->_object;
15280     yield $this->_operator;
15281     yield $this->_name;
15282     yield break;
15283   }
15284 }
15285 final class YieldExpression extends EditableSyntax {
15286   private EditableSyntax $_keyword;
15287   private EditableSyntax $_operand;
15288   public function __construct(
15289     EditableSyntax $keyword,
15290     EditableSyntax $operand) {
15291     parent::__construct('yield_expression');
15292     $this->_keyword = $keyword;
15293     $this->_operand = $operand;
15294   }
15295   public function keyword(): EditableSyntax {
15296     return $this->_keyword;
15297   }
15298   public function operand(): EditableSyntax {
15299     return $this->_operand;
15300   }
15301   public function with_keyword(EditableSyntax $keyword): YieldExpression {
15302     return new YieldExpression(
15303       $keyword,
15304       $this->_operand);
15305   }
15306   public function with_operand(EditableSyntax $operand): YieldExpression {
15307     return new YieldExpression(
15308       $this->_keyword,
15309       $operand);
15310   }
15311
15312   public function rewrite(
15313     ( function
15314       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
15315     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
15316     $new_parents = $parents ?? [];
15317     array_push($new_parents, $this);
15318     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
15319     $operand = $this->operand()->rewrite($rewriter, $new_parents);
15320     if (
15321       $keyword === $this->keyword() &&
15322       $operand === $this->operand()) {
15323       return $rewriter($this, $parents ?? []);
15324     } else {
15325       return $rewriter(new YieldExpression(
15326         $keyword,
15327         $operand), $parents ?? []);
15328     }
15329   }
15330
15331   public static function from_json(mixed $json, int $position, string $source) {
15332     $keyword = EditableSyntax::from_json(
15333       $json->yield_keyword, $position, $source);
15334     $position += $keyword->width();
15335     $operand = EditableSyntax::from_json(
15336       $json->yield_operand, $position, $source);
15337     $position += $operand->width();
15338     return new YieldExpression(
15339         $keyword,
15340         $operand);
15341   }
15342   public function children(): Generator<string, EditableSyntax, void> {
15343     yield $this->_keyword;
15344     yield $this->_operand;
15345     yield break;
15346   }
15347 }
15348 final class YieldFromExpression extends EditableSyntax {
15349   private EditableSyntax $_yield_keyword;
15350   private EditableSyntax $_from_keyword;
15351   private EditableSyntax $_operand;
15352   public function __construct(
15353     EditableSyntax $yield_keyword,
15354     EditableSyntax $from_keyword,
15355     EditableSyntax $operand) {
15356     parent::__construct('yield_from_expression');
15357     $this->_yield_keyword = $yield_keyword;
15358     $this->_from_keyword = $from_keyword;
15359     $this->_operand = $operand;
15360   }
15361   public function yield_keyword(): EditableSyntax {
15362     return $this->_yield_keyword;
15363   }
15364   public function from_keyword(): EditableSyntax {
15365     return $this->_from_keyword;
15366   }
15367   public function operand(): EditableSyntax {
15368     return $this->_operand;
15369   }
15370   public function with_yield_keyword(EditableSyntax $yield_keyword): YieldFromExpression {
15371     return new YieldFromExpression(
15372       $yield_keyword,
15373       $this->_from_keyword,
15374       $this->_operand);
15375   }
15376   public function with_from_keyword(EditableSyntax $from_keyword): YieldFromExpression {
15377     return new YieldFromExpression(
15378       $this->_yield_keyword,
15379       $from_keyword,
15380       $this->_operand);
15381   }
15382   public function with_operand(EditableSyntax $operand): YieldFromExpression {
15383     return new YieldFromExpression(
15384       $this->_yield_keyword,
15385       $this->_from_keyword,
15386       $operand);
15387   }
15388
15389   public function rewrite(
15390     ( function
15391       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
15392     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
15393     $new_parents = $parents ?? [];
15394     array_push($new_parents, $this);
15395     $yield_keyword = $this->yield_keyword()->rewrite($rewriter, $new_parents);
15396     $from_keyword = $this->from_keyword()->rewrite($rewriter, $new_parents);
15397     $operand = $this->operand()->rewrite($rewriter, $new_parents);
15398     if (
15399       $yield_keyword === $this->yield_keyword() &&
15400       $from_keyword === $this->from_keyword() &&
15401       $operand === $this->operand()) {
15402       return $rewriter($this, $parents ?? []);
15403     } else {
15404       return $rewriter(new YieldFromExpression(
15405         $yield_keyword,
15406         $from_keyword,
15407         $operand), $parents ?? []);
15408     }
15409   }
15410
15411   public static function from_json(mixed $json, int $position, string $source) {
15412     $yield_keyword = EditableSyntax::from_json(
15413       $json->yield_from_yield_keyword, $position, $source);
15414     $position += $yield_keyword->width();
15415     $from_keyword = EditableSyntax::from_json(
15416       $json->yield_from_from_keyword, $position, $source);
15417     $position += $from_keyword->width();
15418     $operand = EditableSyntax::from_json(
15419       $json->yield_from_operand, $position, $source);
15420     $position += $operand->width();
15421     return new YieldFromExpression(
15422         $yield_keyword,
15423         $from_keyword,
15424         $operand);
15425   }
15426   public function children(): Generator<string, EditableSyntax, void> {
15427     yield $this->_yield_keyword;
15428     yield $this->_from_keyword;
15429     yield $this->_operand;
15430     yield break;
15431   }
15432 }
15433 final class PrefixUnaryExpression extends EditableSyntax {
15434   private EditableSyntax $_operator;
15435   private EditableSyntax $_operand;
15436   public function __construct(
15437     EditableSyntax $operator,
15438     EditableSyntax $operand) {
15439     parent::__construct('prefix_unary_expression');
15440     $this->_operator = $operator;
15441     $this->_operand = $operand;
15442   }
15443   public function operator(): EditableSyntax {
15444     return $this->_operator;
15445   }
15446   public function operand(): EditableSyntax {
15447     return $this->_operand;
15448   }
15449   public function with_operator(EditableSyntax $operator): PrefixUnaryExpression {
15450     return new PrefixUnaryExpression(
15451       $operator,
15452       $this->_operand);
15453   }
15454   public function with_operand(EditableSyntax $operand): PrefixUnaryExpression {
15455     return new PrefixUnaryExpression(
15456       $this->_operator,
15457       $operand);
15458   }
15459
15460   public function rewrite(
15461     ( function
15462       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
15463     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
15464     $new_parents = $parents ?? [];
15465     array_push($new_parents, $this);
15466     $operator = $this->operator()->rewrite($rewriter, $new_parents);
15467     $operand = $this->operand()->rewrite($rewriter, $new_parents);
15468     if (
15469       $operator === $this->operator() &&
15470       $operand === $this->operand()) {
15471       return $rewriter($this, $parents ?? []);
15472     } else {
15473       return $rewriter(new PrefixUnaryExpression(
15474         $operator,
15475         $operand), $parents ?? []);
15476     }
15477   }
15478
15479   public static function from_json(mixed $json, int $position, string $source) {
15480     $operator = EditableSyntax::from_json(
15481       $json->prefix_unary_operator, $position, $source);
15482     $position += $operator->width();
15483     $operand = EditableSyntax::from_json(
15484       $json->prefix_unary_operand, $position, $source);
15485     $position += $operand->width();
15486     return new PrefixUnaryExpression(
15487         $operator,
15488         $operand);
15489   }
15490   public function children(): Generator<string, EditableSyntax, void> {
15491     yield $this->_operator;
15492     yield $this->_operand;
15493     yield break;
15494   }
15495 }
15496 final class PostfixUnaryExpression extends EditableSyntax {
15497   private EditableSyntax $_operand;
15498   private EditableSyntax $_operator;
15499   public function __construct(
15500     EditableSyntax $operand,
15501     EditableSyntax $operator) {
15502     parent::__construct('postfix_unary_expression');
15503     $this->_operand = $operand;
15504     $this->_operator = $operator;
15505   }
15506   public function operand(): EditableSyntax {
15507     return $this->_operand;
15508   }
15509   public function operator(): EditableSyntax {
15510     return $this->_operator;
15511   }
15512   public function with_operand(EditableSyntax $operand): PostfixUnaryExpression {
15513     return new PostfixUnaryExpression(
15514       $operand,
15515       $this->_operator);
15516   }
15517   public function with_operator(EditableSyntax $operator): PostfixUnaryExpression {
15518     return new PostfixUnaryExpression(
15519       $this->_operand,
15520       $operator);
15521   }
15522
15523   public function rewrite(
15524     ( function
15525       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
15526     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
15527     $new_parents = $parents ?? [];
15528     array_push($new_parents, $this);
15529     $operand = $this->operand()->rewrite($rewriter, $new_parents);
15530     $operator = $this->operator()->rewrite($rewriter, $new_parents);
15531     if (
15532       $operand === $this->operand() &&
15533       $operator === $this->operator()) {
15534       return $rewriter($this, $parents ?? []);
15535     } else {
15536       return $rewriter(new PostfixUnaryExpression(
15537         $operand,
15538         $operator), $parents ?? []);
15539     }
15540   }
15541
15542   public static function from_json(mixed $json, int $position, string $source) {
15543     $operand = EditableSyntax::from_json(
15544       $json->postfix_unary_operand, $position, $source);
15545     $position += $operand->width();
15546     $operator = EditableSyntax::from_json(
15547       $json->postfix_unary_operator, $position, $source);
15548     $position += $operator->width();
15549     return new PostfixUnaryExpression(
15550         $operand,
15551         $operator);
15552   }
15553   public function children(): Generator<string, EditableSyntax, void> {
15554     yield $this->_operand;
15555     yield $this->_operator;
15556     yield break;
15557   }
15558 }
15559 final class BinaryExpression extends EditableSyntax {
15560   private EditableSyntax $_left_operand;
15561   private EditableSyntax $_operator;
15562   private EditableSyntax $_right_operand;
15563   public function __construct(
15564     EditableSyntax $left_operand,
15565     EditableSyntax $operator,
15566     EditableSyntax $right_operand) {
15567     parent::__construct('binary_expression');
15568     $this->_left_operand = $left_operand;
15569     $this->_operator = $operator;
15570     $this->_right_operand = $right_operand;
15571   }
15572   public function left_operand(): EditableSyntax {
15573     return $this->_left_operand;
15574   }
15575   public function operator(): EditableSyntax {
15576     return $this->_operator;
15577   }
15578   public function right_operand(): EditableSyntax {
15579     return $this->_right_operand;
15580   }
15581   public function with_left_operand(EditableSyntax $left_operand): BinaryExpression {
15582     return new BinaryExpression(
15583       $left_operand,
15584       $this->_operator,
15585       $this->_right_operand);
15586   }
15587   public function with_operator(EditableSyntax $operator): BinaryExpression {
15588     return new BinaryExpression(
15589       $this->_left_operand,
15590       $operator,
15591       $this->_right_operand);
15592   }
15593   public function with_right_operand(EditableSyntax $right_operand): BinaryExpression {
15594     return new BinaryExpression(
15595       $this->_left_operand,
15596       $this->_operator,
15597       $right_operand);
15598   }
15599
15600   public function rewrite(
15601     ( function
15602       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
15603     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
15604     $new_parents = $parents ?? [];
15605     array_push($new_parents, $this);
15606     $left_operand = $this->left_operand()->rewrite($rewriter, $new_parents);
15607     $operator = $this->operator()->rewrite($rewriter, $new_parents);
15608     $right_operand = $this->right_operand()->rewrite($rewriter, $new_parents);
15609     if (
15610       $left_operand === $this->left_operand() &&
15611       $operator === $this->operator() &&
15612       $right_operand === $this->right_operand()) {
15613       return $rewriter($this, $parents ?? []);
15614     } else {
15615       return $rewriter(new BinaryExpression(
15616         $left_operand,
15617         $operator,
15618         $right_operand), $parents ?? []);
15619     }
15620   }
15621
15622   public static function from_json(mixed $json, int $position, string $source) {
15623     $left_operand = EditableSyntax::from_json(
15624       $json->binary_left_operand, $position, $source);
15625     $position += $left_operand->width();
15626     $operator = EditableSyntax::from_json(
15627       $json->binary_operator, $position, $source);
15628     $position += $operator->width();
15629     $right_operand = EditableSyntax::from_json(
15630       $json->binary_right_operand, $position, $source);
15631     $position += $right_operand->width();
15632     return new BinaryExpression(
15633         $left_operand,
15634         $operator,
15635         $right_operand);
15636   }
15637   public function children(): Generator<string, EditableSyntax, void> {
15638     yield $this->_left_operand;
15639     yield $this->_operator;
15640     yield $this->_right_operand;
15641     yield break;
15642   }
15643 }
15644 final class InstanceofExpression extends EditableSyntax {
15645   private EditableSyntax $_left_operand;
15646   private EditableSyntax $_operator;
15647   private EditableSyntax $_right_operand;
15648   public function __construct(
15649     EditableSyntax $left_operand,
15650     EditableSyntax $operator,
15651     EditableSyntax $right_operand) {
15652     parent::__construct('instanceof_expression');
15653     $this->_left_operand = $left_operand;
15654     $this->_operator = $operator;
15655     $this->_right_operand = $right_operand;
15656   }
15657   public function left_operand(): EditableSyntax {
15658     return $this->_left_operand;
15659   }
15660   public function operator(): EditableSyntax {
15661     return $this->_operator;
15662   }
15663   public function right_operand(): EditableSyntax {
15664     return $this->_right_operand;
15665   }
15666   public function with_left_operand(EditableSyntax $left_operand): InstanceofExpression {
15667     return new InstanceofExpression(
15668       $left_operand,
15669       $this->_operator,
15670       $this->_right_operand);
15671   }
15672   public function with_operator(EditableSyntax $operator): InstanceofExpression {
15673     return new InstanceofExpression(
15674       $this->_left_operand,
15675       $operator,
15676       $this->_right_operand);
15677   }
15678   public function with_right_operand(EditableSyntax $right_operand): InstanceofExpression {
15679     return new InstanceofExpression(
15680       $this->_left_operand,
15681       $this->_operator,
15682       $right_operand);
15683   }
15684
15685   public function rewrite(
15686     ( function
15687       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
15688     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
15689     $new_parents = $parents ?? [];
15690     array_push($new_parents, $this);
15691     $left_operand = $this->left_operand()->rewrite($rewriter, $new_parents);
15692     $operator = $this->operator()->rewrite($rewriter, $new_parents);
15693     $right_operand = $this->right_operand()->rewrite($rewriter, $new_parents);
15694     if (
15695       $left_operand === $this->left_operand() &&
15696       $operator === $this->operator() &&
15697       $right_operand === $this->right_operand()) {
15698       return $rewriter($this, $parents ?? []);
15699     } else {
15700       return $rewriter(new InstanceofExpression(
15701         $left_operand,
15702         $operator,
15703         $right_operand), $parents ?? []);
15704     }
15705   }
15706
15707   public static function from_json(mixed $json, int $position, string $source) {
15708     $left_operand = EditableSyntax::from_json(
15709       $json->instanceof_left_operand, $position, $source);
15710     $position += $left_operand->width();
15711     $operator = EditableSyntax::from_json(
15712       $json->instanceof_operator, $position, $source);
15713     $position += $operator->width();
15714     $right_operand = EditableSyntax::from_json(
15715       $json->instanceof_right_operand, $position, $source);
15716     $position += $right_operand->width();
15717     return new InstanceofExpression(
15718         $left_operand,
15719         $operator,
15720         $right_operand);
15721   }
15722   public function children(): Generator<string, EditableSyntax, void> {
15723     yield $this->_left_operand;
15724     yield $this->_operator;
15725     yield $this->_right_operand;
15726     yield break;
15727   }
15728 }
15729 final class IsExpression extends EditableSyntax {
15730   private EditableSyntax $_left_operand;
15731   private EditableSyntax $_operator;
15732   private EditableSyntax $_right_operand;
15733   public function __construct(
15734     EditableSyntax $left_operand,
15735     EditableSyntax $operator,
15736     EditableSyntax $right_operand) {
15737     parent::__construct('is_expression');
15738     $this->_left_operand = $left_operand;
15739     $this->_operator = $operator;
15740     $this->_right_operand = $right_operand;
15741   }
15742   public function left_operand(): EditableSyntax {
15743     return $this->_left_operand;
15744   }
15745   public function operator(): EditableSyntax {
15746     return $this->_operator;
15747   }
15748   public function right_operand(): EditableSyntax {
15749     return $this->_right_operand;
15750   }
15751   public function with_left_operand(EditableSyntax $left_operand): IsExpression {
15752     return new IsExpression(
15753       $left_operand,
15754       $this->_operator,
15755       $this->_right_operand);
15756   }
15757   public function with_operator(EditableSyntax $operator): IsExpression {
15758     return new IsExpression(
15759       $this->_left_operand,
15760       $operator,
15761       $this->_right_operand);
15762   }
15763   public function with_right_operand(EditableSyntax $right_operand): IsExpression {
15764     return new IsExpression(
15765       $this->_left_operand,
15766       $this->_operator,
15767       $right_operand);
15768   }
15769
15770   public function rewrite(
15771     ( function
15772       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
15773     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
15774     $new_parents = $parents ?? [];
15775     array_push($new_parents, $this);
15776     $left_operand = $this->left_operand()->rewrite($rewriter, $new_parents);
15777     $operator = $this->operator()->rewrite($rewriter, $new_parents);
15778     $right_operand = $this->right_operand()->rewrite($rewriter, $new_parents);
15779     if (
15780       $left_operand === $this->left_operand() &&
15781       $operator === $this->operator() &&
15782       $right_operand === $this->right_operand()) {
15783       return $rewriter($this, $parents ?? []);
15784     } else {
15785       return $rewriter(new IsExpression(
15786         $left_operand,
15787         $operator,
15788         $right_operand), $parents ?? []);
15789     }
15790   }
15791
15792   public static function from_json(mixed $json, int $position, string $source) {
15793     $left_operand = EditableSyntax::from_json(
15794       $json->is_left_operand, $position, $source);
15795     $position += $left_operand->width();
15796     $operator = EditableSyntax::from_json(
15797       $json->is_operator, $position, $source);
15798     $position += $operator->width();
15799     $right_operand = EditableSyntax::from_json(
15800       $json->is_right_operand, $position, $source);
15801     $position += $right_operand->width();
15802     return new IsExpression(
15803         $left_operand,
15804         $operator,
15805         $right_operand);
15806   }
15807   public function children(): Generator<string, EditableSyntax, void> {
15808     yield $this->_left_operand;
15809     yield $this->_operator;
15810     yield $this->_right_operand;
15811     yield break;
15812   }
15813 }
15814 final class ConditionalExpression extends EditableSyntax {
15815   private EditableSyntax $_test;
15816   private EditableSyntax $_question;
15817   private EditableSyntax $_consequence;
15818   private EditableSyntax $_colon;
15819   private EditableSyntax $_alternative;
15820   public function __construct(
15821     EditableSyntax $test,
15822     EditableSyntax $question,
15823     EditableSyntax $consequence,
15824     EditableSyntax $colon,
15825     EditableSyntax $alternative) {
15826     parent::__construct('conditional_expression');
15827     $this->_test = $test;
15828     $this->_question = $question;
15829     $this->_consequence = $consequence;
15830     $this->_colon = $colon;
15831     $this->_alternative = $alternative;
15832   }
15833   public function test(): EditableSyntax {
15834     return $this->_test;
15835   }
15836   public function question(): EditableSyntax {
15837     return $this->_question;
15838   }
15839   public function consequence(): EditableSyntax {
15840     return $this->_consequence;
15841   }
15842   public function colon(): EditableSyntax {
15843     return $this->_colon;
15844   }
15845   public function alternative(): EditableSyntax {
15846     return $this->_alternative;
15847   }
15848   public function with_test(EditableSyntax $test): ConditionalExpression {
15849     return new ConditionalExpression(
15850       $test,
15851       $this->_question,
15852       $this->_consequence,
15853       $this->_colon,
15854       $this->_alternative);
15855   }
15856   public function with_question(EditableSyntax $question): ConditionalExpression {
15857     return new ConditionalExpression(
15858       $this->_test,
15859       $question,
15860       $this->_consequence,
15861       $this->_colon,
15862       $this->_alternative);
15863   }
15864   public function with_consequence(EditableSyntax $consequence): ConditionalExpression {
15865     return new ConditionalExpression(
15866       $this->_test,
15867       $this->_question,
15868       $consequence,
15869       $this->_colon,
15870       $this->_alternative);
15871   }
15872   public function with_colon(EditableSyntax $colon): ConditionalExpression {
15873     return new ConditionalExpression(
15874       $this->_test,
15875       $this->_question,
15876       $this->_consequence,
15877       $colon,
15878       $this->_alternative);
15879   }
15880   public function with_alternative(EditableSyntax $alternative): ConditionalExpression {
15881     return new ConditionalExpression(
15882       $this->_test,
15883       $this->_question,
15884       $this->_consequence,
15885       $this->_colon,
15886       $alternative);
15887   }
15888
15889   public function rewrite(
15890     ( function
15891       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
15892     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
15893     $new_parents = $parents ?? [];
15894     array_push($new_parents, $this);
15895     $test = $this->test()->rewrite($rewriter, $new_parents);
15896     $question = $this->question()->rewrite($rewriter, $new_parents);
15897     $consequence = $this->consequence()->rewrite($rewriter, $new_parents);
15898     $colon = $this->colon()->rewrite($rewriter, $new_parents);
15899     $alternative = $this->alternative()->rewrite($rewriter, $new_parents);
15900     if (
15901       $test === $this->test() &&
15902       $question === $this->question() &&
15903       $consequence === $this->consequence() &&
15904       $colon === $this->colon() &&
15905       $alternative === $this->alternative()) {
15906       return $rewriter($this, $parents ?? []);
15907     } else {
15908       return $rewriter(new ConditionalExpression(
15909         $test,
15910         $question,
15911         $consequence,
15912         $colon,
15913         $alternative), $parents ?? []);
15914     }
15915   }
15916
15917   public static function from_json(mixed $json, int $position, string $source) {
15918     $test = EditableSyntax::from_json(
15919       $json->conditional_test, $position, $source);
15920     $position += $test->width();
15921     $question = EditableSyntax::from_json(
15922       $json->conditional_question, $position, $source);
15923     $position += $question->width();
15924     $consequence = EditableSyntax::from_json(
15925       $json->conditional_consequence, $position, $source);
15926     $position += $consequence->width();
15927     $colon = EditableSyntax::from_json(
15928       $json->conditional_colon, $position, $source);
15929     $position += $colon->width();
15930     $alternative = EditableSyntax::from_json(
15931       $json->conditional_alternative, $position, $source);
15932     $position += $alternative->width();
15933     return new ConditionalExpression(
15934         $test,
15935         $question,
15936         $consequence,
15937         $colon,
15938         $alternative);
15939   }
15940   public function children(): Generator<string, EditableSyntax, void> {
15941     yield $this->_test;
15942     yield $this->_question;
15943     yield $this->_consequence;
15944     yield $this->_colon;
15945     yield $this->_alternative;
15946     yield break;
15947   }
15948 }
15949 final class EvalExpression extends EditableSyntax {
15950   private EditableSyntax $_keyword;
15951   private EditableSyntax $_left_paren;
15952   private EditableSyntax $_argument;
15953   private EditableSyntax $_right_paren;
15954   public function __construct(
15955     EditableSyntax $keyword,
15956     EditableSyntax $left_paren,
15957     EditableSyntax $argument,
15958     EditableSyntax $right_paren) {
15959     parent::__construct('eval_expression');
15960     $this->_keyword = $keyword;
15961     $this->_left_paren = $left_paren;
15962     $this->_argument = $argument;
15963     $this->_right_paren = $right_paren;
15964   }
15965   public function keyword(): EditableSyntax {
15966     return $this->_keyword;
15967   }
15968   public function left_paren(): EditableSyntax {
15969     return $this->_left_paren;
15970   }
15971   public function argument(): EditableSyntax {
15972     return $this->_argument;
15973   }
15974   public function right_paren(): EditableSyntax {
15975     return $this->_right_paren;
15976   }
15977   public function with_keyword(EditableSyntax $keyword): EvalExpression {
15978     return new EvalExpression(
15979       $keyword,
15980       $this->_left_paren,
15981       $this->_argument,
15982       $this->_right_paren);
15983   }
15984   public function with_left_paren(EditableSyntax $left_paren): EvalExpression {
15985     return new EvalExpression(
15986       $this->_keyword,
15987       $left_paren,
15988       $this->_argument,
15989       $this->_right_paren);
15990   }
15991   public function with_argument(EditableSyntax $argument): EvalExpression {
15992     return new EvalExpression(
15993       $this->_keyword,
15994       $this->_left_paren,
15995       $argument,
15996       $this->_right_paren);
15997   }
15998   public function with_right_paren(EditableSyntax $right_paren): EvalExpression {
15999     return new EvalExpression(
16000       $this->_keyword,
16001       $this->_left_paren,
16002       $this->_argument,
16003       $right_paren);
16004   }
16005
16006   public function rewrite(
16007     ( function
16008       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
16009     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
16010     $new_parents = $parents ?? [];
16011     array_push($new_parents, $this);
16012     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
16013     $left_paren = $this->left_paren()->rewrite($rewriter, $new_parents);
16014     $argument = $this->argument()->rewrite($rewriter, $new_parents);
16015     $right_paren = $this->right_paren()->rewrite($rewriter, $new_parents);
16016     if (
16017       $keyword === $this->keyword() &&
16018       $left_paren === $this->left_paren() &&
16019       $argument === $this->argument() &&
16020       $right_paren === $this->right_paren()) {
16021       return $rewriter($this, $parents ?? []);
16022     } else {
16023       return $rewriter(new EvalExpression(
16024         $keyword,
16025         $left_paren,
16026         $argument,
16027         $right_paren), $parents ?? []);
16028     }
16029   }
16030
16031   public static function from_json(mixed $json, int $position, string $source) {
16032     $keyword = EditableSyntax::from_json(
16033       $json->eval_keyword, $position, $source);
16034     $position += $keyword->width();
16035     $left_paren = EditableSyntax::from_json(
16036       $json->eval_left_paren, $position, $source);
16037     $position += $left_paren->width();
16038     $argument = EditableSyntax::from_json(
16039       $json->eval_argument, $position, $source);
16040     $position += $argument->width();
16041     $right_paren = EditableSyntax::from_json(
16042       $json->eval_right_paren, $position, $source);
16043     $position += $right_paren->width();
16044     return new EvalExpression(
16045         $keyword,
16046         $left_paren,
16047         $argument,
16048         $right_paren);
16049   }
16050   public function children(): Generator<string, EditableSyntax, void> {
16051     yield $this->_keyword;
16052     yield $this->_left_paren;
16053     yield $this->_argument;
16054     yield $this->_right_paren;
16055     yield break;
16056   }
16057 }
16058 final class EmptyExpression extends EditableSyntax {
16059   private EditableSyntax $_keyword;
16060   private EditableSyntax $_left_paren;
16061   private EditableSyntax $_argument;
16062   private EditableSyntax $_right_paren;
16063   public function __construct(
16064     EditableSyntax $keyword,
16065     EditableSyntax $left_paren,
16066     EditableSyntax $argument,
16067     EditableSyntax $right_paren) {
16068     parent::__construct('empty_expression');
16069     $this->_keyword = $keyword;
16070     $this->_left_paren = $left_paren;
16071     $this->_argument = $argument;
16072     $this->_right_paren = $right_paren;
16073   }
16074   public function keyword(): EditableSyntax {
16075     return $this->_keyword;
16076   }
16077   public function left_paren(): EditableSyntax {
16078     return $this->_left_paren;
16079   }
16080   public function argument(): EditableSyntax {
16081     return $this->_argument;
16082   }
16083   public function right_paren(): EditableSyntax {
16084     return $this->_right_paren;
16085   }
16086   public function with_keyword(EditableSyntax $keyword): EmptyExpression {
16087     return new EmptyExpression(
16088       $keyword,
16089       $this->_left_paren,
16090       $this->_argument,
16091       $this->_right_paren);
16092   }
16093   public function with_left_paren(EditableSyntax $left_paren): EmptyExpression {
16094     return new EmptyExpression(
16095       $this->_keyword,
16096       $left_paren,
16097       $this->_argument,
16098       $this->_right_paren);
16099   }
16100   public function with_argument(EditableSyntax $argument): EmptyExpression {
16101     return new EmptyExpression(
16102       $this->_keyword,
16103       $this->_left_paren,
16104       $argument,
16105       $this->_right_paren);
16106   }
16107   public function with_right_paren(EditableSyntax $right_paren): EmptyExpression {
16108     return new EmptyExpression(
16109       $this->_keyword,
16110       $this->_left_paren,
16111       $this->_argument,
16112       $right_paren);
16113   }
16114
16115   public function rewrite(
16116     ( function
16117       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
16118     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
16119     $new_parents = $parents ?? [];
16120     array_push($new_parents, $this);
16121     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
16122     $left_paren = $this->left_paren()->rewrite($rewriter, $new_parents);
16123     $argument = $this->argument()->rewrite($rewriter, $new_parents);
16124     $right_paren = $this->right_paren()->rewrite($rewriter, $new_parents);
16125     if (
16126       $keyword === $this->keyword() &&
16127       $left_paren === $this->left_paren() &&
16128       $argument === $this->argument() &&
16129       $right_paren === $this->right_paren()) {
16130       return $rewriter($this, $parents ?? []);
16131     } else {
16132       return $rewriter(new EmptyExpression(
16133         $keyword,
16134         $left_paren,
16135         $argument,
16136         $right_paren), $parents ?? []);
16137     }
16138   }
16139
16140   public static function from_json(mixed $json, int $position, string $source) {
16141     $keyword = EditableSyntax::from_json(
16142       $json->empty_keyword, $position, $source);
16143     $position += $keyword->width();
16144     $left_paren = EditableSyntax::from_json(
16145       $json->empty_left_paren, $position, $source);
16146     $position += $left_paren->width();
16147     $argument = EditableSyntax::from_json(
16148       $json->empty_argument, $position, $source);
16149     $position += $argument->width();
16150     $right_paren = EditableSyntax::from_json(
16151       $json->empty_right_paren, $position, $source);
16152     $position += $right_paren->width();
16153     return new EmptyExpression(
16154         $keyword,
16155         $left_paren,
16156         $argument,
16157         $right_paren);
16158   }
16159   public function children(): Generator<string, EditableSyntax, void> {
16160     yield $this->_keyword;
16161     yield $this->_left_paren;
16162     yield $this->_argument;
16163     yield $this->_right_paren;
16164     yield break;
16165   }
16166 }
16167 final class DefineExpression extends EditableSyntax {
16168   private EditableSyntax $_keyword;
16169   private EditableSyntax $_left_paren;
16170   private EditableSyntax $_argument_list;
16171   private EditableSyntax $_right_paren;
16172   public function __construct(
16173     EditableSyntax $keyword,
16174     EditableSyntax $left_paren,
16175     EditableSyntax $argument_list,
16176     EditableSyntax $right_paren) {
16177     parent::__construct('define_expression');
16178     $this->_keyword = $keyword;
16179     $this->_left_paren = $left_paren;
16180     $this->_argument_list = $argument_list;
16181     $this->_right_paren = $right_paren;
16182   }
16183   public function keyword(): EditableSyntax {
16184     return $this->_keyword;
16185   }
16186   public function left_paren(): EditableSyntax {
16187     return $this->_left_paren;
16188   }
16189   public function argument_list(): EditableSyntax {
16190     return $this->_argument_list;
16191   }
16192   public function right_paren(): EditableSyntax {
16193     return $this->_right_paren;
16194   }
16195   public function with_keyword(EditableSyntax $keyword): DefineExpression {
16196     return new DefineExpression(
16197       $keyword,
16198       $this->_left_paren,
16199       $this->_argument_list,
16200       $this->_right_paren);
16201   }
16202   public function with_left_paren(EditableSyntax $left_paren): DefineExpression {
16203     return new DefineExpression(
16204       $this->_keyword,
16205       $left_paren,
16206       $this->_argument_list,
16207       $this->_right_paren);
16208   }
16209   public function with_argument_list(EditableSyntax $argument_list): DefineExpression {
16210     return new DefineExpression(
16211       $this->_keyword,
16212       $this->_left_paren,
16213       $argument_list,
16214       $this->_right_paren);
16215   }
16216   public function with_right_paren(EditableSyntax $right_paren): DefineExpression {
16217     return new DefineExpression(
16218       $this->_keyword,
16219       $this->_left_paren,
16220       $this->_argument_list,
16221       $right_paren);
16222   }
16223
16224   public function rewrite(
16225     ( function
16226       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
16227     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
16228     $new_parents = $parents ?? [];
16229     array_push($new_parents, $this);
16230     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
16231     $left_paren = $this->left_paren()->rewrite($rewriter, $new_parents);
16232     $argument_list = $this->argument_list()->rewrite($rewriter, $new_parents);
16233     $right_paren = $this->right_paren()->rewrite($rewriter, $new_parents);
16234     if (
16235       $keyword === $this->keyword() &&
16236       $left_paren === $this->left_paren() &&
16237       $argument_list === $this->argument_list() &&
16238       $right_paren === $this->right_paren()) {
16239       return $rewriter($this, $parents ?? []);
16240     } else {
16241       return $rewriter(new DefineExpression(
16242         $keyword,
16243         $left_paren,
16244         $argument_list,
16245         $right_paren), $parents ?? []);
16246     }
16247   }
16248
16249   public static function from_json(mixed $json, int $position, string $source) {
16250     $keyword = EditableSyntax::from_json(
16251       $json->define_keyword, $position, $source);
16252     $position += $keyword->width();
16253     $left_paren = EditableSyntax::from_json(
16254       $json->define_left_paren, $position, $source);
16255     $position += $left_paren->width();
16256     $argument_list = EditableSyntax::from_json(
16257       $json->define_argument_list, $position, $source);
16258     $position += $argument_list->width();
16259     $right_paren = EditableSyntax::from_json(
16260       $json->define_right_paren, $position, $source);
16261     $position += $right_paren->width();
16262     return new DefineExpression(
16263         $keyword,
16264         $left_paren,
16265         $argument_list,
16266         $right_paren);
16267   }
16268   public function children(): Generator<string, EditableSyntax, void> {
16269     yield $this->_keyword;
16270     yield $this->_left_paren;
16271     yield $this->_argument_list;
16272     yield $this->_right_paren;
16273     yield break;
16274   }
16275 }
16276 final class HaltCompilerExpression extends EditableSyntax {
16277   private EditableSyntax $_keyword;
16278   private EditableSyntax $_left_paren;
16279   private EditableSyntax $_argument_list;
16280   private EditableSyntax $_right_paren;
16281   public function __construct(
16282     EditableSyntax $keyword,
16283     EditableSyntax $left_paren,
16284     EditableSyntax $argument_list,
16285     EditableSyntax $right_paren) {
16286     parent::__construct('halt_compiler_expression');
16287     $this->_keyword = $keyword;
16288     $this->_left_paren = $left_paren;
16289     $this->_argument_list = $argument_list;
16290     $this->_right_paren = $right_paren;
16291   }
16292   public function keyword(): EditableSyntax {
16293     return $this->_keyword;
16294   }
16295   public function left_paren(): EditableSyntax {
16296     return $this->_left_paren;
16297   }
16298   public function argument_list(): EditableSyntax {
16299     return $this->_argument_list;
16300   }
16301   public function right_paren(): EditableSyntax {
16302     return $this->_right_paren;
16303   }
16304   public function with_keyword(EditableSyntax $keyword): HaltCompilerExpression {
16305     return new HaltCompilerExpression(
16306       $keyword,
16307       $this->_left_paren,
16308       $this->_argument_list,
16309       $this->_right_paren);
16310   }
16311   public function with_left_paren(EditableSyntax $left_paren): HaltCompilerExpression {
16312     return new HaltCompilerExpression(
16313       $this->_keyword,
16314       $left_paren,
16315       $this->_argument_list,
16316       $this->_right_paren);
16317   }
16318   public function with_argument_list(EditableSyntax $argument_list): HaltCompilerExpression {
16319     return new HaltCompilerExpression(
16320       $this->_keyword,
16321       $this->_left_paren,
16322       $argument_list,
16323       $this->_right_paren);
16324   }
16325   public function with_right_paren(EditableSyntax $right_paren): HaltCompilerExpression {
16326     return new HaltCompilerExpression(
16327       $this->_keyword,
16328       $this->_left_paren,
16329       $this->_argument_list,
16330       $right_paren);
16331   }
16332
16333   public function rewrite(
16334     ( function
16335       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
16336     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
16337     $new_parents = $parents ?? [];
16338     array_push($new_parents, $this);
16339     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
16340     $left_paren = $this->left_paren()->rewrite($rewriter, $new_parents);
16341     $argument_list = $this->argument_list()->rewrite($rewriter, $new_parents);
16342     $right_paren = $this->right_paren()->rewrite($rewriter, $new_parents);
16343     if (
16344       $keyword === $this->keyword() &&
16345       $left_paren === $this->left_paren() &&
16346       $argument_list === $this->argument_list() &&
16347       $right_paren === $this->right_paren()) {
16348       return $rewriter($this, $parents ?? []);
16349     } else {
16350       return $rewriter(new HaltCompilerExpression(
16351         $keyword,
16352         $left_paren,
16353         $argument_list,
16354         $right_paren), $parents ?? []);
16355     }
16356   }
16357
16358   public static function from_json(mixed $json, int $position, string $source) {
16359     $keyword = EditableSyntax::from_json(
16360       $json->halt_compiler_keyword, $position, $source);
16361     $position += $keyword->width();
16362     $left_paren = EditableSyntax::from_json(
16363       $json->halt_compiler_left_paren, $position, $source);
16364     $position += $left_paren->width();
16365     $argument_list = EditableSyntax::from_json(
16366       $json->halt_compiler_argument_list, $position, $source);
16367     $position += $argument_list->width();
16368     $right_paren = EditableSyntax::from_json(
16369       $json->halt_compiler_right_paren, $position, $source);
16370     $position += $right_paren->width();
16371     return new HaltCompilerExpression(
16372         $keyword,
16373         $left_paren,
16374         $argument_list,
16375         $right_paren);
16376   }
16377   public function children(): Generator<string, EditableSyntax, void> {
16378     yield $this->_keyword;
16379     yield $this->_left_paren;
16380     yield $this->_argument_list;
16381     yield $this->_right_paren;
16382     yield break;
16383   }
16384 }
16385 final class IssetExpression extends EditableSyntax {
16386   private EditableSyntax $_keyword;
16387   private EditableSyntax $_left_paren;
16388   private EditableSyntax $_argument_list;
16389   private EditableSyntax $_right_paren;
16390   public function __construct(
16391     EditableSyntax $keyword,
16392     EditableSyntax $left_paren,
16393     EditableSyntax $argument_list,
16394     EditableSyntax $right_paren) {
16395     parent::__construct('isset_expression');
16396     $this->_keyword = $keyword;
16397     $this->_left_paren = $left_paren;
16398     $this->_argument_list = $argument_list;
16399     $this->_right_paren = $right_paren;
16400   }
16401   public function keyword(): EditableSyntax {
16402     return $this->_keyword;
16403   }
16404   public function left_paren(): EditableSyntax {
16405     return $this->_left_paren;
16406   }
16407   public function argument_list(): EditableSyntax {
16408     return $this->_argument_list;
16409   }
16410   public function right_paren(): EditableSyntax {
16411     return $this->_right_paren;
16412   }
16413   public function with_keyword(EditableSyntax $keyword): IssetExpression {
16414     return new IssetExpression(
16415       $keyword,
16416       $this->_left_paren,
16417       $this->_argument_list,
16418       $this->_right_paren);
16419   }
16420   public function with_left_paren(EditableSyntax $left_paren): IssetExpression {
16421     return new IssetExpression(
16422       $this->_keyword,
16423       $left_paren,
16424       $this->_argument_list,
16425       $this->_right_paren);
16426   }
16427   public function with_argument_list(EditableSyntax $argument_list): IssetExpression {
16428     return new IssetExpression(
16429       $this->_keyword,
16430       $this->_left_paren,
16431       $argument_list,
16432       $this->_right_paren);
16433   }
16434   public function with_right_paren(EditableSyntax $right_paren): IssetExpression {
16435     return new IssetExpression(
16436       $this->_keyword,
16437       $this->_left_paren,
16438       $this->_argument_list,
16439       $right_paren);
16440   }
16441
16442   public function rewrite(
16443     ( function
16444       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
16445     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
16446     $new_parents = $parents ?? [];
16447     array_push($new_parents, $this);
16448     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
16449     $left_paren = $this->left_paren()->rewrite($rewriter, $new_parents);
16450     $argument_list = $this->argument_list()->rewrite($rewriter, $new_parents);
16451     $right_paren = $this->right_paren()->rewrite($rewriter, $new_parents);
16452     if (
16453       $keyword === $this->keyword() &&
16454       $left_paren === $this->left_paren() &&
16455       $argument_list === $this->argument_list() &&
16456       $right_paren === $this->right_paren()) {
16457       return $rewriter($this, $parents ?? []);
16458     } else {
16459       return $rewriter(new IssetExpression(
16460         $keyword,
16461         $left_paren,
16462         $argument_list,
16463         $right_paren), $parents ?? []);
16464     }
16465   }
16466
16467   public static function from_json(mixed $json, int $position, string $source) {
16468     $keyword = EditableSyntax::from_json(
16469       $json->isset_keyword, $position, $source);
16470     $position += $keyword->width();
16471     $left_paren = EditableSyntax::from_json(
16472       $json->isset_left_paren, $position, $source);
16473     $position += $left_paren->width();
16474     $argument_list = EditableSyntax::from_json(
16475       $json->isset_argument_list, $position, $source);
16476     $position += $argument_list->width();
16477     $right_paren = EditableSyntax::from_json(
16478       $json->isset_right_paren, $position, $source);
16479     $position += $right_paren->width();
16480     return new IssetExpression(
16481         $keyword,
16482         $left_paren,
16483         $argument_list,
16484         $right_paren);
16485   }
16486   public function children(): Generator<string, EditableSyntax, void> {
16487     yield $this->_keyword;
16488     yield $this->_left_paren;
16489     yield $this->_argument_list;
16490     yield $this->_right_paren;
16491     yield break;
16492   }
16493 }
16494 final class FunctionCallExpression extends EditableSyntax {
16495   private EditableSyntax $_receiver;
16496   private EditableSyntax $_left_paren;
16497   private EditableSyntax $_argument_list;
16498   private EditableSyntax $_right_paren;
16499   public function __construct(
16500     EditableSyntax $receiver,
16501     EditableSyntax $left_paren,
16502     EditableSyntax $argument_list,
16503     EditableSyntax $right_paren) {
16504     parent::__construct('function_call_expression');
16505     $this->_receiver = $receiver;
16506     $this->_left_paren = $left_paren;
16507     $this->_argument_list = $argument_list;
16508     $this->_right_paren = $right_paren;
16509   }
16510   public function receiver(): EditableSyntax {
16511     return $this->_receiver;
16512   }
16513   public function left_paren(): EditableSyntax {
16514     return $this->_left_paren;
16515   }
16516   public function argument_list(): EditableSyntax {
16517     return $this->_argument_list;
16518   }
16519   public function right_paren(): EditableSyntax {
16520     return $this->_right_paren;
16521   }
16522   public function with_receiver(EditableSyntax $receiver): FunctionCallExpression {
16523     return new FunctionCallExpression(
16524       $receiver,
16525       $this->_left_paren,
16526       $this->_argument_list,
16527       $this->_right_paren);
16528   }
16529   public function with_left_paren(EditableSyntax $left_paren): FunctionCallExpression {
16530     return new FunctionCallExpression(
16531       $this->_receiver,
16532       $left_paren,
16533       $this->_argument_list,
16534       $this->_right_paren);
16535   }
16536   public function with_argument_list(EditableSyntax $argument_list): FunctionCallExpression {
16537     return new FunctionCallExpression(
16538       $this->_receiver,
16539       $this->_left_paren,
16540       $argument_list,
16541       $this->_right_paren);
16542   }
16543   public function with_right_paren(EditableSyntax $right_paren): FunctionCallExpression {
16544     return new FunctionCallExpression(
16545       $this->_receiver,
16546       $this->_left_paren,
16547       $this->_argument_list,
16548       $right_paren);
16549   }
16550
16551   public function rewrite(
16552     ( function
16553       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
16554     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
16555     $new_parents = $parents ?? [];
16556     array_push($new_parents, $this);
16557     $receiver = $this->receiver()->rewrite($rewriter, $new_parents);
16558     $left_paren = $this->left_paren()->rewrite($rewriter, $new_parents);
16559     $argument_list = $this->argument_list()->rewrite($rewriter, $new_parents);
16560     $right_paren = $this->right_paren()->rewrite($rewriter, $new_parents);
16561     if (
16562       $receiver === $this->receiver() &&
16563       $left_paren === $this->left_paren() &&
16564       $argument_list === $this->argument_list() &&
16565       $right_paren === $this->right_paren()) {
16566       return $rewriter($this, $parents ?? []);
16567     } else {
16568       return $rewriter(new FunctionCallExpression(
16569         $receiver,
16570         $left_paren,
16571         $argument_list,
16572         $right_paren), $parents ?? []);
16573     }
16574   }
16575
16576   public static function from_json(mixed $json, int $position, string $source) {
16577     $receiver = EditableSyntax::from_json(
16578       $json->function_call_receiver, $position, $source);
16579     $position += $receiver->width();
16580     $left_paren = EditableSyntax::from_json(
16581       $json->function_call_left_paren, $position, $source);
16582     $position += $left_paren->width();
16583     $argument_list = EditableSyntax::from_json(
16584       $json->function_call_argument_list, $position, $source);
16585     $position += $argument_list->width();
16586     $right_paren = EditableSyntax::from_json(
16587       $json->function_call_right_paren, $position, $source);
16588     $position += $right_paren->width();
16589     return new FunctionCallExpression(
16590         $receiver,
16591         $left_paren,
16592         $argument_list,
16593         $right_paren);
16594   }
16595   public function children(): Generator<string, EditableSyntax, void> {
16596     yield $this->_receiver;
16597     yield $this->_left_paren;
16598     yield $this->_argument_list;
16599     yield $this->_right_paren;
16600     yield break;
16601   }
16602 }
16603 final class FunctionCallWithTypeArgumentsExpression extends EditableSyntax {
16604   private EditableSyntax $_receiver;
16605   private EditableSyntax $_type_args;
16606   private EditableSyntax $_left_paren;
16607   private EditableSyntax $_argument_list;
16608   private EditableSyntax $_right_paren;
16609   public function __construct(
16610     EditableSyntax $receiver,
16611     EditableSyntax $type_args,
16612     EditableSyntax $left_paren,
16613     EditableSyntax $argument_list,
16614     EditableSyntax $right_paren) {
16615     parent::__construct('function_call_with_type_arguments_expression');
16616     $this->_receiver = $receiver;
16617     $this->_type_args = $type_args;
16618     $this->_left_paren = $left_paren;
16619     $this->_argument_list = $argument_list;
16620     $this->_right_paren = $right_paren;
16621   }
16622   public function receiver(): EditableSyntax {
16623     return $this->_receiver;
16624   }
16625   public function type_args(): EditableSyntax {
16626     return $this->_type_args;
16627   }
16628   public function left_paren(): EditableSyntax {
16629     return $this->_left_paren;
16630   }
16631   public function argument_list(): EditableSyntax {
16632     return $this->_argument_list;
16633   }
16634   public function right_paren(): EditableSyntax {
16635     return $this->_right_paren;
16636   }
16637   public function with_receiver(EditableSyntax $receiver): FunctionCallWithTypeArgumentsExpression {
16638     return new FunctionCallWithTypeArgumentsExpression(
16639       $receiver,
16640       $this->_type_args,
16641       $this->_left_paren,
16642       $this->_argument_list,
16643       $this->_right_paren);
16644   }
16645   public function with_type_args(EditableSyntax $type_args): FunctionCallWithTypeArgumentsExpression {
16646     return new FunctionCallWithTypeArgumentsExpression(
16647       $this->_receiver,
16648       $type_args,
16649       $this->_left_paren,
16650       $this->_argument_list,
16651       $this->_right_paren);
16652   }
16653   public function with_left_paren(EditableSyntax $left_paren): FunctionCallWithTypeArgumentsExpression {
16654     return new FunctionCallWithTypeArgumentsExpression(
16655       $this->_receiver,
16656       $this->_type_args,
16657       $left_paren,
16658       $this->_argument_list,
16659       $this->_right_paren);
16660   }
16661   public function with_argument_list(EditableSyntax $argument_list): FunctionCallWithTypeArgumentsExpression {
16662     return new FunctionCallWithTypeArgumentsExpression(
16663       $this->_receiver,
16664       $this->_type_args,
16665       $this->_left_paren,
16666       $argument_list,
16667       $this->_right_paren);
16668   }
16669   public function with_right_paren(EditableSyntax $right_paren): FunctionCallWithTypeArgumentsExpression {
16670     return new FunctionCallWithTypeArgumentsExpression(
16671       $this->_receiver,
16672       $this->_type_args,
16673       $this->_left_paren,
16674       $this->_argument_list,
16675       $right_paren);
16676   }
16677
16678   public function rewrite(
16679     ( function
16680       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
16681     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
16682     $new_parents = $parents ?? [];
16683     array_push($new_parents, $this);
16684     $receiver = $this->receiver()->rewrite($rewriter, $new_parents);
16685     $type_args = $this->type_args()->rewrite($rewriter, $new_parents);
16686     $left_paren = $this->left_paren()->rewrite($rewriter, $new_parents);
16687     $argument_list = $this->argument_list()->rewrite($rewriter, $new_parents);
16688     $right_paren = $this->right_paren()->rewrite($rewriter, $new_parents);
16689     if (
16690       $receiver === $this->receiver() &&
16691       $type_args === $this->type_args() &&
16692       $left_paren === $this->left_paren() &&
16693       $argument_list === $this->argument_list() &&
16694       $right_paren === $this->right_paren()) {
16695       return $rewriter($this, $parents ?? []);
16696     } else {
16697       return $rewriter(new FunctionCallWithTypeArgumentsExpression(
16698         $receiver,
16699         $type_args,
16700         $left_paren,
16701         $argument_list,
16702         $right_paren), $parents ?? []);
16703     }
16704   }
16705
16706   public static function from_json(mixed $json, int $position, string $source) {
16707     $receiver = EditableSyntax::from_json(
16708       $json->function_call_with_type_arguments_receiver, $position, $source);
16709     $position += $receiver->width();
16710     $type_args = EditableSyntax::from_json(
16711       $json->function_call_with_type_arguments_type_args, $position, $source);
16712     $position += $type_args->width();
16713     $left_paren = EditableSyntax::from_json(
16714       $json->function_call_with_type_arguments_left_paren, $position, $source);
16715     $position += $left_paren->width();
16716     $argument_list = EditableSyntax::from_json(
16717       $json->function_call_with_type_arguments_argument_list, $position, $source);
16718     $position += $argument_list->width();
16719     $right_paren = EditableSyntax::from_json(
16720       $json->function_call_with_type_arguments_right_paren, $position, $source);
16721     $position += $right_paren->width();
16722     return new FunctionCallWithTypeArgumentsExpression(
16723         $receiver,
16724         $type_args,
16725         $left_paren,
16726         $argument_list,
16727         $right_paren);
16728   }
16729   public function children(): Generator<string, EditableSyntax, void> {
16730     yield $this->_receiver;
16731     yield $this->_type_args;
16732     yield $this->_left_paren;
16733     yield $this->_argument_list;
16734     yield $this->_right_paren;
16735     yield break;
16736   }
16737 }
16738 final class ParenthesizedExpression extends EditableSyntax {
16739   private EditableSyntax $_left_paren;
16740   private EditableSyntax $_expression;
16741   private EditableSyntax $_right_paren;
16742   public function __construct(
16743     EditableSyntax $left_paren,
16744     EditableSyntax $expression,
16745     EditableSyntax $right_paren) {
16746     parent::__construct('parenthesized_expression');
16747     $this->_left_paren = $left_paren;
16748     $this->_expression = $expression;
16749     $this->_right_paren = $right_paren;
16750   }
16751   public function left_paren(): EditableSyntax {
16752     return $this->_left_paren;
16753   }
16754   public function expression(): EditableSyntax {
16755     return $this->_expression;
16756   }
16757   public function right_paren(): EditableSyntax {
16758     return $this->_right_paren;
16759   }
16760   public function with_left_paren(EditableSyntax $left_paren): ParenthesizedExpression {
16761     return new ParenthesizedExpression(
16762       $left_paren,
16763       $this->_expression,
16764       $this->_right_paren);
16765   }
16766   public function with_expression(EditableSyntax $expression): ParenthesizedExpression {
16767     return new ParenthesizedExpression(
16768       $this->_left_paren,
16769       $expression,
16770       $this->_right_paren);
16771   }
16772   public function with_right_paren(EditableSyntax $right_paren): ParenthesizedExpression {
16773     return new ParenthesizedExpression(
16774       $this->_left_paren,
16775       $this->_expression,
16776       $right_paren);
16777   }
16778
16779   public function rewrite(
16780     ( function
16781       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
16782     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
16783     $new_parents = $parents ?? [];
16784     array_push($new_parents, $this);
16785     $left_paren = $this->left_paren()->rewrite($rewriter, $new_parents);
16786     $expression = $this->expression()->rewrite($rewriter, $new_parents);
16787     $right_paren = $this->right_paren()->rewrite($rewriter, $new_parents);
16788     if (
16789       $left_paren === $this->left_paren() &&
16790       $expression === $this->expression() &&
16791       $right_paren === $this->right_paren()) {
16792       return $rewriter($this, $parents ?? []);
16793     } else {
16794       return $rewriter(new ParenthesizedExpression(
16795         $left_paren,
16796         $expression,
16797         $right_paren), $parents ?? []);
16798     }
16799   }
16800
16801   public static function from_json(mixed $json, int $position, string $source) {
16802     $left_paren = EditableSyntax::from_json(
16803       $json->parenthesized_expression_left_paren, $position, $source);
16804     $position += $left_paren->width();
16805     $expression = EditableSyntax::from_json(
16806       $json->parenthesized_expression_expression, $position, $source);
16807     $position += $expression->width();
16808     $right_paren = EditableSyntax::from_json(
16809       $json->parenthesized_expression_right_paren, $position, $source);
16810     $position += $right_paren->width();
16811     return new ParenthesizedExpression(
16812         $left_paren,
16813         $expression,
16814         $right_paren);
16815   }
16816   public function children(): Generator<string, EditableSyntax, void> {
16817     yield $this->_left_paren;
16818     yield $this->_expression;
16819     yield $this->_right_paren;
16820     yield break;
16821   }
16822 }
16823 final class BracedExpression extends EditableSyntax {
16824   private EditableSyntax $_left_brace;
16825   private EditableSyntax $_expression;
16826   private EditableSyntax $_right_brace;
16827   public function __construct(
16828     EditableSyntax $left_brace,
16829     EditableSyntax $expression,
16830     EditableSyntax $right_brace) {
16831     parent::__construct('braced_expression');
16832     $this->_left_brace = $left_brace;
16833     $this->_expression = $expression;
16834     $this->_right_brace = $right_brace;
16835   }
16836   public function left_brace(): EditableSyntax {
16837     return $this->_left_brace;
16838   }
16839   public function expression(): EditableSyntax {
16840     return $this->_expression;
16841   }
16842   public function right_brace(): EditableSyntax {
16843     return $this->_right_brace;
16844   }
16845   public function with_left_brace(EditableSyntax $left_brace): BracedExpression {
16846     return new BracedExpression(
16847       $left_brace,
16848       $this->_expression,
16849       $this->_right_brace);
16850   }
16851   public function with_expression(EditableSyntax $expression): BracedExpression {
16852     return new BracedExpression(
16853       $this->_left_brace,
16854       $expression,
16855       $this->_right_brace);
16856   }
16857   public function with_right_brace(EditableSyntax $right_brace): BracedExpression {
16858     return new BracedExpression(
16859       $this->_left_brace,
16860       $this->_expression,
16861       $right_brace);
16862   }
16863
16864   public function rewrite(
16865     ( function
16866       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
16867     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
16868     $new_parents = $parents ?? [];
16869     array_push($new_parents, $this);
16870     $left_brace = $this->left_brace()->rewrite($rewriter, $new_parents);
16871     $expression = $this->expression()->rewrite($rewriter, $new_parents);
16872     $right_brace = $this->right_brace()->rewrite($rewriter, $new_parents);
16873     if (
16874       $left_brace === $this->left_brace() &&
16875       $expression === $this->expression() &&
16876       $right_brace === $this->right_brace()) {
16877       return $rewriter($this, $parents ?? []);
16878     } else {
16879       return $rewriter(new BracedExpression(
16880         $left_brace,
16881         $expression,
16882         $right_brace), $parents ?? []);
16883     }
16884   }
16885
16886   public static function from_json(mixed $json, int $position, string $source) {
16887     $left_brace = EditableSyntax::from_json(
16888       $json->braced_expression_left_brace, $position, $source);
16889     $position += $left_brace->width();
16890     $expression = EditableSyntax::from_json(
16891       $json->braced_expression_expression, $position, $source);
16892     $position += $expression->width();
16893     $right_brace = EditableSyntax::from_json(
16894       $json->braced_expression_right_brace, $position, $source);
16895     $position += $right_brace->width();
16896     return new BracedExpression(
16897         $left_brace,
16898         $expression,
16899         $right_brace);
16900   }
16901   public function children(): Generator<string, EditableSyntax, void> {
16902     yield $this->_left_brace;
16903     yield $this->_expression;
16904     yield $this->_right_brace;
16905     yield break;
16906   }
16907 }
16908 final class EmbeddedBracedExpression extends EditableSyntax {
16909   private EditableSyntax $_left_brace;
16910   private EditableSyntax $_expression;
16911   private EditableSyntax $_right_brace;
16912   public function __construct(
16913     EditableSyntax $left_brace,
16914     EditableSyntax $expression,
16915     EditableSyntax $right_brace) {
16916     parent::__construct('embedded_braced_expression');
16917     $this->_left_brace = $left_brace;
16918     $this->_expression = $expression;
16919     $this->_right_brace = $right_brace;
16920   }
16921   public function left_brace(): EditableSyntax {
16922     return $this->_left_brace;
16923   }
16924   public function expression(): EditableSyntax {
16925     return $this->_expression;
16926   }
16927   public function right_brace(): EditableSyntax {
16928     return $this->_right_brace;
16929   }
16930   public function with_left_brace(EditableSyntax $left_brace): EmbeddedBracedExpression {
16931     return new EmbeddedBracedExpression(
16932       $left_brace,
16933       $this->_expression,
16934       $this->_right_brace);
16935   }
16936   public function with_expression(EditableSyntax $expression): EmbeddedBracedExpression {
16937     return new EmbeddedBracedExpression(
16938       $this->_left_brace,
16939       $expression,
16940       $this->_right_brace);
16941   }
16942   public function with_right_brace(EditableSyntax $right_brace): EmbeddedBracedExpression {
16943     return new EmbeddedBracedExpression(
16944       $this->_left_brace,
16945       $this->_expression,
16946       $right_brace);
16947   }
16948
16949   public function rewrite(
16950     ( function
16951       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
16952     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
16953     $new_parents = $parents ?? [];
16954     array_push($new_parents, $this);
16955     $left_brace = $this->left_brace()->rewrite($rewriter, $new_parents);
16956     $expression = $this->expression()->rewrite($rewriter, $new_parents);
16957     $right_brace = $this->right_brace()->rewrite($rewriter, $new_parents);
16958     if (
16959       $left_brace === $this->left_brace() &&
16960       $expression === $this->expression() &&
16961       $right_brace === $this->right_brace()) {
16962       return $rewriter($this, $parents ?? []);
16963     } else {
16964       return $rewriter(new EmbeddedBracedExpression(
16965         $left_brace,
16966         $expression,
16967         $right_brace), $parents ?? []);
16968     }
16969   }
16970
16971   public static function from_json(mixed $json, int $position, string $source) {
16972     $left_brace = EditableSyntax::from_json(
16973       $json->embedded_braced_expression_left_brace, $position, $source);
16974     $position += $left_brace->width();
16975     $expression = EditableSyntax::from_json(
16976       $json->embedded_braced_expression_expression, $position, $source);
16977     $position += $expression->width();
16978     $right_brace = EditableSyntax::from_json(
16979       $json->embedded_braced_expression_right_brace, $position, $source);
16980     $position += $right_brace->width();
16981     return new EmbeddedBracedExpression(
16982         $left_brace,
16983         $expression,
16984         $right_brace);
16985   }
16986   public function children(): Generator<string, EditableSyntax, void> {
16987     yield $this->_left_brace;
16988     yield $this->_expression;
16989     yield $this->_right_brace;
16990     yield break;
16991   }
16992 }
16993 final class ListExpression extends EditableSyntax {
16994   private EditableSyntax $_keyword;
16995   private EditableSyntax $_left_paren;
16996   private EditableSyntax $_members;
16997   private EditableSyntax $_right_paren;
16998   public function __construct(
16999     EditableSyntax $keyword,
17000     EditableSyntax $left_paren,
17001     EditableSyntax $members,
17002     EditableSyntax $right_paren) {
17003     parent::__construct('list_expression');
17004     $this->_keyword = $keyword;
17005     $this->_left_paren = $left_paren;
17006     $this->_members = $members;
17007     $this->_right_paren = $right_paren;
17008   }
17009   public function keyword(): EditableSyntax {
17010     return $this->_keyword;
17011   }
17012   public function left_paren(): EditableSyntax {
17013     return $this->_left_paren;
17014   }
17015   public function members(): EditableSyntax {
17016     return $this->_members;
17017   }
17018   public function right_paren(): EditableSyntax {
17019     return $this->_right_paren;
17020   }
17021   public function with_keyword(EditableSyntax $keyword): ListExpression {
17022     return new ListExpression(
17023       $keyword,
17024       $this->_left_paren,
17025       $this->_members,
17026       $this->_right_paren);
17027   }
17028   public function with_left_paren(EditableSyntax $left_paren): ListExpression {
17029     return new ListExpression(
17030       $this->_keyword,
17031       $left_paren,
17032       $this->_members,
17033       $this->_right_paren);
17034   }
17035   public function with_members(EditableSyntax $members): ListExpression {
17036     return new ListExpression(
17037       $this->_keyword,
17038       $this->_left_paren,
17039       $members,
17040       $this->_right_paren);
17041   }
17042   public function with_right_paren(EditableSyntax $right_paren): ListExpression {
17043     return new ListExpression(
17044       $this->_keyword,
17045       $this->_left_paren,
17046       $this->_members,
17047       $right_paren);
17048   }
17049
17050   public function rewrite(
17051     ( function
17052       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
17053     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
17054     $new_parents = $parents ?? [];
17055     array_push($new_parents, $this);
17056     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
17057     $left_paren = $this->left_paren()->rewrite($rewriter, $new_parents);
17058     $members = $this->members()->rewrite($rewriter, $new_parents);
17059     $right_paren = $this->right_paren()->rewrite($rewriter, $new_parents);
17060     if (
17061       $keyword === $this->keyword() &&
17062       $left_paren === $this->left_paren() &&
17063       $members === $this->members() &&
17064       $right_paren === $this->right_paren()) {
17065       return $rewriter($this, $parents ?? []);
17066     } else {
17067       return $rewriter(new ListExpression(
17068         $keyword,
17069         $left_paren,
17070         $members,
17071         $right_paren), $parents ?? []);
17072     }
17073   }
17074
17075   public static function from_json(mixed $json, int $position, string $source) {
17076     $keyword = EditableSyntax::from_json(
17077       $json->list_keyword, $position, $source);
17078     $position += $keyword->width();
17079     $left_paren = EditableSyntax::from_json(
17080       $json->list_left_paren, $position, $source);
17081     $position += $left_paren->width();
17082     $members = EditableSyntax::from_json(
17083       $json->list_members, $position, $source);
17084     $position += $members->width();
17085     $right_paren = EditableSyntax::from_json(
17086       $json->list_right_paren, $position, $source);
17087     $position += $right_paren->width();
17088     return new ListExpression(
17089         $keyword,
17090         $left_paren,
17091         $members,
17092         $right_paren);
17093   }
17094   public function children(): Generator<string, EditableSyntax, void> {
17095     yield $this->_keyword;
17096     yield $this->_left_paren;
17097     yield $this->_members;
17098     yield $this->_right_paren;
17099     yield break;
17100   }
17101 }
17102 final class CollectionLiteralExpression extends EditableSyntax {
17103   private EditableSyntax $_name;
17104   private EditableSyntax $_left_brace;
17105   private EditableSyntax $_initializers;
17106   private EditableSyntax $_right_brace;
17107   public function __construct(
17108     EditableSyntax $name,
17109     EditableSyntax $left_brace,
17110     EditableSyntax $initializers,
17111     EditableSyntax $right_brace) {
17112     parent::__construct('collection_literal_expression');
17113     $this->_name = $name;
17114     $this->_left_brace = $left_brace;
17115     $this->_initializers = $initializers;
17116     $this->_right_brace = $right_brace;
17117   }
17118   public function name(): EditableSyntax {
17119     return $this->_name;
17120   }
17121   public function left_brace(): EditableSyntax {
17122     return $this->_left_brace;
17123   }
17124   public function initializers(): EditableSyntax {
17125     return $this->_initializers;
17126   }
17127   public function right_brace(): EditableSyntax {
17128     return $this->_right_brace;
17129   }
17130   public function with_name(EditableSyntax $name): CollectionLiteralExpression {
17131     return new CollectionLiteralExpression(
17132       $name,
17133       $this->_left_brace,
17134       $this->_initializers,
17135       $this->_right_brace);
17136   }
17137   public function with_left_brace(EditableSyntax $left_brace): CollectionLiteralExpression {
17138     return new CollectionLiteralExpression(
17139       $this->_name,
17140       $left_brace,
17141       $this->_initializers,
17142       $this->_right_brace);
17143   }
17144   public function with_initializers(EditableSyntax $initializers): CollectionLiteralExpression {
17145     return new CollectionLiteralExpression(
17146       $this->_name,
17147       $this->_left_brace,
17148       $initializers,
17149       $this->_right_brace);
17150   }
17151   public function with_right_brace(EditableSyntax $right_brace): CollectionLiteralExpression {
17152     return new CollectionLiteralExpression(
17153       $this->_name,
17154       $this->_left_brace,
17155       $this->_initializers,
17156       $right_brace);
17157   }
17158
17159   public function rewrite(
17160     ( function
17161       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
17162     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
17163     $new_parents = $parents ?? [];
17164     array_push($new_parents, $this);
17165     $name = $this->name()->rewrite($rewriter, $new_parents);
17166     $left_brace = $this->left_brace()->rewrite($rewriter, $new_parents);
17167     $initializers = $this->initializers()->rewrite($rewriter, $new_parents);
17168     $right_brace = $this->right_brace()->rewrite($rewriter, $new_parents);
17169     if (
17170       $name === $this->name() &&
17171       $left_brace === $this->left_brace() &&
17172       $initializers === $this->initializers() &&
17173       $right_brace === $this->right_brace()) {
17174       return $rewriter($this, $parents ?? []);
17175     } else {
17176       return $rewriter(new CollectionLiteralExpression(
17177         $name,
17178         $left_brace,
17179         $initializers,
17180         $right_brace), $parents ?? []);
17181     }
17182   }
17183
17184   public static function from_json(mixed $json, int $position, string $source) {
17185     $name = EditableSyntax::from_json(
17186       $json->collection_literal_name, $position, $source);
17187     $position += $name->width();
17188     $left_brace = EditableSyntax::from_json(
17189       $json->collection_literal_left_brace, $position, $source);
17190     $position += $left_brace->width();
17191     $initializers = EditableSyntax::from_json(
17192       $json->collection_literal_initializers, $position, $source);
17193     $position += $initializers->width();
17194     $right_brace = EditableSyntax::from_json(
17195       $json->collection_literal_right_brace, $position, $source);
17196     $position += $right_brace->width();
17197     return new CollectionLiteralExpression(
17198         $name,
17199         $left_brace,
17200         $initializers,
17201         $right_brace);
17202   }
17203   public function children(): Generator<string, EditableSyntax, void> {
17204     yield $this->_name;
17205     yield $this->_left_brace;
17206     yield $this->_initializers;
17207     yield $this->_right_brace;
17208     yield break;
17209   }
17210 }
17211 final class ObjectCreationExpression extends EditableSyntax {
17212   private EditableSyntax $_new_keyword;
17213   private EditableSyntax $_object;
17214   public function __construct(
17215     EditableSyntax $new_keyword,
17216     EditableSyntax $object) {
17217     parent::__construct('object_creation_expression');
17218     $this->_new_keyword = $new_keyword;
17219     $this->_object = $object;
17220   }
17221   public function new_keyword(): EditableSyntax {
17222     return $this->_new_keyword;
17223   }
17224   public function object(): EditableSyntax {
17225     return $this->_object;
17226   }
17227   public function with_new_keyword(EditableSyntax $new_keyword): ObjectCreationExpression {
17228     return new ObjectCreationExpression(
17229       $new_keyword,
17230       $this->_object);
17231   }
17232   public function with_object(EditableSyntax $object): ObjectCreationExpression {
17233     return new ObjectCreationExpression(
17234       $this->_new_keyword,
17235       $object);
17236   }
17237
17238   public function rewrite(
17239     ( function
17240       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
17241     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
17242     $new_parents = $parents ?? [];
17243     array_push($new_parents, $this);
17244     $new_keyword = $this->new_keyword()->rewrite($rewriter, $new_parents);
17245     $object = $this->object()->rewrite($rewriter, $new_parents);
17246     if (
17247       $new_keyword === $this->new_keyword() &&
17248       $object === $this->object()) {
17249       return $rewriter($this, $parents ?? []);
17250     } else {
17251       return $rewriter(new ObjectCreationExpression(
17252         $new_keyword,
17253         $object), $parents ?? []);
17254     }
17255   }
17256
17257   public static function from_json(mixed $json, int $position, string $source) {
17258     $new_keyword = EditableSyntax::from_json(
17259       $json->object_creation_new_keyword, $position, $source);
17260     $position += $new_keyword->width();
17261     $object = EditableSyntax::from_json(
17262       $json->object_creation_object, $position, $source);
17263     $position += $object->width();
17264     return new ObjectCreationExpression(
17265         $new_keyword,
17266         $object);
17267   }
17268   public function children(): Generator<string, EditableSyntax, void> {
17269     yield $this->_new_keyword;
17270     yield $this->_object;
17271     yield break;
17272   }
17273 }
17274 final class ConstructorCall extends EditableSyntax {
17275   private EditableSyntax $_type;
17276   private EditableSyntax $_left_paren;
17277   private EditableSyntax $_argument_list;
17278   private EditableSyntax $_right_paren;
17279   public function __construct(
17280     EditableSyntax $type,
17281     EditableSyntax $left_paren,
17282     EditableSyntax $argument_list,
17283     EditableSyntax $right_paren) {
17284     parent::__construct('constructor_call');
17285     $this->_type = $type;
17286     $this->_left_paren = $left_paren;
17287     $this->_argument_list = $argument_list;
17288     $this->_right_paren = $right_paren;
17289   }
17290   public function type(): EditableSyntax {
17291     return $this->_type;
17292   }
17293   public function left_paren(): EditableSyntax {
17294     return $this->_left_paren;
17295   }
17296   public function argument_list(): EditableSyntax {
17297     return $this->_argument_list;
17298   }
17299   public function right_paren(): EditableSyntax {
17300     return $this->_right_paren;
17301   }
17302   public function with_type(EditableSyntax $type): ConstructorCall {
17303     return new ConstructorCall(
17304       $type,
17305       $this->_left_paren,
17306       $this->_argument_list,
17307       $this->_right_paren);
17308   }
17309   public function with_left_paren(EditableSyntax $left_paren): ConstructorCall {
17310     return new ConstructorCall(
17311       $this->_type,
17312       $left_paren,
17313       $this->_argument_list,
17314       $this->_right_paren);
17315   }
17316   public function with_argument_list(EditableSyntax $argument_list): ConstructorCall {
17317     return new ConstructorCall(
17318       $this->_type,
17319       $this->_left_paren,
17320       $argument_list,
17321       $this->_right_paren);
17322   }
17323   public function with_right_paren(EditableSyntax $right_paren): ConstructorCall {
17324     return new ConstructorCall(
17325       $this->_type,
17326       $this->_left_paren,
17327       $this->_argument_list,
17328       $right_paren);
17329   }
17330
17331   public function rewrite(
17332     ( function
17333       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
17334     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
17335     $new_parents = $parents ?? [];
17336     array_push($new_parents, $this);
17337     $type = $this->type()->rewrite($rewriter, $new_parents);
17338     $left_paren = $this->left_paren()->rewrite($rewriter, $new_parents);
17339     $argument_list = $this->argument_list()->rewrite($rewriter, $new_parents);
17340     $right_paren = $this->right_paren()->rewrite($rewriter, $new_parents);
17341     if (
17342       $type === $this->type() &&
17343       $left_paren === $this->left_paren() &&
17344       $argument_list === $this->argument_list() &&
17345       $right_paren === $this->right_paren()) {
17346       return $rewriter($this, $parents ?? []);
17347     } else {
17348       return $rewriter(new ConstructorCall(
17349         $type,
17350         $left_paren,
17351         $argument_list,
17352         $right_paren), $parents ?? []);
17353     }
17354   }
17355
17356   public static function from_json(mixed $json, int $position, string $source) {
17357     $type = EditableSyntax::from_json(
17358       $json->constructor_call_type, $position, $source);
17359     $position += $type->width();
17360     $left_paren = EditableSyntax::from_json(
17361       $json->constructor_call_left_paren, $position, $source);
17362     $position += $left_paren->width();
17363     $argument_list = EditableSyntax::from_json(
17364       $json->constructor_call_argument_list, $position, $source);
17365     $position += $argument_list->width();
17366     $right_paren = EditableSyntax::from_json(
17367       $json->constructor_call_right_paren, $position, $source);
17368     $position += $right_paren->width();
17369     return new ConstructorCall(
17370         $type,
17371         $left_paren,
17372         $argument_list,
17373         $right_paren);
17374   }
17375   public function children(): Generator<string, EditableSyntax, void> {
17376     yield $this->_type;
17377     yield $this->_left_paren;
17378     yield $this->_argument_list;
17379     yield $this->_right_paren;
17380     yield break;
17381   }
17382 }
17383 final class ArrayCreationExpression extends EditableSyntax {
17384   private EditableSyntax $_left_bracket;
17385   private EditableSyntax $_members;
17386   private EditableSyntax $_right_bracket;
17387   public function __construct(
17388     EditableSyntax $left_bracket,
17389     EditableSyntax $members,
17390     EditableSyntax $right_bracket) {
17391     parent::__construct('array_creation_expression');
17392     $this->_left_bracket = $left_bracket;
17393     $this->_members = $members;
17394     $this->_right_bracket = $right_bracket;
17395   }
17396   public function left_bracket(): EditableSyntax {
17397     return $this->_left_bracket;
17398   }
17399   public function members(): EditableSyntax {
17400     return $this->_members;
17401   }
17402   public function right_bracket(): EditableSyntax {
17403     return $this->_right_bracket;
17404   }
17405   public function with_left_bracket(EditableSyntax $left_bracket): ArrayCreationExpression {
17406     return new ArrayCreationExpression(
17407       $left_bracket,
17408       $this->_members,
17409       $this->_right_bracket);
17410   }
17411   public function with_members(EditableSyntax $members): ArrayCreationExpression {
17412     return new ArrayCreationExpression(
17413       $this->_left_bracket,
17414       $members,
17415       $this->_right_bracket);
17416   }
17417   public function with_right_bracket(EditableSyntax $right_bracket): ArrayCreationExpression {
17418     return new ArrayCreationExpression(
17419       $this->_left_bracket,
17420       $this->_members,
17421       $right_bracket);
17422   }
17423
17424   public function rewrite(
17425     ( function
17426       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
17427     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
17428     $new_parents = $parents ?? [];
17429     array_push($new_parents, $this);
17430     $left_bracket = $this->left_bracket()->rewrite($rewriter, $new_parents);
17431     $members = $this->members()->rewrite($rewriter, $new_parents);
17432     $right_bracket = $this->right_bracket()->rewrite($rewriter, $new_parents);
17433     if (
17434       $left_bracket === $this->left_bracket() &&
17435       $members === $this->members() &&
17436       $right_bracket === $this->right_bracket()) {
17437       return $rewriter($this, $parents ?? []);
17438     } else {
17439       return $rewriter(new ArrayCreationExpression(
17440         $left_bracket,
17441         $members,
17442         $right_bracket), $parents ?? []);
17443     }
17444   }
17445
17446   public static function from_json(mixed $json, int $position, string $source) {
17447     $left_bracket = EditableSyntax::from_json(
17448       $json->array_creation_left_bracket, $position, $source);
17449     $position += $left_bracket->width();
17450     $members = EditableSyntax::from_json(
17451       $json->array_creation_members, $position, $source);
17452     $position += $members->width();
17453     $right_bracket = EditableSyntax::from_json(
17454       $json->array_creation_right_bracket, $position, $source);
17455     $position += $right_bracket->width();
17456     return new ArrayCreationExpression(
17457         $left_bracket,
17458         $members,
17459         $right_bracket);
17460   }
17461   public function children(): Generator<string, EditableSyntax, void> {
17462     yield $this->_left_bracket;
17463     yield $this->_members;
17464     yield $this->_right_bracket;
17465     yield break;
17466   }
17467 }
17468 final class ArrayIntrinsicExpression extends EditableSyntax {
17469   private EditableSyntax $_keyword;
17470   private EditableSyntax $_left_paren;
17471   private EditableSyntax $_members;
17472   private EditableSyntax $_right_paren;
17473   public function __construct(
17474     EditableSyntax $keyword,
17475     EditableSyntax $left_paren,
17476     EditableSyntax $members,
17477     EditableSyntax $right_paren) {
17478     parent::__construct('array_intrinsic_expression');
17479     $this->_keyword = $keyword;
17480     $this->_left_paren = $left_paren;
17481     $this->_members = $members;
17482     $this->_right_paren = $right_paren;
17483   }
17484   public function keyword(): EditableSyntax {
17485     return $this->_keyword;
17486   }
17487   public function left_paren(): EditableSyntax {
17488     return $this->_left_paren;
17489   }
17490   public function members(): EditableSyntax {
17491     return $this->_members;
17492   }
17493   public function right_paren(): EditableSyntax {
17494     return $this->_right_paren;
17495   }
17496   public function with_keyword(EditableSyntax $keyword): ArrayIntrinsicExpression {
17497     return new ArrayIntrinsicExpression(
17498       $keyword,
17499       $this->_left_paren,
17500       $this->_members,
17501       $this->_right_paren);
17502   }
17503   public function with_left_paren(EditableSyntax $left_paren): ArrayIntrinsicExpression {
17504     return new ArrayIntrinsicExpression(
17505       $this->_keyword,
17506       $left_paren,
17507       $this->_members,
17508       $this->_right_paren);
17509   }
17510   public function with_members(EditableSyntax $members): ArrayIntrinsicExpression {
17511     return new ArrayIntrinsicExpression(
17512       $this->_keyword,
17513       $this->_left_paren,
17514       $members,
17515       $this->_right_paren);
17516   }
17517   public function with_right_paren(EditableSyntax $right_paren): ArrayIntrinsicExpression {
17518     return new ArrayIntrinsicExpression(
17519       $this->_keyword,
17520       $this->_left_paren,
17521       $this->_members,
17522       $right_paren);
17523   }
17524
17525   public function rewrite(
17526     ( function
17527       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
17528     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
17529     $new_parents = $parents ?? [];
17530     array_push($new_parents, $this);
17531     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
17532     $left_paren = $this->left_paren()->rewrite($rewriter, $new_parents);
17533     $members = $this->members()->rewrite($rewriter, $new_parents);
17534     $right_paren = $this->right_paren()->rewrite($rewriter, $new_parents);
17535     if (
17536       $keyword === $this->keyword() &&
17537       $left_paren === $this->left_paren() &&
17538       $members === $this->members() &&
17539       $right_paren === $this->right_paren()) {
17540       return $rewriter($this, $parents ?? []);
17541     } else {
17542       return $rewriter(new ArrayIntrinsicExpression(
17543         $keyword,
17544         $left_paren,
17545         $members,
17546         $right_paren), $parents ?? []);
17547     }
17548   }
17549
17550   public static function from_json(mixed $json, int $position, string $source) {
17551     $keyword = EditableSyntax::from_json(
17552       $json->array_intrinsic_keyword, $position, $source);
17553     $position += $keyword->width();
17554     $left_paren = EditableSyntax::from_json(
17555       $json->array_intrinsic_left_paren, $position, $source);
17556     $position += $left_paren->width();
17557     $members = EditableSyntax::from_json(
17558       $json->array_intrinsic_members, $position, $source);
17559     $position += $members->width();
17560     $right_paren = EditableSyntax::from_json(
17561       $json->array_intrinsic_right_paren, $position, $source);
17562     $position += $right_paren->width();
17563     return new ArrayIntrinsicExpression(
17564         $keyword,
17565         $left_paren,
17566         $members,
17567         $right_paren);
17568   }
17569   public function children(): Generator<string, EditableSyntax, void> {
17570     yield $this->_keyword;
17571     yield $this->_left_paren;
17572     yield $this->_members;
17573     yield $this->_right_paren;
17574     yield break;
17575   }
17576 }
17577 final class DarrayIntrinsicExpression extends EditableSyntax {
17578   private EditableSyntax $_keyword;
17579   private EditableSyntax $_left_bracket;
17580   private EditableSyntax $_members;
17581   private EditableSyntax $_right_bracket;
17582   public function __construct(
17583     EditableSyntax $keyword,
17584     EditableSyntax $left_bracket,
17585     EditableSyntax $members,
17586     EditableSyntax $right_bracket) {
17587     parent::__construct('darray_intrinsic_expression');
17588     $this->_keyword = $keyword;
17589     $this->_left_bracket = $left_bracket;
17590     $this->_members = $members;
17591     $this->_right_bracket = $right_bracket;
17592   }
17593   public function keyword(): EditableSyntax {
17594     return $this->_keyword;
17595   }
17596   public function left_bracket(): EditableSyntax {
17597     return $this->_left_bracket;
17598   }
17599   public function members(): EditableSyntax {
17600     return $this->_members;
17601   }
17602   public function right_bracket(): EditableSyntax {
17603     return $this->_right_bracket;
17604   }
17605   public function with_keyword(EditableSyntax $keyword): DarrayIntrinsicExpression {
17606     return new DarrayIntrinsicExpression(
17607       $keyword,
17608       $this->_left_bracket,
17609       $this->_members,
17610       $this->_right_bracket);
17611   }
17612   public function with_left_bracket(EditableSyntax $left_bracket): DarrayIntrinsicExpression {
17613     return new DarrayIntrinsicExpression(
17614       $this->_keyword,
17615       $left_bracket,
17616       $this->_members,
17617       $this->_right_bracket);
17618   }
17619   public function with_members(EditableSyntax $members): DarrayIntrinsicExpression {
17620     return new DarrayIntrinsicExpression(
17621       $this->_keyword,
17622       $this->_left_bracket,
17623       $members,
17624       $this->_right_bracket);
17625   }
17626   public function with_right_bracket(EditableSyntax $right_bracket): DarrayIntrinsicExpression {
17627     return new DarrayIntrinsicExpression(
17628       $this->_keyword,
17629       $this->_left_bracket,
17630       $this->_members,
17631       $right_bracket);
17632   }
17633
17634   public function rewrite(
17635     ( function
17636       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
17637     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
17638     $new_parents = $parents ?? [];
17639     array_push($new_parents, $this);
17640     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
17641     $left_bracket = $this->left_bracket()->rewrite($rewriter, $new_parents);
17642     $members = $this->members()->rewrite($rewriter, $new_parents);
17643     $right_bracket = $this->right_bracket()->rewrite($rewriter, $new_parents);
17644     if (
17645       $keyword === $this->keyword() &&
17646       $left_bracket === $this->left_bracket() &&
17647       $members === $this->members() &&
17648       $right_bracket === $this->right_bracket()) {
17649       return $rewriter($this, $parents ?? []);
17650     } else {
17651       return $rewriter(new DarrayIntrinsicExpression(
17652         $keyword,
17653         $left_bracket,
17654         $members,
17655         $right_bracket), $parents ?? []);
17656     }
17657   }
17658
17659   public static function from_json(mixed $json, int $position, string $source) {
17660     $keyword = EditableSyntax::from_json(
17661       $json->darray_intrinsic_keyword, $position, $source);
17662     $position += $keyword->width();
17663     $left_bracket = EditableSyntax::from_json(
17664       $json->darray_intrinsic_left_bracket, $position, $source);
17665     $position += $left_bracket->width();
17666     $members = EditableSyntax::from_json(
17667       $json->darray_intrinsic_members, $position, $source);
17668     $position += $members->width();
17669     $right_bracket = EditableSyntax::from_json(
17670       $json->darray_intrinsic_right_bracket, $position, $source);
17671     $position += $right_bracket->width();
17672     return new DarrayIntrinsicExpression(
17673         $keyword,
17674         $left_bracket,
17675         $members,
17676         $right_bracket);
17677   }
17678   public function children(): Generator<string, EditableSyntax, void> {
17679     yield $this->_keyword;
17680     yield $this->_left_bracket;
17681     yield $this->_members;
17682     yield $this->_right_bracket;
17683     yield break;
17684   }
17685 }
17686 final class DictionaryIntrinsicExpression extends EditableSyntax {
17687   private EditableSyntax $_keyword;
17688   private EditableSyntax $_left_bracket;
17689   private EditableSyntax $_members;
17690   private EditableSyntax $_right_bracket;
17691   public function __construct(
17692     EditableSyntax $keyword,
17693     EditableSyntax $left_bracket,
17694     EditableSyntax $members,
17695     EditableSyntax $right_bracket) {
17696     parent::__construct('dictionary_intrinsic_expression');
17697     $this->_keyword = $keyword;
17698     $this->_left_bracket = $left_bracket;
17699     $this->_members = $members;
17700     $this->_right_bracket = $right_bracket;
17701   }
17702   public function keyword(): EditableSyntax {
17703     return $this->_keyword;
17704   }
17705   public function left_bracket(): EditableSyntax {
17706     return $this->_left_bracket;
17707   }
17708   public function members(): EditableSyntax {
17709     return $this->_members;
17710   }
17711   public function right_bracket(): EditableSyntax {
17712     return $this->_right_bracket;
17713   }
17714   public function with_keyword(EditableSyntax $keyword): DictionaryIntrinsicExpression {
17715     return new DictionaryIntrinsicExpression(
17716       $keyword,
17717       $this->_left_bracket,
17718       $this->_members,
17719       $this->_right_bracket);
17720   }
17721   public function with_left_bracket(EditableSyntax $left_bracket): DictionaryIntrinsicExpression {
17722     return new DictionaryIntrinsicExpression(
17723       $this->_keyword,
17724       $left_bracket,
17725       $this->_members,
17726       $this->_right_bracket);
17727   }
17728   public function with_members(EditableSyntax $members): DictionaryIntrinsicExpression {
17729     return new DictionaryIntrinsicExpression(
17730       $this->_keyword,
17731       $this->_left_bracket,
17732       $members,
17733       $this->_right_bracket);
17734   }
17735   public function with_right_bracket(EditableSyntax $right_bracket): DictionaryIntrinsicExpression {
17736     return new DictionaryIntrinsicExpression(
17737       $this->_keyword,
17738       $this->_left_bracket,
17739       $this->_members,
17740       $right_bracket);
17741   }
17742
17743   public function rewrite(
17744     ( function
17745       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
17746     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
17747     $new_parents = $parents ?? [];
17748     array_push($new_parents, $this);
17749     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
17750     $left_bracket = $this->left_bracket()->rewrite($rewriter, $new_parents);
17751     $members = $this->members()->rewrite($rewriter, $new_parents);
17752     $right_bracket = $this->right_bracket()->rewrite($rewriter, $new_parents);
17753     if (
17754       $keyword === $this->keyword() &&
17755       $left_bracket === $this->left_bracket() &&
17756       $members === $this->members() &&
17757       $right_bracket === $this->right_bracket()) {
17758       return $rewriter($this, $parents ?? []);
17759     } else {
17760       return $rewriter(new DictionaryIntrinsicExpression(
17761         $keyword,
17762         $left_bracket,
17763         $members,
17764         $right_bracket), $parents ?? []);
17765     }
17766   }
17767
17768   public static function from_json(mixed $json, int $position, string $source) {
17769     $keyword = EditableSyntax::from_json(
17770       $json->dictionary_intrinsic_keyword, $position, $source);
17771     $position += $keyword->width();
17772     $left_bracket = EditableSyntax::from_json(
17773       $json->dictionary_intrinsic_left_bracket, $position, $source);
17774     $position += $left_bracket->width();
17775     $members = EditableSyntax::from_json(
17776       $json->dictionary_intrinsic_members, $position, $source);
17777     $position += $members->width();
17778     $right_bracket = EditableSyntax::from_json(
17779       $json->dictionary_intrinsic_right_bracket, $position, $source);
17780     $position += $right_bracket->width();
17781     return new DictionaryIntrinsicExpression(
17782         $keyword,
17783         $left_bracket,
17784         $members,
17785         $right_bracket);
17786   }
17787   public function children(): Generator<string, EditableSyntax, void> {
17788     yield $this->_keyword;
17789     yield $this->_left_bracket;
17790     yield $this->_members;
17791     yield $this->_right_bracket;
17792     yield break;
17793   }
17794 }
17795 final class KeysetIntrinsicExpression extends EditableSyntax {
17796   private EditableSyntax $_keyword;
17797   private EditableSyntax $_left_bracket;
17798   private EditableSyntax $_members;
17799   private EditableSyntax $_right_bracket;
17800   public function __construct(
17801     EditableSyntax $keyword,
17802     EditableSyntax $left_bracket,
17803     EditableSyntax $members,
17804     EditableSyntax $right_bracket) {
17805     parent::__construct('keyset_intrinsic_expression');
17806     $this->_keyword = $keyword;
17807     $this->_left_bracket = $left_bracket;
17808     $this->_members = $members;
17809     $this->_right_bracket = $right_bracket;
17810   }
17811   public function keyword(): EditableSyntax {
17812     return $this->_keyword;
17813   }
17814   public function left_bracket(): EditableSyntax {
17815     return $this->_left_bracket;
17816   }
17817   public function members(): EditableSyntax {
17818     return $this->_members;
17819   }
17820   public function right_bracket(): EditableSyntax {
17821     return $this->_right_bracket;
17822   }
17823   public function with_keyword(EditableSyntax $keyword): KeysetIntrinsicExpression {
17824     return new KeysetIntrinsicExpression(
17825       $keyword,
17826       $this->_left_bracket,
17827       $this->_members,
17828       $this->_right_bracket);
17829   }
17830   public function with_left_bracket(EditableSyntax $left_bracket): KeysetIntrinsicExpression {
17831     return new KeysetIntrinsicExpression(
17832       $this->_keyword,
17833       $left_bracket,
17834       $this->_members,
17835       $this->_right_bracket);
17836   }
17837   public function with_members(EditableSyntax $members): KeysetIntrinsicExpression {
17838     return new KeysetIntrinsicExpression(
17839       $this->_keyword,
17840       $this->_left_bracket,
17841       $members,
17842       $this->_right_bracket);
17843   }
17844   public function with_right_bracket(EditableSyntax $right_bracket): KeysetIntrinsicExpression {
17845     return new KeysetIntrinsicExpression(
17846       $this->_keyword,
17847       $this->_left_bracket,
17848       $this->_members,
17849       $right_bracket);
17850   }
17851
17852   public function rewrite(
17853     ( function
17854       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
17855     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
17856     $new_parents = $parents ?? [];
17857     array_push($new_parents, $this);
17858     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
17859     $left_bracket = $this->left_bracket()->rewrite($rewriter, $new_parents);
17860     $members = $this->members()->rewrite($rewriter, $new_parents);
17861     $right_bracket = $this->right_bracket()->rewrite($rewriter, $new_parents);
17862     if (
17863       $keyword === $this->keyword() &&
17864       $left_bracket === $this->left_bracket() &&
17865       $members === $this->members() &&
17866       $right_bracket === $this->right_bracket()) {
17867       return $rewriter($this, $parents ?? []);
17868     } else {
17869       return $rewriter(new KeysetIntrinsicExpression(
17870         $keyword,
17871         $left_bracket,
17872         $members,
17873         $right_bracket), $parents ?? []);
17874     }
17875   }
17876
17877   public static function from_json(mixed $json, int $position, string $source) {
17878     $keyword = EditableSyntax::from_json(
17879       $json->keyset_intrinsic_keyword, $position, $source);
17880     $position += $keyword->width();
17881     $left_bracket = EditableSyntax::from_json(
17882       $json->keyset_intrinsic_left_bracket, $position, $source);
17883     $position += $left_bracket->width();
17884     $members = EditableSyntax::from_json(
17885       $json->keyset_intrinsic_members, $position, $source);
17886     $position += $members->width();
17887     $right_bracket = EditableSyntax::from_json(
17888       $json->keyset_intrinsic_right_bracket, $position, $source);
17889     $position += $right_bracket->width();
17890     return new KeysetIntrinsicExpression(
17891         $keyword,
17892         $left_bracket,
17893         $members,
17894         $right_bracket);
17895   }
17896   public function children(): Generator<string, EditableSyntax, void> {
17897     yield $this->_keyword;
17898     yield $this->_left_bracket;
17899     yield $this->_members;
17900     yield $this->_right_bracket;
17901     yield break;
17902   }
17903 }
17904 final class VarrayIntrinsicExpression extends EditableSyntax {
17905   private EditableSyntax $_keyword;
17906   private EditableSyntax $_left_bracket;
17907   private EditableSyntax $_members;
17908   private EditableSyntax $_right_bracket;
17909   public function __construct(
17910     EditableSyntax $keyword,
17911     EditableSyntax $left_bracket,
17912     EditableSyntax $members,
17913     EditableSyntax $right_bracket) {
17914     parent::__construct('varray_intrinsic_expression');
17915     $this->_keyword = $keyword;
17916     $this->_left_bracket = $left_bracket;
17917     $this->_members = $members;
17918     $this->_right_bracket = $right_bracket;
17919   }
17920   public function keyword(): EditableSyntax {
17921     return $this->_keyword;
17922   }
17923   public function left_bracket(): EditableSyntax {
17924     return $this->_left_bracket;
17925   }
17926   public function members(): EditableSyntax {
17927     return $this->_members;
17928   }
17929   public function right_bracket(): EditableSyntax {
17930     return $this->_right_bracket;
17931   }
17932   public function with_keyword(EditableSyntax $keyword): VarrayIntrinsicExpression {
17933     return new VarrayIntrinsicExpression(
17934       $keyword,
17935       $this->_left_bracket,
17936       $this->_members,
17937       $this->_right_bracket);
17938   }
17939   public function with_left_bracket(EditableSyntax $left_bracket): VarrayIntrinsicExpression {
17940     return new VarrayIntrinsicExpression(
17941       $this->_keyword,
17942       $left_bracket,
17943       $this->_members,
17944       $this->_right_bracket);
17945   }
17946   public function with_members(EditableSyntax $members): VarrayIntrinsicExpression {
17947     return new VarrayIntrinsicExpression(
17948       $this->_keyword,
17949       $this->_left_bracket,
17950       $members,
17951       $this->_right_bracket);
17952   }
17953   public function with_right_bracket(EditableSyntax $right_bracket): VarrayIntrinsicExpression {
17954     return new VarrayIntrinsicExpression(
17955       $this->_keyword,
17956       $this->_left_bracket,
17957       $this->_members,
17958       $right_bracket);
17959   }
17960
17961   public function rewrite(
17962     ( function
17963       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
17964     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
17965     $new_parents = $parents ?? [];
17966     array_push($new_parents, $this);
17967     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
17968     $left_bracket = $this->left_bracket()->rewrite($rewriter, $new_parents);
17969     $members = $this->members()->rewrite($rewriter, $new_parents);
17970     $right_bracket = $this->right_bracket()->rewrite($rewriter, $new_parents);
17971     if (
17972       $keyword === $this->keyword() &&
17973       $left_bracket === $this->left_bracket() &&
17974       $members === $this->members() &&
17975       $right_bracket === $this->right_bracket()) {
17976       return $rewriter($this, $parents ?? []);
17977     } else {
17978       return $rewriter(new VarrayIntrinsicExpression(
17979         $keyword,
17980         $left_bracket,
17981         $members,
17982         $right_bracket), $parents ?? []);
17983     }
17984   }
17985
17986   public static function from_json(mixed $json, int $position, string $source) {
17987     $keyword = EditableSyntax::from_json(
17988       $json->varray_intrinsic_keyword, $position, $source);
17989     $position += $keyword->width();
17990     $left_bracket = EditableSyntax::from_json(
17991       $json->varray_intrinsic_left_bracket, $position, $source);
17992     $position += $left_bracket->width();
17993     $members = EditableSyntax::from_json(
17994       $json->varray_intrinsic_members, $position, $source);
17995     $position += $members->width();
17996     $right_bracket = EditableSyntax::from_json(
17997       $json->varray_intrinsic_right_bracket, $position, $source);
17998     $position += $right_bracket->width();
17999     return new VarrayIntrinsicExpression(
18000         $keyword,
18001         $left_bracket,
18002         $members,
18003         $right_bracket);
18004   }
18005   public function children(): Generator<string, EditableSyntax, void> {
18006     yield $this->_keyword;
18007     yield $this->_left_bracket;
18008     yield $this->_members;
18009     yield $this->_right_bracket;
18010     yield break;
18011   }
18012 }
18013 final class VectorIntrinsicExpression extends EditableSyntax {
18014   private EditableSyntax $_keyword;
18015   private EditableSyntax $_left_bracket;
18016   private EditableSyntax $_members;
18017   private EditableSyntax $_right_bracket;
18018   public function __construct(
18019     EditableSyntax $keyword,
18020     EditableSyntax $left_bracket,
18021     EditableSyntax $members,
18022     EditableSyntax $right_bracket) {
18023     parent::__construct('vector_intrinsic_expression');
18024     $this->_keyword = $keyword;
18025     $this->_left_bracket = $left_bracket;
18026     $this->_members = $members;
18027     $this->_right_bracket = $right_bracket;
18028   }
18029   public function keyword(): EditableSyntax {
18030     return $this->_keyword;
18031   }
18032   public function left_bracket(): EditableSyntax {
18033     return $this->_left_bracket;
18034   }
18035   public function members(): EditableSyntax {
18036     return $this->_members;
18037   }
18038   public function right_bracket(): EditableSyntax {
18039     return $this->_right_bracket;
18040   }
18041   public function with_keyword(EditableSyntax $keyword): VectorIntrinsicExpression {
18042     return new VectorIntrinsicExpression(
18043       $keyword,
18044       $this->_left_bracket,
18045       $this->_members,
18046       $this->_right_bracket);
18047   }
18048   public function with_left_bracket(EditableSyntax $left_bracket): VectorIntrinsicExpression {
18049     return new VectorIntrinsicExpression(
18050       $this->_keyword,
18051       $left_bracket,
18052       $this->_members,
18053       $this->_right_bracket);
18054   }
18055   public function with_members(EditableSyntax $members): VectorIntrinsicExpression {
18056     return new VectorIntrinsicExpression(
18057       $this->_keyword,
18058       $this->_left_bracket,
18059       $members,
18060       $this->_right_bracket);
18061   }
18062   public function with_right_bracket(EditableSyntax $right_bracket): VectorIntrinsicExpression {
18063     return new VectorIntrinsicExpression(
18064       $this->_keyword,
18065       $this->_left_bracket,
18066       $this->_members,
18067       $right_bracket);
18068   }
18069
18070   public function rewrite(
18071     ( function
18072       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
18073     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
18074     $new_parents = $parents ?? [];
18075     array_push($new_parents, $this);
18076     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
18077     $left_bracket = $this->left_bracket()->rewrite($rewriter, $new_parents);
18078     $members = $this->members()->rewrite($rewriter, $new_parents);
18079     $right_bracket = $this->right_bracket()->rewrite($rewriter, $new_parents);
18080     if (
18081       $keyword === $this->keyword() &&
18082       $left_bracket === $this->left_bracket() &&
18083       $members === $this->members() &&
18084       $right_bracket === $this->right_bracket()) {
18085       return $rewriter($this, $parents ?? []);
18086     } else {
18087       return $rewriter(new VectorIntrinsicExpression(
18088         $keyword,
18089         $left_bracket,
18090         $members,
18091         $right_bracket), $parents ?? []);
18092     }
18093   }
18094
18095   public static function from_json(mixed $json, int $position, string $source) {
18096     $keyword = EditableSyntax::from_json(
18097       $json->vector_intrinsic_keyword, $position, $source);
18098     $position += $keyword->width();
18099     $left_bracket = EditableSyntax::from_json(
18100       $json->vector_intrinsic_left_bracket, $position, $source);
18101     $position += $left_bracket->width();
18102     $members = EditableSyntax::from_json(
18103       $json->vector_intrinsic_members, $position, $source);
18104     $position += $members->width();
18105     $right_bracket = EditableSyntax::from_json(
18106       $json->vector_intrinsic_right_bracket, $position, $source);
18107     $position += $right_bracket->width();
18108     return new VectorIntrinsicExpression(
18109         $keyword,
18110         $left_bracket,
18111         $members,
18112         $right_bracket);
18113   }
18114   public function children(): Generator<string, EditableSyntax, void> {
18115     yield $this->_keyword;
18116     yield $this->_left_bracket;
18117     yield $this->_members;
18118     yield $this->_right_bracket;
18119     yield break;
18120   }
18121 }
18122 final class ElementInitializer extends EditableSyntax {
18123   private EditableSyntax $_key;
18124   private EditableSyntax $_arrow;
18125   private EditableSyntax $_value;
18126   public function __construct(
18127     EditableSyntax $key,
18128     EditableSyntax $arrow,
18129     EditableSyntax $value) {
18130     parent::__construct('element_initializer');
18131     $this->_key = $key;
18132     $this->_arrow = $arrow;
18133     $this->_value = $value;
18134   }
18135   public function key(): EditableSyntax {
18136     return $this->_key;
18137   }
18138   public function arrow(): EditableSyntax {
18139     return $this->_arrow;
18140   }
18141   public function value(): EditableSyntax {
18142     return $this->_value;
18143   }
18144   public function with_key(EditableSyntax $key): ElementInitializer {
18145     return new ElementInitializer(
18146       $key,
18147       $this->_arrow,
18148       $this->_value);
18149   }
18150   public function with_arrow(EditableSyntax $arrow): ElementInitializer {
18151     return new ElementInitializer(
18152       $this->_key,
18153       $arrow,
18154       $this->_value);
18155   }
18156   public function with_value(EditableSyntax $value): ElementInitializer {
18157     return new ElementInitializer(
18158       $this->_key,
18159       $this->_arrow,
18160       $value);
18161   }
18162
18163   public function rewrite(
18164     ( function
18165       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
18166     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
18167     $new_parents = $parents ?? [];
18168     array_push($new_parents, $this);
18169     $key = $this->key()->rewrite($rewriter, $new_parents);
18170     $arrow = $this->arrow()->rewrite($rewriter, $new_parents);
18171     $value = $this->value()->rewrite($rewriter, $new_parents);
18172     if (
18173       $key === $this->key() &&
18174       $arrow === $this->arrow() &&
18175       $value === $this->value()) {
18176       return $rewriter($this, $parents ?? []);
18177     } else {
18178       return $rewriter(new ElementInitializer(
18179         $key,
18180         $arrow,
18181         $value), $parents ?? []);
18182     }
18183   }
18184
18185   public static function from_json(mixed $json, int $position, string $source) {
18186     $key = EditableSyntax::from_json(
18187       $json->element_key, $position, $source);
18188     $position += $key->width();
18189     $arrow = EditableSyntax::from_json(
18190       $json->element_arrow, $position, $source);
18191     $position += $arrow->width();
18192     $value = EditableSyntax::from_json(
18193       $json->element_value, $position, $source);
18194     $position += $value->width();
18195     return new ElementInitializer(
18196         $key,
18197         $arrow,
18198         $value);
18199   }
18200   public function children(): Generator<string, EditableSyntax, void> {
18201     yield $this->_key;
18202     yield $this->_arrow;
18203     yield $this->_value;
18204     yield break;
18205   }
18206 }
18207 final class SubscriptExpression extends EditableSyntax {
18208   private EditableSyntax $_receiver;
18209   private EditableSyntax $_left_bracket;
18210   private EditableSyntax $_index;
18211   private EditableSyntax $_right_bracket;
18212   public function __construct(
18213     EditableSyntax $receiver,
18214     EditableSyntax $left_bracket,
18215     EditableSyntax $index,
18216     EditableSyntax $right_bracket) {
18217     parent::__construct('subscript_expression');
18218     $this->_receiver = $receiver;
18219     $this->_left_bracket = $left_bracket;
18220     $this->_index = $index;
18221     $this->_right_bracket = $right_bracket;
18222   }
18223   public function receiver(): EditableSyntax {
18224     return $this->_receiver;
18225   }
18226   public function left_bracket(): EditableSyntax {
18227     return $this->_left_bracket;
18228   }
18229   public function index(): EditableSyntax {
18230     return $this->_index;
18231   }
18232   public function right_bracket(): EditableSyntax {
18233     return $this->_right_bracket;
18234   }
18235   public function with_receiver(EditableSyntax $receiver): SubscriptExpression {
18236     return new SubscriptExpression(
18237       $receiver,
18238       $this->_left_bracket,
18239       $this->_index,
18240       $this->_right_bracket);
18241   }
18242   public function with_left_bracket(EditableSyntax $left_bracket): SubscriptExpression {
18243     return new SubscriptExpression(
18244       $this->_receiver,
18245       $left_bracket,
18246       $this->_index,
18247       $this->_right_bracket);
18248   }
18249   public function with_index(EditableSyntax $index): SubscriptExpression {
18250     return new SubscriptExpression(
18251       $this->_receiver,
18252       $this->_left_bracket,
18253       $index,
18254       $this->_right_bracket);
18255   }
18256   public function with_right_bracket(EditableSyntax $right_bracket): SubscriptExpression {
18257     return new SubscriptExpression(
18258       $this->_receiver,
18259       $this->_left_bracket,
18260       $this->_index,
18261       $right_bracket);
18262   }
18263
18264   public function rewrite(
18265     ( function
18266       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
18267     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
18268     $new_parents = $parents ?? [];
18269     array_push($new_parents, $this);
18270     $receiver = $this->receiver()->rewrite($rewriter, $new_parents);
18271     $left_bracket = $this->left_bracket()->rewrite($rewriter, $new_parents);
18272     $index = $this->index()->rewrite($rewriter, $new_parents);
18273     $right_bracket = $this->right_bracket()->rewrite($rewriter, $new_parents);
18274     if (
18275       $receiver === $this->receiver() &&
18276       $left_bracket === $this->left_bracket() &&
18277       $index === $this->index() &&
18278       $right_bracket === $this->right_bracket()) {
18279       return $rewriter($this, $parents ?? []);
18280     } else {
18281       return $rewriter(new SubscriptExpression(
18282         $receiver,
18283         $left_bracket,
18284         $index,
18285         $right_bracket), $parents ?? []);
18286     }
18287   }
18288
18289   public static function from_json(mixed $json, int $position, string $source) {
18290     $receiver = EditableSyntax::from_json(
18291       $json->subscript_receiver, $position, $source);
18292     $position += $receiver->width();
18293     $left_bracket = EditableSyntax::from_json(
18294       $json->subscript_left_bracket, $position, $source);
18295     $position += $left_bracket->width();
18296     $index = EditableSyntax::from_json(
18297       $json->subscript_index, $position, $source);
18298     $position += $index->width();
18299     $right_bracket = EditableSyntax::from_json(
18300       $json->subscript_right_bracket, $position, $source);
18301     $position += $right_bracket->width();
18302     return new SubscriptExpression(
18303         $receiver,
18304         $left_bracket,
18305         $index,
18306         $right_bracket);
18307   }
18308   public function children(): Generator<string, EditableSyntax, void> {
18309     yield $this->_receiver;
18310     yield $this->_left_bracket;
18311     yield $this->_index;
18312     yield $this->_right_bracket;
18313     yield break;
18314   }
18315 }
18316 final class EmbeddedSubscriptExpression extends EditableSyntax {
18317   private EditableSyntax $_receiver;
18318   private EditableSyntax $_left_bracket;
18319   private EditableSyntax $_index;
18320   private EditableSyntax $_right_bracket;
18321   public function __construct(
18322     EditableSyntax $receiver,
18323     EditableSyntax $left_bracket,
18324     EditableSyntax $index,
18325     EditableSyntax $right_bracket) {
18326     parent::__construct('embedded_subscript_expression');
18327     $this->_receiver = $receiver;
18328     $this->_left_bracket = $left_bracket;
18329     $this->_index = $index;
18330     $this->_right_bracket = $right_bracket;
18331   }
18332   public function receiver(): EditableSyntax {
18333     return $this->_receiver;
18334   }
18335   public function left_bracket(): EditableSyntax {
18336     return $this->_left_bracket;
18337   }
18338   public function index(): EditableSyntax {
18339     return $this->_index;
18340   }
18341   public function right_bracket(): EditableSyntax {
18342     return $this->_right_bracket;
18343   }
18344   public function with_receiver(EditableSyntax $receiver): EmbeddedSubscriptExpression {
18345     return new EmbeddedSubscriptExpression(
18346       $receiver,
18347       $this->_left_bracket,
18348       $this->_index,
18349       $this->_right_bracket);
18350   }
18351   public function with_left_bracket(EditableSyntax $left_bracket): EmbeddedSubscriptExpression {
18352     return new EmbeddedSubscriptExpression(
18353       $this->_receiver,
18354       $left_bracket,
18355       $this->_index,
18356       $this->_right_bracket);
18357   }
18358   public function with_index(EditableSyntax $index): EmbeddedSubscriptExpression {
18359     return new EmbeddedSubscriptExpression(
18360       $this->_receiver,
18361       $this->_left_bracket,
18362       $index,
18363       $this->_right_bracket);
18364   }
18365   public function with_right_bracket(EditableSyntax $right_bracket): EmbeddedSubscriptExpression {
18366     return new EmbeddedSubscriptExpression(
18367       $this->_receiver,
18368       $this->_left_bracket,
18369       $this->_index,
18370       $right_bracket);
18371   }
18372
18373   public function rewrite(
18374     ( function
18375       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
18376     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
18377     $new_parents = $parents ?? [];
18378     array_push($new_parents, $this);
18379     $receiver = $this->receiver()->rewrite($rewriter, $new_parents);
18380     $left_bracket = $this->left_bracket()->rewrite($rewriter, $new_parents);
18381     $index = $this->index()->rewrite($rewriter, $new_parents);
18382     $right_bracket = $this->right_bracket()->rewrite($rewriter, $new_parents);
18383     if (
18384       $receiver === $this->receiver() &&
18385       $left_bracket === $this->left_bracket() &&
18386       $index === $this->index() &&
18387       $right_bracket === $this->right_bracket()) {
18388       return $rewriter($this, $parents ?? []);
18389     } else {
18390       return $rewriter(new EmbeddedSubscriptExpression(
18391         $receiver,
18392         $left_bracket,
18393         $index,
18394         $right_bracket), $parents ?? []);
18395     }
18396   }
18397
18398   public static function from_json(mixed $json, int $position, string $source) {
18399     $receiver = EditableSyntax::from_json(
18400       $json->embedded_subscript_receiver, $position, $source);
18401     $position += $receiver->width();
18402     $left_bracket = EditableSyntax::from_json(
18403       $json->embedded_subscript_left_bracket, $position, $source);
18404     $position += $left_bracket->width();
18405     $index = EditableSyntax::from_json(
18406       $json->embedded_subscript_index, $position, $source);
18407     $position += $index->width();
18408     $right_bracket = EditableSyntax::from_json(
18409       $json->embedded_subscript_right_bracket, $position, $source);
18410     $position += $right_bracket->width();
18411     return new EmbeddedSubscriptExpression(
18412         $receiver,
18413         $left_bracket,
18414         $index,
18415         $right_bracket);
18416   }
18417   public function children(): Generator<string, EditableSyntax, void> {
18418     yield $this->_receiver;
18419     yield $this->_left_bracket;
18420     yield $this->_index;
18421     yield $this->_right_bracket;
18422     yield break;
18423   }
18424 }
18425 final class AwaitableCreationExpression extends EditableSyntax {
18426   private EditableSyntax $_async;
18427   private EditableSyntax $_coroutine;
18428   private EditableSyntax $_compound_statement;
18429   public function __construct(
18430     EditableSyntax $async,
18431     EditableSyntax $coroutine,
18432     EditableSyntax $compound_statement) {
18433     parent::__construct('awaitable_creation_expression');
18434     $this->_async = $async;
18435     $this->_coroutine = $coroutine;
18436     $this->_compound_statement = $compound_statement;
18437   }
18438   public function async(): EditableSyntax {
18439     return $this->_async;
18440   }
18441   public function coroutine(): EditableSyntax {
18442     return $this->_coroutine;
18443   }
18444   public function compound_statement(): EditableSyntax {
18445     return $this->_compound_statement;
18446   }
18447   public function with_async(EditableSyntax $async): AwaitableCreationExpression {
18448     return new AwaitableCreationExpression(
18449       $async,
18450       $this->_coroutine,
18451       $this->_compound_statement);
18452   }
18453   public function with_coroutine(EditableSyntax $coroutine): AwaitableCreationExpression {
18454     return new AwaitableCreationExpression(
18455       $this->_async,
18456       $coroutine,
18457       $this->_compound_statement);
18458   }
18459   public function with_compound_statement(EditableSyntax $compound_statement): AwaitableCreationExpression {
18460     return new AwaitableCreationExpression(
18461       $this->_async,
18462       $this->_coroutine,
18463       $compound_statement);
18464   }
18465
18466   public function rewrite(
18467     ( function
18468       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
18469     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
18470     $new_parents = $parents ?? [];
18471     array_push($new_parents, $this);
18472     $async = $this->async()->rewrite($rewriter, $new_parents);
18473     $coroutine = $this->coroutine()->rewrite($rewriter, $new_parents);
18474     $compound_statement = $this->compound_statement()->rewrite($rewriter, $new_parents);
18475     if (
18476       $async === $this->async() &&
18477       $coroutine === $this->coroutine() &&
18478       $compound_statement === $this->compound_statement()) {
18479       return $rewriter($this, $parents ?? []);
18480     } else {
18481       return $rewriter(new AwaitableCreationExpression(
18482         $async,
18483         $coroutine,
18484         $compound_statement), $parents ?? []);
18485     }
18486   }
18487
18488   public static function from_json(mixed $json, int $position, string $source) {
18489     $async = EditableSyntax::from_json(
18490       $json->awaitable_async, $position, $source);
18491     $position += $async->width();
18492     $coroutine = EditableSyntax::from_json(
18493       $json->awaitable_coroutine, $position, $source);
18494     $position += $coroutine->width();
18495     $compound_statement = EditableSyntax::from_json(
18496       $json->awaitable_compound_statement, $position, $source);
18497     $position += $compound_statement->width();
18498     return new AwaitableCreationExpression(
18499         $async,
18500         $coroutine,
18501         $compound_statement);
18502   }
18503   public function children(): Generator<string, EditableSyntax, void> {
18504     yield $this->_async;
18505     yield $this->_coroutine;
18506     yield $this->_compound_statement;
18507     yield break;
18508   }
18509 }
18510 final class XHPChildrenDeclaration extends EditableSyntax {
18511   private EditableSyntax $_keyword;
18512   private EditableSyntax $_expression;
18513   private EditableSyntax $_semicolon;
18514   public function __construct(
18515     EditableSyntax $keyword,
18516     EditableSyntax $expression,
18517     EditableSyntax $semicolon) {
18518     parent::__construct('xhp_children_declaration');
18519     $this->_keyword = $keyword;
18520     $this->_expression = $expression;
18521     $this->_semicolon = $semicolon;
18522   }
18523   public function keyword(): EditableSyntax {
18524     return $this->_keyword;
18525   }
18526   public function expression(): EditableSyntax {
18527     return $this->_expression;
18528   }
18529   public function semicolon(): EditableSyntax {
18530     return $this->_semicolon;
18531   }
18532   public function with_keyword(EditableSyntax $keyword): XHPChildrenDeclaration {
18533     return new XHPChildrenDeclaration(
18534       $keyword,
18535       $this->_expression,
18536       $this->_semicolon);
18537   }
18538   public function with_expression(EditableSyntax $expression): XHPChildrenDeclaration {
18539     return new XHPChildrenDeclaration(
18540       $this->_keyword,
18541       $expression,
18542       $this->_semicolon);
18543   }
18544   public function with_semicolon(EditableSyntax $semicolon): XHPChildrenDeclaration {
18545     return new XHPChildrenDeclaration(
18546       $this->_keyword,
18547       $this->_expression,
18548       $semicolon);
18549   }
18550
18551   public function rewrite(
18552     ( function
18553       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
18554     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
18555     $new_parents = $parents ?? [];
18556     array_push($new_parents, $this);
18557     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
18558     $expression = $this->expression()->rewrite($rewriter, $new_parents);
18559     $semicolon = $this->semicolon()->rewrite($rewriter, $new_parents);
18560     if (
18561       $keyword === $this->keyword() &&
18562       $expression === $this->expression() &&
18563       $semicolon === $this->semicolon()) {
18564       return $rewriter($this, $parents ?? []);
18565     } else {
18566       return $rewriter(new XHPChildrenDeclaration(
18567         $keyword,
18568         $expression,
18569         $semicolon), $parents ?? []);
18570     }
18571   }
18572
18573   public static function from_json(mixed $json, int $position, string $source) {
18574     $keyword = EditableSyntax::from_json(
18575       $json->xhp_children_keyword, $position, $source);
18576     $position += $keyword->width();
18577     $expression = EditableSyntax::from_json(
18578       $json->xhp_children_expression, $position, $source);
18579     $position += $expression->width();
18580     $semicolon = EditableSyntax::from_json(
18581       $json->xhp_children_semicolon, $position, $source);
18582     $position += $semicolon->width();
18583     return new XHPChildrenDeclaration(
18584         $keyword,
18585         $expression,
18586         $semicolon);
18587   }
18588   public function children(): Generator<string, EditableSyntax, void> {
18589     yield $this->_keyword;
18590     yield $this->_expression;
18591     yield $this->_semicolon;
18592     yield break;
18593   }
18594 }
18595 final class XHPChildrenParenthesizedList extends EditableSyntax {
18596   private EditableSyntax $_left_paren;
18597   private EditableSyntax $_xhp_children;
18598   private EditableSyntax $_right_paren;
18599   public function __construct(
18600     EditableSyntax $left_paren,
18601     EditableSyntax $xhp_children,
18602     EditableSyntax $right_paren) {
18603     parent::__construct('xhp_children_parenthesized_list');
18604     $this->_left_paren = $left_paren;
18605     $this->_xhp_children = $xhp_children;
18606     $this->_right_paren = $right_paren;
18607   }
18608   public function left_paren(): EditableSyntax {
18609     return $this->_left_paren;
18610   }
18611   public function xhp_children(): EditableSyntax {
18612     return $this->_xhp_children;
18613   }
18614   public function right_paren(): EditableSyntax {
18615     return $this->_right_paren;
18616   }
18617   public function with_left_paren(EditableSyntax $left_paren): XHPChildrenParenthesizedList {
18618     return new XHPChildrenParenthesizedList(
18619       $left_paren,
18620       $this->_xhp_children,
18621       $this->_right_paren);
18622   }
18623   public function with_xhp_children(EditableSyntax $xhp_children): XHPChildrenParenthesizedList {
18624     return new XHPChildrenParenthesizedList(
18625       $this->_left_paren,
18626       $xhp_children,
18627       $this->_right_paren);
18628   }
18629   public function with_right_paren(EditableSyntax $right_paren): XHPChildrenParenthesizedList {
18630     return new XHPChildrenParenthesizedList(
18631       $this->_left_paren,
18632       $this->_xhp_children,
18633       $right_paren);
18634   }
18635
18636   public function rewrite(
18637     ( function
18638       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
18639     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
18640     $new_parents = $parents ?? [];
18641     array_push($new_parents, $this);
18642     $left_paren = $this->left_paren()->rewrite($rewriter, $new_parents);
18643     $xhp_children = $this->xhp_children()->rewrite($rewriter, $new_parents);
18644     $right_paren = $this->right_paren()->rewrite($rewriter, $new_parents);
18645     if (
18646       $left_paren === $this->left_paren() &&
18647       $xhp_children === $this->xhp_children() &&
18648       $right_paren === $this->right_paren()) {
18649       return $rewriter($this, $parents ?? []);
18650     } else {
18651       return $rewriter(new XHPChildrenParenthesizedList(
18652         $left_paren,
18653         $xhp_children,
18654         $right_paren), $parents ?? []);
18655     }
18656   }
18657
18658   public static function from_json(mixed $json, int $position, string $source) {
18659     $left_paren = EditableSyntax::from_json(
18660       $json->xhp_children_list_left_paren, $position, $source);
18661     $position += $left_paren->width();
18662     $xhp_children = EditableSyntax::from_json(
18663       $json->xhp_children_list_xhp_children, $position, $source);
18664     $position += $xhp_children->width();
18665     $right_paren = EditableSyntax::from_json(
18666       $json->xhp_children_list_right_paren, $position, $source);
18667     $position += $right_paren->width();
18668     return new XHPChildrenParenthesizedList(
18669         $left_paren,
18670         $xhp_children,
18671         $right_paren);
18672   }
18673   public function children(): Generator<string, EditableSyntax, void> {
18674     yield $this->_left_paren;
18675     yield $this->_xhp_children;
18676     yield $this->_right_paren;
18677     yield break;
18678   }
18679 }
18680 final class XHPCategoryDeclaration extends EditableSyntax {
18681   private EditableSyntax $_keyword;
18682   private EditableSyntax $_categories;
18683   private EditableSyntax $_semicolon;
18684   public function __construct(
18685     EditableSyntax $keyword,
18686     EditableSyntax $categories,
18687     EditableSyntax $semicolon) {
18688     parent::__construct('xhp_category_declaration');
18689     $this->_keyword = $keyword;
18690     $this->_categories = $categories;
18691     $this->_semicolon = $semicolon;
18692   }
18693   public function keyword(): EditableSyntax {
18694     return $this->_keyword;
18695   }
18696   public function categories(): EditableSyntax {
18697     return $this->_categories;
18698   }
18699   public function semicolon(): EditableSyntax {
18700     return $this->_semicolon;
18701   }
18702   public function with_keyword(EditableSyntax $keyword): XHPCategoryDeclaration {
18703     return new XHPCategoryDeclaration(
18704       $keyword,
18705       $this->_categories,
18706       $this->_semicolon);
18707   }
18708   public function with_categories(EditableSyntax $categories): XHPCategoryDeclaration {
18709     return new XHPCategoryDeclaration(
18710       $this->_keyword,
18711       $categories,
18712       $this->_semicolon);
18713   }
18714   public function with_semicolon(EditableSyntax $semicolon): XHPCategoryDeclaration {
18715     return new XHPCategoryDeclaration(
18716       $this->_keyword,
18717       $this->_categories,
18718       $semicolon);
18719   }
18720
18721   public function rewrite(
18722     ( function
18723       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
18724     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
18725     $new_parents = $parents ?? [];
18726     array_push($new_parents, $this);
18727     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
18728     $categories = $this->categories()->rewrite($rewriter, $new_parents);
18729     $semicolon = $this->semicolon()->rewrite($rewriter, $new_parents);
18730     if (
18731       $keyword === $this->keyword() &&
18732       $categories === $this->categories() &&
18733       $semicolon === $this->semicolon()) {
18734       return $rewriter($this, $parents ?? []);
18735     } else {
18736       return $rewriter(new XHPCategoryDeclaration(
18737         $keyword,
18738         $categories,
18739         $semicolon), $parents ?? []);
18740     }
18741   }
18742
18743   public static function from_json(mixed $json, int $position, string $source) {
18744     $keyword = EditableSyntax::from_json(
18745       $json->xhp_category_keyword, $position, $source);
18746     $position += $keyword->width();
18747     $categories = EditableSyntax::from_json(
18748       $json->xhp_category_categories, $position, $source);
18749     $position += $categories->width();
18750     $semicolon = EditableSyntax::from_json(
18751       $json->xhp_category_semicolon, $position, $source);
18752     $position += $semicolon->width();
18753     return new XHPCategoryDeclaration(
18754         $keyword,
18755         $categories,
18756         $semicolon);
18757   }
18758   public function children(): Generator<string, EditableSyntax, void> {
18759     yield $this->_keyword;
18760     yield $this->_categories;
18761     yield $this->_semicolon;
18762     yield break;
18763   }
18764 }
18765 final class XHPEnumType extends EditableSyntax {
18766   private EditableSyntax $_optional;
18767   private EditableSyntax $_keyword;
18768   private EditableSyntax $_left_brace;
18769   private EditableSyntax $_values;
18770   private EditableSyntax $_right_brace;
18771   public function __construct(
18772     EditableSyntax $optional,
18773     EditableSyntax $keyword,
18774     EditableSyntax $left_brace,
18775     EditableSyntax $values,
18776     EditableSyntax $right_brace) {
18777     parent::__construct('xhp_enum_type');
18778     $this->_optional = $optional;
18779     $this->_keyword = $keyword;
18780     $this->_left_brace = $left_brace;
18781     $this->_values = $values;
18782     $this->_right_brace = $right_brace;
18783   }
18784   public function optional(): EditableSyntax {
18785     return $this->_optional;
18786   }
18787   public function keyword(): EditableSyntax {
18788     return $this->_keyword;
18789   }
18790   public function left_brace(): EditableSyntax {
18791     return $this->_left_brace;
18792   }
18793   public function values(): EditableSyntax {
18794     return $this->_values;
18795   }
18796   public function right_brace(): EditableSyntax {
18797     return $this->_right_brace;
18798   }
18799   public function with_optional(EditableSyntax $optional): XHPEnumType {
18800     return new XHPEnumType(
18801       $optional,
18802       $this->_keyword,
18803       $this->_left_brace,
18804       $this->_values,
18805       $this->_right_brace);
18806   }
18807   public function with_keyword(EditableSyntax $keyword): XHPEnumType {
18808     return new XHPEnumType(
18809       $this->_optional,
18810       $keyword,
18811       $this->_left_brace,
18812       $this->_values,
18813       $this->_right_brace);
18814   }
18815   public function with_left_brace(EditableSyntax $left_brace): XHPEnumType {
18816     return new XHPEnumType(
18817       $this->_optional,
18818       $this->_keyword,
18819       $left_brace,
18820       $this->_values,
18821       $this->_right_brace);
18822   }
18823   public function with_values(EditableSyntax $values): XHPEnumType {
18824     return new XHPEnumType(
18825       $this->_optional,
18826       $this->_keyword,
18827       $this->_left_brace,
18828       $values,
18829       $this->_right_brace);
18830   }
18831   public function with_right_brace(EditableSyntax $right_brace): XHPEnumType {
18832     return new XHPEnumType(
18833       $this->_optional,
18834       $this->_keyword,
18835       $this->_left_brace,
18836       $this->_values,
18837       $right_brace);
18838   }
18839
18840   public function rewrite(
18841     ( function
18842       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
18843     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
18844     $new_parents = $parents ?? [];
18845     array_push($new_parents, $this);
18846     $optional = $this->optional()->rewrite($rewriter, $new_parents);
18847     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
18848     $left_brace = $this->left_brace()->rewrite($rewriter, $new_parents);
18849     $values = $this->values()->rewrite($rewriter, $new_parents);
18850     $right_brace = $this->right_brace()->rewrite($rewriter, $new_parents);
18851     if (
18852       $optional === $this->optional() &&
18853       $keyword === $this->keyword() &&
18854       $left_brace === $this->left_brace() &&
18855       $values === $this->values() &&
18856       $right_brace === $this->right_brace()) {
18857       return $rewriter($this, $parents ?? []);
18858     } else {
18859       return $rewriter(new XHPEnumType(
18860         $optional,
18861         $keyword,
18862         $left_brace,
18863         $values,
18864         $right_brace), $parents ?? []);
18865     }
18866   }
18867
18868   public static function from_json(mixed $json, int $position, string $source) {
18869     $optional = EditableSyntax::from_json(
18870       $json->xhp_enum_optional, $position, $source);
18871     $position += $optional->width();
18872     $keyword = EditableSyntax::from_json(
18873       $json->xhp_enum_keyword, $position, $source);
18874     $position += $keyword->width();
18875     $left_brace = EditableSyntax::from_json(
18876       $json->xhp_enum_left_brace, $position, $source);
18877     $position += $left_brace->width();
18878     $values = EditableSyntax::from_json(
18879       $json->xhp_enum_values, $position, $source);
18880     $position += $values->width();
18881     $right_brace = EditableSyntax::from_json(
18882       $json->xhp_enum_right_brace, $position, $source);
18883     $position += $right_brace->width();
18884     return new XHPEnumType(
18885         $optional,
18886         $keyword,
18887         $left_brace,
18888         $values,
18889         $right_brace);
18890   }
18891   public function children(): Generator<string, EditableSyntax, void> {
18892     yield $this->_optional;
18893     yield $this->_keyword;
18894     yield $this->_left_brace;
18895     yield $this->_values;
18896     yield $this->_right_brace;
18897     yield break;
18898   }
18899 }
18900 final class XHPRequired extends EditableSyntax {
18901   private EditableSyntax $_at;
18902   private EditableSyntax $_keyword;
18903   public function __construct(
18904     EditableSyntax $at,
18905     EditableSyntax $keyword) {
18906     parent::__construct('xhp_required');
18907     $this->_at = $at;
18908     $this->_keyword = $keyword;
18909   }
18910   public function at(): EditableSyntax {
18911     return $this->_at;
18912   }
18913   public function keyword(): EditableSyntax {
18914     return $this->_keyword;
18915   }
18916   public function with_at(EditableSyntax $at): XHPRequired {
18917     return new XHPRequired(
18918       $at,
18919       $this->_keyword);
18920   }
18921   public function with_keyword(EditableSyntax $keyword): XHPRequired {
18922     return new XHPRequired(
18923       $this->_at,
18924       $keyword);
18925   }
18926
18927   public function rewrite(
18928     ( function
18929       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
18930     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
18931     $new_parents = $parents ?? [];
18932     array_push($new_parents, $this);
18933     $at = $this->at()->rewrite($rewriter, $new_parents);
18934     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
18935     if (
18936       $at === $this->at() &&
18937       $keyword === $this->keyword()) {
18938       return $rewriter($this, $parents ?? []);
18939     } else {
18940       return $rewriter(new XHPRequired(
18941         $at,
18942         $keyword), $parents ?? []);
18943     }
18944   }
18945
18946   public static function from_json(mixed $json, int $position, string $source) {
18947     $at = EditableSyntax::from_json(
18948       $json->xhp_required_at, $position, $source);
18949     $position += $at->width();
18950     $keyword = EditableSyntax::from_json(
18951       $json->xhp_required_keyword, $position, $source);
18952     $position += $keyword->width();
18953     return new XHPRequired(
18954         $at,
18955         $keyword);
18956   }
18957   public function children(): Generator<string, EditableSyntax, void> {
18958     yield $this->_at;
18959     yield $this->_keyword;
18960     yield break;
18961   }
18962 }
18963 final class XHPClassAttributeDeclaration extends EditableSyntax {
18964   private EditableSyntax $_keyword;
18965   private EditableSyntax $_attributes;
18966   private EditableSyntax $_semicolon;
18967   public function __construct(
18968     EditableSyntax $keyword,
18969     EditableSyntax $attributes,
18970     EditableSyntax $semicolon) {
18971     parent::__construct('xhp_class_attribute_declaration');
18972     $this->_keyword = $keyword;
18973     $this->_attributes = $attributes;
18974     $this->_semicolon = $semicolon;
18975   }
18976   public function keyword(): EditableSyntax {
18977     return $this->_keyword;
18978   }
18979   public function attributes(): EditableSyntax {
18980     return $this->_attributes;
18981   }
18982   public function semicolon(): EditableSyntax {
18983     return $this->_semicolon;
18984   }
18985   public function with_keyword(EditableSyntax $keyword): XHPClassAttributeDeclaration {
18986     return new XHPClassAttributeDeclaration(
18987       $keyword,
18988       $this->_attributes,
18989       $this->_semicolon);
18990   }
18991   public function with_attributes(EditableSyntax $attributes): XHPClassAttributeDeclaration {
18992     return new XHPClassAttributeDeclaration(
18993       $this->_keyword,
18994       $attributes,
18995       $this->_semicolon);
18996   }
18997   public function with_semicolon(EditableSyntax $semicolon): XHPClassAttributeDeclaration {
18998     return new XHPClassAttributeDeclaration(
18999       $this->_keyword,
19000       $this->_attributes,
19001       $semicolon);
19002   }
19003
19004   public function rewrite(
19005     ( function
19006       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
19007     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
19008     $new_parents = $parents ?? [];
19009     array_push($new_parents, $this);
19010     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
19011     $attributes = $this->attributes()->rewrite($rewriter, $new_parents);
19012     $semicolon = $this->semicolon()->rewrite($rewriter, $new_parents);
19013     if (
19014       $keyword === $this->keyword() &&
19015       $attributes === $this->attributes() &&
19016       $semicolon === $this->semicolon()) {
19017       return $rewriter($this, $parents ?? []);
19018     } else {
19019       return $rewriter(new XHPClassAttributeDeclaration(
19020         $keyword,
19021         $attributes,
19022         $semicolon), $parents ?? []);
19023     }
19024   }
19025
19026   public static function from_json(mixed $json, int $position, string $source) {
19027     $keyword = EditableSyntax::from_json(
19028       $json->xhp_attribute_keyword, $position, $source);
19029     $position += $keyword->width();
19030     $attributes = EditableSyntax::from_json(
19031       $json->xhp_attribute_attributes, $position, $source);
19032     $position += $attributes->width();
19033     $semicolon = EditableSyntax::from_json(
19034       $json->xhp_attribute_semicolon, $position, $source);
19035     $position += $semicolon->width();
19036     return new XHPClassAttributeDeclaration(
19037         $keyword,
19038         $attributes,
19039         $semicolon);
19040   }
19041   public function children(): Generator<string, EditableSyntax, void> {
19042     yield $this->_keyword;
19043     yield $this->_attributes;
19044     yield $this->_semicolon;
19045     yield break;
19046   }
19047 }
19048 final class XHPClassAttribute extends EditableSyntax {
19049   private EditableSyntax $_type;
19050   private EditableSyntax $_name;
19051   private EditableSyntax $_initializer;
19052   private EditableSyntax $_required;
19053   public function __construct(
19054     EditableSyntax $type,
19055     EditableSyntax $name,
19056     EditableSyntax $initializer,
19057     EditableSyntax $required) {
19058     parent::__construct('xhp_class_attribute');
19059     $this->_type = $type;
19060     $this->_name = $name;
19061     $this->_initializer = $initializer;
19062     $this->_required = $required;
19063   }
19064   public function type(): EditableSyntax {
19065     return $this->_type;
19066   }
19067   public function name(): EditableSyntax {
19068     return $this->_name;
19069   }
19070   public function initializer(): EditableSyntax {
19071     return $this->_initializer;
19072   }
19073   public function required(): EditableSyntax {
19074     return $this->_required;
19075   }
19076   public function with_type(EditableSyntax $type): XHPClassAttribute {
19077     return new XHPClassAttribute(
19078       $type,
19079       $this->_name,
19080       $this->_initializer,
19081       $this->_required);
19082   }
19083   public function with_name(EditableSyntax $name): XHPClassAttribute {
19084     return new XHPClassAttribute(
19085       $this->_type,
19086       $name,
19087       $this->_initializer,
19088       $this->_required);
19089   }
19090   public function with_initializer(EditableSyntax $initializer): XHPClassAttribute {
19091     return new XHPClassAttribute(
19092       $this->_type,
19093       $this->_name,
19094       $initializer,
19095       $this->_required);
19096   }
19097   public function with_required(EditableSyntax $required): XHPClassAttribute {
19098     return new XHPClassAttribute(
19099       $this->_type,
19100       $this->_name,
19101       $this->_initializer,
19102       $required);
19103   }
19104
19105   public function rewrite(
19106     ( function
19107       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
19108     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
19109     $new_parents = $parents ?? [];
19110     array_push($new_parents, $this);
19111     $type = $this->type()->rewrite($rewriter, $new_parents);
19112     $name = $this->name()->rewrite($rewriter, $new_parents);
19113     $initializer = $this->initializer()->rewrite($rewriter, $new_parents);
19114     $required = $this->required()->rewrite($rewriter, $new_parents);
19115     if (
19116       $type === $this->type() &&
19117       $name === $this->name() &&
19118       $initializer === $this->initializer() &&
19119       $required === $this->required()) {
19120       return $rewriter($this, $parents ?? []);
19121     } else {
19122       return $rewriter(new XHPClassAttribute(
19123         $type,
19124         $name,
19125         $initializer,
19126         $required), $parents ?? []);
19127     }
19128   }
19129
19130   public static function from_json(mixed $json, int $position, string $source) {
19131     $type = EditableSyntax::from_json(
19132       $json->xhp_attribute_decl_type, $position, $source);
19133     $position += $type->width();
19134     $name = EditableSyntax::from_json(
19135       $json->xhp_attribute_decl_name, $position, $source);
19136     $position += $name->width();
19137     $initializer = EditableSyntax::from_json(
19138       $json->xhp_attribute_decl_initializer, $position, $source);
19139     $position += $initializer->width();
19140     $required = EditableSyntax::from_json(
19141       $json->xhp_attribute_decl_required, $position, $source);
19142     $position += $required->width();
19143     return new XHPClassAttribute(
19144         $type,
19145         $name,
19146         $initializer,
19147         $required);
19148   }
19149   public function children(): Generator<string, EditableSyntax, void> {
19150     yield $this->_type;
19151     yield $this->_name;
19152     yield $this->_initializer;
19153     yield $this->_required;
19154     yield break;
19155   }
19156 }
19157 final class XHPSimpleClassAttribute extends EditableSyntax {
19158   private EditableSyntax $_type;
19159   public function __construct(
19160     EditableSyntax $type) {
19161     parent::__construct('xhp_simple_class_attribute');
19162     $this->_type = $type;
19163   }
19164   public function type(): EditableSyntax {
19165     return $this->_type;
19166   }
19167   public function with_type(EditableSyntax $type): XHPSimpleClassAttribute {
19168     return new XHPSimpleClassAttribute(
19169       $type);
19170   }
19171
19172   public function rewrite(
19173     ( function
19174       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
19175     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
19176     $new_parents = $parents ?? [];
19177     array_push($new_parents, $this);
19178     $type = $this->type()->rewrite($rewriter, $new_parents);
19179     if (
19180       $type === $this->type()) {
19181       return $rewriter($this, $parents ?? []);
19182     } else {
19183       return $rewriter(new XHPSimpleClassAttribute(
19184         $type), $parents ?? []);
19185     }
19186   }
19187
19188   public static function from_json(mixed $json, int $position, string $source) {
19189     $type = EditableSyntax::from_json(
19190       $json->xhp_simple_class_attribute_type, $position, $source);
19191     $position += $type->width();
19192     return new XHPSimpleClassAttribute(
19193         $type);
19194   }
19195   public function children(): Generator<string, EditableSyntax, void> {
19196     yield $this->_type;
19197     yield break;
19198   }
19199 }
19200 final class XHPSimpleAttribute extends EditableSyntax {
19201   private EditableSyntax $_name;
19202   private EditableSyntax $_equal;
19203   private EditableSyntax $_expression;
19204   public function __construct(
19205     EditableSyntax $name,
19206     EditableSyntax $equal,
19207     EditableSyntax $expression) {
19208     parent::__construct('xhp_simple_attribute');
19209     $this->_name = $name;
19210     $this->_equal = $equal;
19211     $this->_expression = $expression;
19212   }
19213   public function name(): EditableSyntax {
19214     return $this->_name;
19215   }
19216   public function equal(): EditableSyntax {
19217     return $this->_equal;
19218   }
19219   public function expression(): EditableSyntax {
19220     return $this->_expression;
19221   }
19222   public function with_name(EditableSyntax $name): XHPSimpleAttribute {
19223     return new XHPSimpleAttribute(
19224       $name,
19225       $this->_equal,
19226       $this->_expression);
19227   }
19228   public function with_equal(EditableSyntax $equal): XHPSimpleAttribute {
19229     return new XHPSimpleAttribute(
19230       $this->_name,
19231       $equal,
19232       $this->_expression);
19233   }
19234   public function with_expression(EditableSyntax $expression): XHPSimpleAttribute {
19235     return new XHPSimpleAttribute(
19236       $this->_name,
19237       $this->_equal,
19238       $expression);
19239   }
19240
19241   public function rewrite(
19242     ( function
19243       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
19244     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
19245     $new_parents = $parents ?? [];
19246     array_push($new_parents, $this);
19247     $name = $this->name()->rewrite($rewriter, $new_parents);
19248     $equal = $this->equal()->rewrite($rewriter, $new_parents);
19249     $expression = $this->expression()->rewrite($rewriter, $new_parents);
19250     if (
19251       $name === $this->name() &&
19252       $equal === $this->equal() &&
19253       $expression === $this->expression()) {
19254       return $rewriter($this, $parents ?? []);
19255     } else {
19256       return $rewriter(new XHPSimpleAttribute(
19257         $name,
19258         $equal,
19259         $expression), $parents ?? []);
19260     }
19261   }
19262
19263   public static function from_json(mixed $json, int $position, string $source) {
19264     $name = EditableSyntax::from_json(
19265       $json->xhp_simple_attribute_name, $position, $source);
19266     $position += $name->width();
19267     $equal = EditableSyntax::from_json(
19268       $json->xhp_simple_attribute_equal, $position, $source);
19269     $position += $equal->width();
19270     $expression = EditableSyntax::from_json(
19271       $json->xhp_simple_attribute_expression, $position, $source);
19272     $position += $expression->width();
19273     return new XHPSimpleAttribute(
19274         $name,
19275         $equal,
19276         $expression);
19277   }
19278   public function children(): Generator<string, EditableSyntax, void> {
19279     yield $this->_name;
19280     yield $this->_equal;
19281     yield $this->_expression;
19282     yield break;
19283   }
19284 }
19285 final class XHPSpreadAttribute extends EditableSyntax {
19286   private EditableSyntax $_left_brace;
19287   private EditableSyntax $_spread_operator;
19288   private EditableSyntax $_expression;
19289   private EditableSyntax $_right_brace;
19290   public function __construct(
19291     EditableSyntax $left_brace,
19292     EditableSyntax $spread_operator,
19293     EditableSyntax $expression,
19294     EditableSyntax $right_brace) {
19295     parent::__construct('xhp_spread_attribute');
19296     $this->_left_brace = $left_brace;
19297     $this->_spread_operator = $spread_operator;
19298     $this->_expression = $expression;
19299     $this->_right_brace = $right_brace;
19300   }
19301   public function left_brace(): EditableSyntax {
19302     return $this->_left_brace;
19303   }
19304   public function spread_operator(): EditableSyntax {
19305     return $this->_spread_operator;
19306   }
19307   public function expression(): EditableSyntax {
19308     return $this->_expression;
19309   }
19310   public function right_brace(): EditableSyntax {
19311     return $this->_right_brace;
19312   }
19313   public function with_left_brace(EditableSyntax $left_brace): XHPSpreadAttribute {
19314     return new XHPSpreadAttribute(
19315       $left_brace,
19316       $this->_spread_operator,
19317       $this->_expression,
19318       $this->_right_brace);
19319   }
19320   public function with_spread_operator(EditableSyntax $spread_operator): XHPSpreadAttribute {
19321     return new XHPSpreadAttribute(
19322       $this->_left_brace,
19323       $spread_operator,
19324       $this->_expression,
19325       $this->_right_brace);
19326   }
19327   public function with_expression(EditableSyntax $expression): XHPSpreadAttribute {
19328     return new XHPSpreadAttribute(
19329       $this->_left_brace,
19330       $this->_spread_operator,
19331       $expression,
19332       $this->_right_brace);
19333   }
19334   public function with_right_brace(EditableSyntax $right_brace): XHPSpreadAttribute {
19335     return new XHPSpreadAttribute(
19336       $this->_left_brace,
19337       $this->_spread_operator,
19338       $this->_expression,
19339       $right_brace);
19340   }
19341
19342   public function rewrite(
19343     ( function
19344       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
19345     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
19346     $new_parents = $parents ?? [];
19347     array_push($new_parents, $this);
19348     $left_brace = $this->left_brace()->rewrite($rewriter, $new_parents);
19349     $spread_operator = $this->spread_operator()->rewrite($rewriter, $new_parents);
19350     $expression = $this->expression()->rewrite($rewriter, $new_parents);
19351     $right_brace = $this->right_brace()->rewrite($rewriter, $new_parents);
19352     if (
19353       $left_brace === $this->left_brace() &&
19354       $spread_operator === $this->spread_operator() &&
19355       $expression === $this->expression() &&
19356       $right_brace === $this->right_brace()) {
19357       return $rewriter($this, $parents ?? []);
19358     } else {
19359       return $rewriter(new XHPSpreadAttribute(
19360         $left_brace,
19361         $spread_operator,
19362         $expression,
19363         $right_brace), $parents ?? []);
19364     }
19365   }
19366
19367   public static function from_json(mixed $json, int $position, string $source) {
19368     $left_brace = EditableSyntax::from_json(
19369       $json->xhp_spread_attribute_left_brace, $position, $source);
19370     $position += $left_brace->width();
19371     $spread_operator = EditableSyntax::from_json(
19372       $json->xhp_spread_attribute_spread_operator, $position, $source);
19373     $position += $spread_operator->width();
19374     $expression = EditableSyntax::from_json(
19375       $json->xhp_spread_attribute_expression, $position, $source);
19376     $position += $expression->width();
19377     $right_brace = EditableSyntax::from_json(
19378       $json->xhp_spread_attribute_right_brace, $position, $source);
19379     $position += $right_brace->width();
19380     return new XHPSpreadAttribute(
19381         $left_brace,
19382         $spread_operator,
19383         $expression,
19384         $right_brace);
19385   }
19386   public function children(): Generator<string, EditableSyntax, void> {
19387     yield $this->_left_brace;
19388     yield $this->_spread_operator;
19389     yield $this->_expression;
19390     yield $this->_right_brace;
19391     yield break;
19392   }
19393 }
19394 final class XHPOpen extends EditableSyntax {
19395   private EditableSyntax $_left_angle;
19396   private EditableSyntax $_name;
19397   private EditableSyntax $_attributes;
19398   private EditableSyntax $_right_angle;
19399   public function __construct(
19400     EditableSyntax $left_angle,
19401     EditableSyntax $name,
19402     EditableSyntax $attributes,
19403     EditableSyntax $right_angle) {
19404     parent::__construct('xhp_open');
19405     $this->_left_angle = $left_angle;
19406     $this->_name = $name;
19407     $this->_attributes = $attributes;
19408     $this->_right_angle = $right_angle;
19409   }
19410   public function left_angle(): EditableSyntax {
19411     return $this->_left_angle;
19412   }
19413   public function name(): EditableSyntax {
19414     return $this->_name;
19415   }
19416   public function attributes(): EditableSyntax {
19417     return $this->_attributes;
19418   }
19419   public function right_angle(): EditableSyntax {
19420     return $this->_right_angle;
19421   }
19422   public function with_left_angle(EditableSyntax $left_angle): XHPOpen {
19423     return new XHPOpen(
19424       $left_angle,
19425       $this->_name,
19426       $this->_attributes,
19427       $this->_right_angle);
19428   }
19429   public function with_name(EditableSyntax $name): XHPOpen {
19430     return new XHPOpen(
19431       $this->_left_angle,
19432       $name,
19433       $this->_attributes,
19434       $this->_right_angle);
19435   }
19436   public function with_attributes(EditableSyntax $attributes): XHPOpen {
19437     return new XHPOpen(
19438       $this->_left_angle,
19439       $this->_name,
19440       $attributes,
19441       $this->_right_angle);
19442   }
19443   public function with_right_angle(EditableSyntax $right_angle): XHPOpen {
19444     return new XHPOpen(
19445       $this->_left_angle,
19446       $this->_name,
19447       $this->_attributes,
19448       $right_angle);
19449   }
19450
19451   public function rewrite(
19452     ( function
19453       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
19454     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
19455     $new_parents = $parents ?? [];
19456     array_push($new_parents, $this);
19457     $left_angle = $this->left_angle()->rewrite($rewriter, $new_parents);
19458     $name = $this->name()->rewrite($rewriter, $new_parents);
19459     $attributes = $this->attributes()->rewrite($rewriter, $new_parents);
19460     $right_angle = $this->right_angle()->rewrite($rewriter, $new_parents);
19461     if (
19462       $left_angle === $this->left_angle() &&
19463       $name === $this->name() &&
19464       $attributes === $this->attributes() &&
19465       $right_angle === $this->right_angle()) {
19466       return $rewriter($this, $parents ?? []);
19467     } else {
19468       return $rewriter(new XHPOpen(
19469         $left_angle,
19470         $name,
19471         $attributes,
19472         $right_angle), $parents ?? []);
19473     }
19474   }
19475
19476   public static function from_json(mixed $json, int $position, string $source) {
19477     $left_angle = EditableSyntax::from_json(
19478       $json->xhp_open_left_angle, $position, $source);
19479     $position += $left_angle->width();
19480     $name = EditableSyntax::from_json(
19481       $json->xhp_open_name, $position, $source);
19482     $position += $name->width();
19483     $attributes = EditableSyntax::from_json(
19484       $json->xhp_open_attributes, $position, $source);
19485     $position += $attributes->width();
19486     $right_angle = EditableSyntax::from_json(
19487       $json->xhp_open_right_angle, $position, $source);
19488     $position += $right_angle->width();
19489     return new XHPOpen(
19490         $left_angle,
19491         $name,
19492         $attributes,
19493         $right_angle);
19494   }
19495   public function children(): Generator<string, EditableSyntax, void> {
19496     yield $this->_left_angle;
19497     yield $this->_name;
19498     yield $this->_attributes;
19499     yield $this->_right_angle;
19500     yield break;
19501   }
19502 }
19503 final class XHPExpression extends EditableSyntax {
19504   private EditableSyntax $_open;
19505   private EditableSyntax $_body;
19506   private EditableSyntax $_close;
19507   public function __construct(
19508     EditableSyntax $open,
19509     EditableSyntax $body,
19510     EditableSyntax $close) {
19511     parent::__construct('xhp_expression');
19512     $this->_open = $open;
19513     $this->_body = $body;
19514     $this->_close = $close;
19515   }
19516   public function open(): EditableSyntax {
19517     return $this->_open;
19518   }
19519   public function body(): EditableSyntax {
19520     return $this->_body;
19521   }
19522   public function close(): EditableSyntax {
19523     return $this->_close;
19524   }
19525   public function with_open(EditableSyntax $open): XHPExpression {
19526     return new XHPExpression(
19527       $open,
19528       $this->_body,
19529       $this->_close);
19530   }
19531   public function with_body(EditableSyntax $body): XHPExpression {
19532     return new XHPExpression(
19533       $this->_open,
19534       $body,
19535       $this->_close);
19536   }
19537   public function with_close(EditableSyntax $close): XHPExpression {
19538     return new XHPExpression(
19539       $this->_open,
19540       $this->_body,
19541       $close);
19542   }
19543
19544   public function rewrite(
19545     ( function
19546       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
19547     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
19548     $new_parents = $parents ?? [];
19549     array_push($new_parents, $this);
19550     $open = $this->open()->rewrite($rewriter, $new_parents);
19551     $body = $this->body()->rewrite($rewriter, $new_parents);
19552     $close = $this->close()->rewrite($rewriter, $new_parents);
19553     if (
19554       $open === $this->open() &&
19555       $body === $this->body() &&
19556       $close === $this->close()) {
19557       return $rewriter($this, $parents ?? []);
19558     } else {
19559       return $rewriter(new XHPExpression(
19560         $open,
19561         $body,
19562         $close), $parents ?? []);
19563     }
19564   }
19565
19566   public static function from_json(mixed $json, int $position, string $source) {
19567     $open = EditableSyntax::from_json(
19568       $json->xhp_open, $position, $source);
19569     $position += $open->width();
19570     $body = EditableSyntax::from_json(
19571       $json->xhp_body, $position, $source);
19572     $position += $body->width();
19573     $close = EditableSyntax::from_json(
19574       $json->xhp_close, $position, $source);
19575     $position += $close->width();
19576     return new XHPExpression(
19577         $open,
19578         $body,
19579         $close);
19580   }
19581   public function children(): Generator<string, EditableSyntax, void> {
19582     yield $this->_open;
19583     yield $this->_body;
19584     yield $this->_close;
19585     yield break;
19586   }
19587 }
19588 final class XHPClose extends EditableSyntax {
19589   private EditableSyntax $_left_angle;
19590   private EditableSyntax $_name;
19591   private EditableSyntax $_right_angle;
19592   public function __construct(
19593     EditableSyntax $left_angle,
19594     EditableSyntax $name,
19595     EditableSyntax $right_angle) {
19596     parent::__construct('xhp_close');
19597     $this->_left_angle = $left_angle;
19598     $this->_name = $name;
19599     $this->_right_angle = $right_angle;
19600   }
19601   public function left_angle(): EditableSyntax {
19602     return $this->_left_angle;
19603   }
19604   public function name(): EditableSyntax {
19605     return $this->_name;
19606   }
19607   public function right_angle(): EditableSyntax {
19608     return $this->_right_angle;
19609   }
19610   public function with_left_angle(EditableSyntax $left_angle): XHPClose {
19611     return new XHPClose(
19612       $left_angle,
19613       $this->_name,
19614       $this->_right_angle);
19615   }
19616   public function with_name(EditableSyntax $name): XHPClose {
19617     return new XHPClose(
19618       $this->_left_angle,
19619       $name,
19620       $this->_right_angle);
19621   }
19622   public function with_right_angle(EditableSyntax $right_angle): XHPClose {
19623     return new XHPClose(
19624       $this->_left_angle,
19625       $this->_name,
19626       $right_angle);
19627   }
19628
19629   public function rewrite(
19630     ( function
19631       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
19632     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
19633     $new_parents = $parents ?? [];
19634     array_push($new_parents, $this);
19635     $left_angle = $this->left_angle()->rewrite($rewriter, $new_parents);
19636     $name = $this->name()->rewrite($rewriter, $new_parents);
19637     $right_angle = $this->right_angle()->rewrite($rewriter, $new_parents);
19638     if (
19639       $left_angle === $this->left_angle() &&
19640       $name === $this->name() &&
19641       $right_angle === $this->right_angle()) {
19642       return $rewriter($this, $parents ?? []);
19643     } else {
19644       return $rewriter(new XHPClose(
19645         $left_angle,
19646         $name,
19647         $right_angle), $parents ?? []);
19648     }
19649   }
19650
19651   public static function from_json(mixed $json, int $position, string $source) {
19652     $left_angle = EditableSyntax::from_json(
19653       $json->xhp_close_left_angle, $position, $source);
19654     $position += $left_angle->width();
19655     $name = EditableSyntax::from_json(
19656       $json->xhp_close_name, $position, $source);
19657     $position += $name->width();
19658     $right_angle = EditableSyntax::from_json(
19659       $json->xhp_close_right_angle, $position, $source);
19660     $position += $right_angle->width();
19661     return new XHPClose(
19662         $left_angle,
19663         $name,
19664         $right_angle);
19665   }
19666   public function children(): Generator<string, EditableSyntax, void> {
19667     yield $this->_left_angle;
19668     yield $this->_name;
19669     yield $this->_right_angle;
19670     yield break;
19671   }
19672 }
19673 final class TypeConstant extends EditableSyntax {
19674   private EditableSyntax $_left_type;
19675   private EditableSyntax $_separator;
19676   private EditableSyntax $_right_type;
19677   public function __construct(
19678     EditableSyntax $left_type,
19679     EditableSyntax $separator,
19680     EditableSyntax $right_type) {
19681     parent::__construct('type_constant');
19682     $this->_left_type = $left_type;
19683     $this->_separator = $separator;
19684     $this->_right_type = $right_type;
19685   }
19686   public function left_type(): EditableSyntax {
19687     return $this->_left_type;
19688   }
19689   public function separator(): EditableSyntax {
19690     return $this->_separator;
19691   }
19692   public function right_type(): EditableSyntax {
19693     return $this->_right_type;
19694   }
19695   public function with_left_type(EditableSyntax $left_type): TypeConstant {
19696     return new TypeConstant(
19697       $left_type,
19698       $this->_separator,
19699       $this->_right_type);
19700   }
19701   public function with_separator(EditableSyntax $separator): TypeConstant {
19702     return new TypeConstant(
19703       $this->_left_type,
19704       $separator,
19705       $this->_right_type);
19706   }
19707   public function with_right_type(EditableSyntax $right_type): TypeConstant {
19708     return new TypeConstant(
19709       $this->_left_type,
19710       $this->_separator,
19711       $right_type);
19712   }
19713
19714   public function rewrite(
19715     ( function
19716       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
19717     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
19718     $new_parents = $parents ?? [];
19719     array_push($new_parents, $this);
19720     $left_type = $this->left_type()->rewrite($rewriter, $new_parents);
19721     $separator = $this->separator()->rewrite($rewriter, $new_parents);
19722     $right_type = $this->right_type()->rewrite($rewriter, $new_parents);
19723     if (
19724       $left_type === $this->left_type() &&
19725       $separator === $this->separator() &&
19726       $right_type === $this->right_type()) {
19727       return $rewriter($this, $parents ?? []);
19728     } else {
19729       return $rewriter(new TypeConstant(
19730         $left_type,
19731         $separator,
19732         $right_type), $parents ?? []);
19733     }
19734   }
19735
19736   public static function from_json(mixed $json, int $position, string $source) {
19737     $left_type = EditableSyntax::from_json(
19738       $json->type_constant_left_type, $position, $source);
19739     $position += $left_type->width();
19740     $separator = EditableSyntax::from_json(
19741       $json->type_constant_separator, $position, $source);
19742     $position += $separator->width();
19743     $right_type = EditableSyntax::from_json(
19744       $json->type_constant_right_type, $position, $source);
19745     $position += $right_type->width();
19746     return new TypeConstant(
19747         $left_type,
19748         $separator,
19749         $right_type);
19750   }
19751   public function children(): Generator<string, EditableSyntax, void> {
19752     yield $this->_left_type;
19753     yield $this->_separator;
19754     yield $this->_right_type;
19755     yield break;
19756   }
19757 }
19758 final class VectorTypeSpecifier extends EditableSyntax {
19759   private EditableSyntax $_keyword;
19760   private EditableSyntax $_left_angle;
19761   private EditableSyntax $_type;
19762   private EditableSyntax $_trailing_comma;
19763   private EditableSyntax $_right_angle;
19764   public function __construct(
19765     EditableSyntax $keyword,
19766     EditableSyntax $left_angle,
19767     EditableSyntax $type,
19768     EditableSyntax $trailing_comma,
19769     EditableSyntax $right_angle) {
19770     parent::__construct('vector_type_specifier');
19771     $this->_keyword = $keyword;
19772     $this->_left_angle = $left_angle;
19773     $this->_type = $type;
19774     $this->_trailing_comma = $trailing_comma;
19775     $this->_right_angle = $right_angle;
19776   }
19777   public function keyword(): EditableSyntax {
19778     return $this->_keyword;
19779   }
19780   public function left_angle(): EditableSyntax {
19781     return $this->_left_angle;
19782   }
19783   public function type(): EditableSyntax {
19784     return $this->_type;
19785   }
19786   public function trailing_comma(): EditableSyntax {
19787     return $this->_trailing_comma;
19788   }
19789   public function right_angle(): EditableSyntax {
19790     return $this->_right_angle;
19791   }
19792   public function with_keyword(EditableSyntax $keyword): VectorTypeSpecifier {
19793     return new VectorTypeSpecifier(
19794       $keyword,
19795       $this->_left_angle,
19796       $this->_type,
19797       $this->_trailing_comma,
19798       $this->_right_angle);
19799   }
19800   public function with_left_angle(EditableSyntax $left_angle): VectorTypeSpecifier {
19801     return new VectorTypeSpecifier(
19802       $this->_keyword,
19803       $left_angle,
19804       $this->_type,
19805       $this->_trailing_comma,
19806       $this->_right_angle);
19807   }
19808   public function with_type(EditableSyntax $type): VectorTypeSpecifier {
19809     return new VectorTypeSpecifier(
19810       $this->_keyword,
19811       $this->_left_angle,
19812       $type,
19813       $this->_trailing_comma,
19814       $this->_right_angle);
19815   }
19816   public function with_trailing_comma(EditableSyntax $trailing_comma): VectorTypeSpecifier {
19817     return new VectorTypeSpecifier(
19818       $this->_keyword,
19819       $this->_left_angle,
19820       $this->_type,
19821       $trailing_comma,
19822       $this->_right_angle);
19823   }
19824   public function with_right_angle(EditableSyntax $right_angle): VectorTypeSpecifier {
19825     return new VectorTypeSpecifier(
19826       $this->_keyword,
19827       $this->_left_angle,
19828       $this->_type,
19829       $this->_trailing_comma,
19830       $right_angle);
19831   }
19832
19833   public function rewrite(
19834     ( function
19835       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
19836     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
19837     $new_parents = $parents ?? [];
19838     array_push($new_parents, $this);
19839     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
19840     $left_angle = $this->left_angle()->rewrite($rewriter, $new_parents);
19841     $type = $this->type()->rewrite($rewriter, $new_parents);
19842     $trailing_comma = $this->trailing_comma()->rewrite($rewriter, $new_parents);
19843     $right_angle = $this->right_angle()->rewrite($rewriter, $new_parents);
19844     if (
19845       $keyword === $this->keyword() &&
19846       $left_angle === $this->left_angle() &&
19847       $type === $this->type() &&
19848       $trailing_comma === $this->trailing_comma() &&
19849       $right_angle === $this->right_angle()) {
19850       return $rewriter($this, $parents ?? []);
19851     } else {
19852       return $rewriter(new VectorTypeSpecifier(
19853         $keyword,
19854         $left_angle,
19855         $type,
19856         $trailing_comma,
19857         $right_angle), $parents ?? []);
19858     }
19859   }
19860
19861   public static function from_json(mixed $json, int $position, string $source) {
19862     $keyword = EditableSyntax::from_json(
19863       $json->vector_type_keyword, $position, $source);
19864     $position += $keyword->width();
19865     $left_angle = EditableSyntax::from_json(
19866       $json->vector_type_left_angle, $position, $source);
19867     $position += $left_angle->width();
19868     $type = EditableSyntax::from_json(
19869       $json->vector_type_type, $position, $source);
19870     $position += $type->width();
19871     $trailing_comma = EditableSyntax::from_json(
19872       $json->vector_type_trailing_comma, $position, $source);
19873     $position += $trailing_comma->width();
19874     $right_angle = EditableSyntax::from_json(
19875       $json->vector_type_right_angle, $position, $source);
19876     $position += $right_angle->width();
19877     return new VectorTypeSpecifier(
19878         $keyword,
19879         $left_angle,
19880         $type,
19881         $trailing_comma,
19882         $right_angle);
19883   }
19884   public function children(): Generator<string, EditableSyntax, void> {
19885     yield $this->_keyword;
19886     yield $this->_left_angle;
19887     yield $this->_type;
19888     yield $this->_trailing_comma;
19889     yield $this->_right_angle;
19890     yield break;
19891   }
19892 }
19893 final class KeysetTypeSpecifier extends EditableSyntax {
19894   private EditableSyntax $_keyword;
19895   private EditableSyntax $_left_angle;
19896   private EditableSyntax $_type;
19897   private EditableSyntax $_trailing_comma;
19898   private EditableSyntax $_right_angle;
19899   public function __construct(
19900     EditableSyntax $keyword,
19901     EditableSyntax $left_angle,
19902     EditableSyntax $type,
19903     EditableSyntax $trailing_comma,
19904     EditableSyntax $right_angle) {
19905     parent::__construct('keyset_type_specifier');
19906     $this->_keyword = $keyword;
19907     $this->_left_angle = $left_angle;
19908     $this->_type = $type;
19909     $this->_trailing_comma = $trailing_comma;
19910     $this->_right_angle = $right_angle;
19911   }
19912   public function keyword(): EditableSyntax {
19913     return $this->_keyword;
19914   }
19915   public function left_angle(): EditableSyntax {
19916     return $this->_left_angle;
19917   }
19918   public function type(): EditableSyntax {
19919     return $this->_type;
19920   }
19921   public function trailing_comma(): EditableSyntax {
19922     return $this->_trailing_comma;
19923   }
19924   public function right_angle(): EditableSyntax {
19925     return $this->_right_angle;
19926   }
19927   public function with_keyword(EditableSyntax $keyword): KeysetTypeSpecifier {
19928     return new KeysetTypeSpecifier(
19929       $keyword,
19930       $this->_left_angle,
19931       $this->_type,
19932       $this->_trailing_comma,
19933       $this->_right_angle);
19934   }
19935   public function with_left_angle(EditableSyntax $left_angle): KeysetTypeSpecifier {
19936     return new KeysetTypeSpecifier(
19937       $this->_keyword,
19938       $left_angle,
19939       $this->_type,
19940       $this->_trailing_comma,
19941       $this->_right_angle);
19942   }
19943   public function with_type(EditableSyntax $type): KeysetTypeSpecifier {
19944     return new KeysetTypeSpecifier(
19945       $this->_keyword,
19946       $this->_left_angle,
19947       $type,
19948       $this->_trailing_comma,
19949       $this->_right_angle);
19950   }
19951   public function with_trailing_comma(EditableSyntax $trailing_comma): KeysetTypeSpecifier {
19952     return new KeysetTypeSpecifier(
19953       $this->_keyword,
19954       $this->_left_angle,
19955       $this->_type,
19956       $trailing_comma,
19957       $this->_right_angle);
19958   }
19959   public function with_right_angle(EditableSyntax $right_angle): KeysetTypeSpecifier {
19960     return new KeysetTypeSpecifier(
19961       $this->_keyword,
19962       $this->_left_angle,
19963       $this->_type,
19964       $this->_trailing_comma,
19965       $right_angle);
19966   }
19967
19968   public function rewrite(
19969     ( function
19970       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
19971     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
19972     $new_parents = $parents ?? [];
19973     array_push($new_parents, $this);
19974     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
19975     $left_angle = $this->left_angle()->rewrite($rewriter, $new_parents);
19976     $type = $this->type()->rewrite($rewriter, $new_parents);
19977     $trailing_comma = $this->trailing_comma()->rewrite($rewriter, $new_parents);
19978     $right_angle = $this->right_angle()->rewrite($rewriter, $new_parents);
19979     if (
19980       $keyword === $this->keyword() &&
19981       $left_angle === $this->left_angle() &&
19982       $type === $this->type() &&
19983       $trailing_comma === $this->trailing_comma() &&
19984       $right_angle === $this->right_angle()) {
19985       return $rewriter($this, $parents ?? []);
19986     } else {
19987       return $rewriter(new KeysetTypeSpecifier(
19988         $keyword,
19989         $left_angle,
19990         $type,
19991         $trailing_comma,
19992         $right_angle), $parents ?? []);
19993     }
19994   }
19995
19996   public static function from_json(mixed $json, int $position, string $source) {
19997     $keyword = EditableSyntax::from_json(
19998       $json->keyset_type_keyword, $position, $source);
19999     $position += $keyword->width();
20000     $left_angle = EditableSyntax::from_json(
20001       $json->keyset_type_left_angle, $position, $source);
20002     $position += $left_angle->width();
20003     $type = EditableSyntax::from_json(
20004       $json->keyset_type_type, $position, $source);
20005     $position += $type->width();
20006     $trailing_comma = EditableSyntax::from_json(
20007       $json->keyset_type_trailing_comma, $position, $source);
20008     $position += $trailing_comma->width();
20009     $right_angle = EditableSyntax::from_json(
20010       $json->keyset_type_right_angle, $position, $source);
20011     $position += $right_angle->width();
20012     return new KeysetTypeSpecifier(
20013         $keyword,
20014         $left_angle,
20015         $type,
20016         $trailing_comma,
20017         $right_angle);
20018   }
20019   public function children(): Generator<string, EditableSyntax, void> {
20020     yield $this->_keyword;
20021     yield $this->_left_angle;
20022     yield $this->_type;
20023     yield $this->_trailing_comma;
20024     yield $this->_right_angle;
20025     yield break;
20026   }
20027 }
20028 final class TupleTypeExplicitSpecifier extends EditableSyntax {
20029   private EditableSyntax $_keyword;
20030   private EditableSyntax $_left_angle;
20031   private EditableSyntax $_types;
20032   private EditableSyntax $_right_angle;
20033   public function __construct(
20034     EditableSyntax $keyword,
20035     EditableSyntax $left_angle,
20036     EditableSyntax $types,
20037     EditableSyntax $right_angle) {
20038     parent::__construct('tuple_type_explicit_specifier');
20039     $this->_keyword = $keyword;
20040     $this->_left_angle = $left_angle;
20041     $this->_types = $types;
20042     $this->_right_angle = $right_angle;
20043   }
20044   public function keyword(): EditableSyntax {
20045     return $this->_keyword;
20046   }
20047   public function left_angle(): EditableSyntax {
20048     return $this->_left_angle;
20049   }
20050   public function types(): EditableSyntax {
20051     return $this->_types;
20052   }
20053   public function right_angle(): EditableSyntax {
20054     return $this->_right_angle;
20055   }
20056   public function with_keyword(EditableSyntax $keyword): TupleTypeExplicitSpecifier {
20057     return new TupleTypeExplicitSpecifier(
20058       $keyword,
20059       $this->_left_angle,
20060       $this->_types,
20061       $this->_right_angle);
20062   }
20063   public function with_left_angle(EditableSyntax $left_angle): TupleTypeExplicitSpecifier {
20064     return new TupleTypeExplicitSpecifier(
20065       $this->_keyword,
20066       $left_angle,
20067       $this->_types,
20068       $this->_right_angle);
20069   }
20070   public function with_types(EditableSyntax $types): TupleTypeExplicitSpecifier {
20071     return new TupleTypeExplicitSpecifier(
20072       $this->_keyword,
20073       $this->_left_angle,
20074       $types,
20075       $this->_right_angle);
20076   }
20077   public function with_right_angle(EditableSyntax $right_angle): TupleTypeExplicitSpecifier {
20078     return new TupleTypeExplicitSpecifier(
20079       $this->_keyword,
20080       $this->_left_angle,
20081       $this->_types,
20082       $right_angle);
20083   }
20084
20085   public function rewrite(
20086     ( function
20087       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
20088     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
20089     $new_parents = $parents ?? [];
20090     array_push($new_parents, $this);
20091     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
20092     $left_angle = $this->left_angle()->rewrite($rewriter, $new_parents);
20093     $types = $this->types()->rewrite($rewriter, $new_parents);
20094     $right_angle = $this->right_angle()->rewrite($rewriter, $new_parents);
20095     if (
20096       $keyword === $this->keyword() &&
20097       $left_angle === $this->left_angle() &&
20098       $types === $this->types() &&
20099       $right_angle === $this->right_angle()) {
20100       return $rewriter($this, $parents ?? []);
20101     } else {
20102       return $rewriter(new TupleTypeExplicitSpecifier(
20103         $keyword,
20104         $left_angle,
20105         $types,
20106         $right_angle), $parents ?? []);
20107     }
20108   }
20109
20110   public static function from_json(mixed $json, int $position, string $source) {
20111     $keyword = EditableSyntax::from_json(
20112       $json->tuple_type_keyword, $position, $source);
20113     $position += $keyword->width();
20114     $left_angle = EditableSyntax::from_json(
20115       $json->tuple_type_left_angle, $position, $source);
20116     $position += $left_angle->width();
20117     $types = EditableSyntax::from_json(
20118       $json->tuple_type_types, $position, $source);
20119     $position += $types->width();
20120     $right_angle = EditableSyntax::from_json(
20121       $json->tuple_type_right_angle, $position, $source);
20122     $position += $right_angle->width();
20123     return new TupleTypeExplicitSpecifier(
20124         $keyword,
20125         $left_angle,
20126         $types,
20127         $right_angle);
20128   }
20129   public function children(): Generator<string, EditableSyntax, void> {
20130     yield $this->_keyword;
20131     yield $this->_left_angle;
20132     yield $this->_types;
20133     yield $this->_right_angle;
20134     yield break;
20135   }
20136 }
20137 final class VarrayTypeSpecifier extends EditableSyntax {
20138   private EditableSyntax $_keyword;
20139   private EditableSyntax $_left_angle;
20140   private EditableSyntax $_type;
20141   private EditableSyntax $_trailing_comma;
20142   private EditableSyntax $_right_angle;
20143   public function __construct(
20144     EditableSyntax $keyword,
20145     EditableSyntax $left_angle,
20146     EditableSyntax $type,
20147     EditableSyntax $trailing_comma,
20148     EditableSyntax $right_angle) {
20149     parent::__construct('varray_type_specifier');
20150     $this->_keyword = $keyword;
20151     $this->_left_angle = $left_angle;
20152     $this->_type = $type;
20153     $this->_trailing_comma = $trailing_comma;
20154     $this->_right_angle = $right_angle;
20155   }
20156   public function keyword(): EditableSyntax {
20157     return $this->_keyword;
20158   }
20159   public function left_angle(): EditableSyntax {
20160     return $this->_left_angle;
20161   }
20162   public function type(): EditableSyntax {
20163     return $this->_type;
20164   }
20165   public function trailing_comma(): EditableSyntax {
20166     return $this->_trailing_comma;
20167   }
20168   public function right_angle(): EditableSyntax {
20169     return $this->_right_angle;
20170   }
20171   public function with_keyword(EditableSyntax $keyword): VarrayTypeSpecifier {
20172     return new VarrayTypeSpecifier(
20173       $keyword,
20174       $this->_left_angle,
20175       $this->_type,
20176       $this->_trailing_comma,
20177       $this->_right_angle);
20178   }
20179   public function with_left_angle(EditableSyntax $left_angle): VarrayTypeSpecifier {
20180     return new VarrayTypeSpecifier(
20181       $this->_keyword,
20182       $left_angle,
20183       $this->_type,
20184       $this->_trailing_comma,
20185       $this->_right_angle);
20186   }
20187   public function with_type(EditableSyntax $type): VarrayTypeSpecifier {
20188     return new VarrayTypeSpecifier(
20189       $this->_keyword,
20190       $this->_left_angle,
20191       $type,
20192       $this->_trailing_comma,
20193       $this->_right_angle);
20194   }
20195   public function with_trailing_comma(EditableSyntax $trailing_comma): VarrayTypeSpecifier {
20196     return new VarrayTypeSpecifier(
20197       $this->_keyword,
20198       $this->_left_angle,
20199       $this->_type,
20200       $trailing_comma,
20201       $this->_right_angle);
20202   }
20203   public function with_right_angle(EditableSyntax $right_angle): VarrayTypeSpecifier {
20204     return new VarrayTypeSpecifier(
20205       $this->_keyword,
20206       $this->_left_angle,
20207       $this->_type,
20208       $this->_trailing_comma,
20209       $right_angle);
20210   }
20211
20212   public function rewrite(
20213     ( function
20214       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
20215     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
20216     $new_parents = $parents ?? [];
20217     array_push($new_parents, $this);
20218     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
20219     $left_angle = $this->left_angle()->rewrite($rewriter, $new_parents);
20220     $type = $this->type()->rewrite($rewriter, $new_parents);
20221     $trailing_comma = $this->trailing_comma()->rewrite($rewriter, $new_parents);
20222     $right_angle = $this->right_angle()->rewrite($rewriter, $new_parents);
20223     if (
20224       $keyword === $this->keyword() &&
20225       $left_angle === $this->left_angle() &&
20226       $type === $this->type() &&
20227       $trailing_comma === $this->trailing_comma() &&
20228       $right_angle === $this->right_angle()) {
20229       return $rewriter($this, $parents ?? []);
20230     } else {
20231       return $rewriter(new VarrayTypeSpecifier(
20232         $keyword,
20233         $left_angle,
20234         $type,
20235         $trailing_comma,
20236         $right_angle), $parents ?? []);
20237     }
20238   }
20239
20240   public static function from_json(mixed $json, int $position, string $source) {
20241     $keyword = EditableSyntax::from_json(
20242       $json->varray_keyword, $position, $source);
20243     $position += $keyword->width();
20244     $left_angle = EditableSyntax::from_json(
20245       $json->varray_left_angle, $position, $source);
20246     $position += $left_angle->width();
20247     $type = EditableSyntax::from_json(
20248       $json->varray_type, $position, $source);
20249     $position += $type->width();
20250     $trailing_comma = EditableSyntax::from_json(
20251       $json->varray_trailing_comma, $position, $source);
20252     $position += $trailing_comma->width();
20253     $right_angle = EditableSyntax::from_json(
20254       $json->varray_right_angle, $position, $source);
20255     $position += $right_angle->width();
20256     return new VarrayTypeSpecifier(
20257         $keyword,
20258         $left_angle,
20259         $type,
20260         $trailing_comma,
20261         $right_angle);
20262   }
20263   public function children(): Generator<string, EditableSyntax, void> {
20264     yield $this->_keyword;
20265     yield $this->_left_angle;
20266     yield $this->_type;
20267     yield $this->_trailing_comma;
20268     yield $this->_right_angle;
20269     yield break;
20270   }
20271 }
20272 final class VectorArrayTypeSpecifier extends EditableSyntax {
20273   private EditableSyntax $_keyword;
20274   private EditableSyntax $_left_angle;
20275   private EditableSyntax $_type;
20276   private EditableSyntax $_right_angle;
20277   public function __construct(
20278     EditableSyntax $keyword,
20279     EditableSyntax $left_angle,
20280     EditableSyntax $type,
20281     EditableSyntax $right_angle) {
20282     parent::__construct('vector_array_type_specifier');
20283     $this->_keyword = $keyword;
20284     $this->_left_angle = $left_angle;
20285     $this->_type = $type;
20286     $this->_right_angle = $right_angle;
20287   }
20288   public function keyword(): EditableSyntax {
20289     return $this->_keyword;
20290   }
20291   public function left_angle(): EditableSyntax {
20292     return $this->_left_angle;
20293   }
20294   public function type(): EditableSyntax {
20295     return $this->_type;
20296   }
20297   public function right_angle(): EditableSyntax {
20298     return $this->_right_angle;
20299   }
20300   public function with_keyword(EditableSyntax $keyword): VectorArrayTypeSpecifier {
20301     return new VectorArrayTypeSpecifier(
20302       $keyword,
20303       $this->_left_angle,
20304       $this->_type,
20305       $this->_right_angle);
20306   }
20307   public function with_left_angle(EditableSyntax $left_angle): VectorArrayTypeSpecifier {
20308     return new VectorArrayTypeSpecifier(
20309       $this->_keyword,
20310       $left_angle,
20311       $this->_type,
20312       $this->_right_angle);
20313   }
20314   public function with_type(EditableSyntax $type): VectorArrayTypeSpecifier {
20315     return new VectorArrayTypeSpecifier(
20316       $this->_keyword,
20317       $this->_left_angle,
20318       $type,
20319       $this->_right_angle);
20320   }
20321   public function with_right_angle(EditableSyntax $right_angle): VectorArrayTypeSpecifier {
20322     return new VectorArrayTypeSpecifier(
20323       $this->_keyword,
20324       $this->_left_angle,
20325       $this->_type,
20326       $right_angle);
20327   }
20328
20329   public function rewrite(
20330     ( function
20331       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
20332     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
20333     $new_parents = $parents ?? [];
20334     array_push($new_parents, $this);
20335     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
20336     $left_angle = $this->left_angle()->rewrite($rewriter, $new_parents);
20337     $type = $this->type()->rewrite($rewriter, $new_parents);
20338     $right_angle = $this->right_angle()->rewrite($rewriter, $new_parents);
20339     if (
20340       $keyword === $this->keyword() &&
20341       $left_angle === $this->left_angle() &&
20342       $type === $this->type() &&
20343       $right_angle === $this->right_angle()) {
20344       return $rewriter($this, $parents ?? []);
20345     } else {
20346       return $rewriter(new VectorArrayTypeSpecifier(
20347         $keyword,
20348         $left_angle,
20349         $type,
20350         $right_angle), $parents ?? []);
20351     }
20352   }
20353
20354   public static function from_json(mixed $json, int $position, string $source) {
20355     $keyword = EditableSyntax::from_json(
20356       $json->vector_array_keyword, $position, $source);
20357     $position += $keyword->width();
20358     $left_angle = EditableSyntax::from_json(
20359       $json->vector_array_left_angle, $position, $source);
20360     $position += $left_angle->width();
20361     $type = EditableSyntax::from_json(
20362       $json->vector_array_type, $position, $source);
20363     $position += $type->width();
20364     $right_angle = EditableSyntax::from_json(
20365       $json->vector_array_right_angle, $position, $source);
20366     $position += $right_angle->width();
20367     return new VectorArrayTypeSpecifier(
20368         $keyword,
20369         $left_angle,
20370         $type,
20371         $right_angle);
20372   }
20373   public function children(): Generator<string, EditableSyntax, void> {
20374     yield $this->_keyword;
20375     yield $this->_left_angle;
20376     yield $this->_type;
20377     yield $this->_right_angle;
20378     yield break;
20379   }
20380 }
20381 final class TypeParameter extends EditableSyntax {
20382   private EditableSyntax $_variance;
20383   private EditableSyntax $_name;
20384   private EditableSyntax $_constraints;
20385   public function __construct(
20386     EditableSyntax $variance,
20387     EditableSyntax $name,
20388     EditableSyntax $constraints) {
20389     parent::__construct('type_parameter');
20390     $this->_variance = $variance;
20391     $this->_name = $name;
20392     $this->_constraints = $constraints;
20393   }
20394   public function variance(): EditableSyntax {
20395     return $this->_variance;
20396   }
20397   public function name(): EditableSyntax {
20398     return $this->_name;
20399   }
20400   public function constraints(): EditableSyntax {
20401     return $this->_constraints;
20402   }
20403   public function with_variance(EditableSyntax $variance): TypeParameter {
20404     return new TypeParameter(
20405       $variance,
20406       $this->_name,
20407       $this->_constraints);
20408   }
20409   public function with_name(EditableSyntax $name): TypeParameter {
20410     return new TypeParameter(
20411       $this->_variance,
20412       $name,
20413       $this->_constraints);
20414   }
20415   public function with_constraints(EditableSyntax $constraints): TypeParameter {
20416     return new TypeParameter(
20417       $this->_variance,
20418       $this->_name,
20419       $constraints);
20420   }
20421
20422   public function rewrite(
20423     ( function
20424       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
20425     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
20426     $new_parents = $parents ?? [];
20427     array_push($new_parents, $this);
20428     $variance = $this->variance()->rewrite($rewriter, $new_parents);
20429     $name = $this->name()->rewrite($rewriter, $new_parents);
20430     $constraints = $this->constraints()->rewrite($rewriter, $new_parents);
20431     if (
20432       $variance === $this->variance() &&
20433       $name === $this->name() &&
20434       $constraints === $this->constraints()) {
20435       return $rewriter($this, $parents ?? []);
20436     } else {
20437       return $rewriter(new TypeParameter(
20438         $variance,
20439         $name,
20440         $constraints), $parents ?? []);
20441     }
20442   }
20443
20444   public static function from_json(mixed $json, int $position, string $source) {
20445     $variance = EditableSyntax::from_json(
20446       $json->type_variance, $position, $source);
20447     $position += $variance->width();
20448     $name = EditableSyntax::from_json(
20449       $json->type_name, $position, $source);
20450     $position += $name->width();
20451     $constraints = EditableSyntax::from_json(
20452       $json->type_constraints, $position, $source);
20453     $position += $constraints->width();
20454     return new TypeParameter(
20455         $variance,
20456         $name,
20457         $constraints);
20458   }
20459   public function children(): Generator<string, EditableSyntax, void> {
20460     yield $this->_variance;
20461     yield $this->_name;
20462     yield $this->_constraints;
20463     yield break;
20464   }
20465 }
20466 final class TypeConstraint extends EditableSyntax {
20467   private EditableSyntax $_keyword;
20468   private EditableSyntax $_type;
20469   public function __construct(
20470     EditableSyntax $keyword,
20471     EditableSyntax $type) {
20472     parent::__construct('type_constraint');
20473     $this->_keyword = $keyword;
20474     $this->_type = $type;
20475   }
20476   public function keyword(): EditableSyntax {
20477     return $this->_keyword;
20478   }
20479   public function type(): EditableSyntax {
20480     return $this->_type;
20481   }
20482   public function with_keyword(EditableSyntax $keyword): TypeConstraint {
20483     return new TypeConstraint(
20484       $keyword,
20485       $this->_type);
20486   }
20487   public function with_type(EditableSyntax $type): TypeConstraint {
20488     return new TypeConstraint(
20489       $this->_keyword,
20490       $type);
20491   }
20492
20493   public function rewrite(
20494     ( function
20495       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
20496     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
20497     $new_parents = $parents ?? [];
20498     array_push($new_parents, $this);
20499     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
20500     $type = $this->type()->rewrite($rewriter, $new_parents);
20501     if (
20502       $keyword === $this->keyword() &&
20503       $type === $this->type()) {
20504       return $rewriter($this, $parents ?? []);
20505     } else {
20506       return $rewriter(new TypeConstraint(
20507         $keyword,
20508         $type), $parents ?? []);
20509     }
20510   }
20511
20512   public static function from_json(mixed $json, int $position, string $source) {
20513     $keyword = EditableSyntax::from_json(
20514       $json->constraint_keyword, $position, $source);
20515     $position += $keyword->width();
20516     $type = EditableSyntax::from_json(
20517       $json->constraint_type, $position, $source);
20518     $position += $type->width();
20519     return new TypeConstraint(
20520         $keyword,
20521         $type);
20522   }
20523   public function children(): Generator<string, EditableSyntax, void> {
20524     yield $this->_keyword;
20525     yield $this->_type;
20526     yield break;
20527   }
20528 }
20529 final class DarrayTypeSpecifier extends EditableSyntax {
20530   private EditableSyntax $_keyword;
20531   private EditableSyntax $_left_angle;
20532   private EditableSyntax $_key;
20533   private EditableSyntax $_comma;
20534   private EditableSyntax $_value;
20535   private EditableSyntax $_trailing_comma;
20536   private EditableSyntax $_right_angle;
20537   public function __construct(
20538     EditableSyntax $keyword,
20539     EditableSyntax $left_angle,
20540     EditableSyntax $key,
20541     EditableSyntax $comma,
20542     EditableSyntax $value,
20543     EditableSyntax $trailing_comma,
20544     EditableSyntax $right_angle) {
20545     parent::__construct('darray_type_specifier');
20546     $this->_keyword = $keyword;
20547     $this->_left_angle = $left_angle;
20548     $this->_key = $key;
20549     $this->_comma = $comma;
20550     $this->_value = $value;
20551     $this->_trailing_comma = $trailing_comma;
20552     $this->_right_angle = $right_angle;
20553   }
20554   public function keyword(): EditableSyntax {
20555     return $this->_keyword;
20556   }
20557   public function left_angle(): EditableSyntax {
20558     return $this->_left_angle;
20559   }
20560   public function key(): EditableSyntax {
20561     return $this->_key;
20562   }
20563   public function comma(): EditableSyntax {
20564     return $this->_comma;
20565   }
20566   public function value(): EditableSyntax {
20567     return $this->_value;
20568   }
20569   public function trailing_comma(): EditableSyntax {
20570     return $this->_trailing_comma;
20571   }
20572   public function right_angle(): EditableSyntax {
20573     return $this->_right_angle;
20574   }
20575   public function with_keyword(EditableSyntax $keyword): DarrayTypeSpecifier {
20576     return new DarrayTypeSpecifier(
20577       $keyword,
20578       $this->_left_angle,
20579       $this->_key,
20580       $this->_comma,
20581       $this->_value,
20582       $this->_trailing_comma,
20583       $this->_right_angle);
20584   }
20585   public function with_left_angle(EditableSyntax $left_angle): DarrayTypeSpecifier {
20586     return new DarrayTypeSpecifier(
20587       $this->_keyword,
20588       $left_angle,
20589       $this->_key,
20590       $this->_comma,
20591       $this->_value,
20592       $this->_trailing_comma,
20593       $this->_right_angle);
20594   }
20595   public function with_key(EditableSyntax $key): DarrayTypeSpecifier {
20596     return new DarrayTypeSpecifier(
20597       $this->_keyword,
20598       $this->_left_angle,
20599       $key,
20600       $this->_comma,
20601       $this->_value,
20602       $this->_trailing_comma,
20603       $this->_right_angle);
20604   }
20605   public function with_comma(EditableSyntax $comma): DarrayTypeSpecifier {
20606     return new DarrayTypeSpecifier(
20607       $this->_keyword,
20608       $this->_left_angle,
20609       $this->_key,
20610       $comma,
20611       $this->_value,
20612       $this->_trailing_comma,
20613       $this->_right_angle);
20614   }
20615   public function with_value(EditableSyntax $value): DarrayTypeSpecifier {
20616     return new DarrayTypeSpecifier(
20617       $this->_keyword,
20618       $this->_left_angle,
20619       $this->_key,
20620       $this->_comma,
20621       $value,
20622       $this->_trailing_comma,
20623       $this->_right_angle);
20624   }
20625   public function with_trailing_comma(EditableSyntax $trailing_comma): DarrayTypeSpecifier {
20626     return new DarrayTypeSpecifier(
20627       $this->_keyword,
20628       $this->_left_angle,
20629       $this->_key,
20630       $this->_comma,
20631       $this->_value,
20632       $trailing_comma,
20633       $this->_right_angle);
20634   }
20635   public function with_right_angle(EditableSyntax $right_angle): DarrayTypeSpecifier {
20636     return new DarrayTypeSpecifier(
20637       $this->_keyword,
20638       $this->_left_angle,
20639       $this->_key,
20640       $this->_comma,
20641       $this->_value,
20642       $this->_trailing_comma,
20643       $right_angle);
20644   }
20645
20646   public function rewrite(
20647     ( function
20648       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
20649     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
20650     $new_parents = $parents ?? [];
20651     array_push($new_parents, $this);
20652     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
20653     $left_angle = $this->left_angle()->rewrite($rewriter, $new_parents);
20654     $key = $this->key()->rewrite($rewriter, $new_parents);
20655     $comma = $this->comma()->rewrite($rewriter, $new_parents);
20656     $value = $this->value()->rewrite($rewriter, $new_parents);
20657     $trailing_comma = $this->trailing_comma()->rewrite($rewriter, $new_parents);
20658     $right_angle = $this->right_angle()->rewrite($rewriter, $new_parents);
20659     if (
20660       $keyword === $this->keyword() &&
20661       $left_angle === $this->left_angle() &&
20662       $key === $this->key() &&
20663       $comma === $this->comma() &&
20664       $value === $this->value() &&
20665       $trailing_comma === $this->trailing_comma() &&
20666       $right_angle === $this->right_angle()) {
20667       return $rewriter($this, $parents ?? []);
20668     } else {
20669       return $rewriter(new DarrayTypeSpecifier(
20670         $keyword,
20671         $left_angle,
20672         $key,
20673         $comma,
20674         $value,
20675         $trailing_comma,
20676         $right_angle), $parents ?? []);
20677     }
20678   }
20679
20680   public static function from_json(mixed $json, int $position, string $source) {
20681     $keyword = EditableSyntax::from_json(
20682       $json->darray_keyword, $position, $source);
20683     $position += $keyword->width();
20684     $left_angle = EditableSyntax::from_json(
20685       $json->darray_left_angle, $position, $source);
20686     $position += $left_angle->width();
20687     $key = EditableSyntax::from_json(
20688       $json->darray_key, $position, $source);
20689     $position += $key->width();
20690     $comma = EditableSyntax::from_json(
20691       $json->darray_comma, $position, $source);
20692     $position += $comma->width();
20693     $value = EditableSyntax::from_json(
20694       $json->darray_value, $position, $source);
20695     $position += $value->width();
20696     $trailing_comma = EditableSyntax::from_json(
20697       $json->darray_trailing_comma, $position, $source);
20698     $position += $trailing_comma->width();
20699     $right_angle = EditableSyntax::from_json(
20700       $json->darray_right_angle, $position, $source);
20701     $position += $right_angle->width();
20702     return new DarrayTypeSpecifier(
20703         $keyword,
20704         $left_angle,
20705         $key,
20706         $comma,
20707         $value,
20708         $trailing_comma,
20709         $right_angle);
20710   }
20711   public function children(): Generator<string, EditableSyntax, void> {
20712     yield $this->_keyword;
20713     yield $this->_left_angle;
20714     yield $this->_key;
20715     yield $this->_comma;
20716     yield $this->_value;
20717     yield $this->_trailing_comma;
20718     yield $this->_right_angle;
20719     yield break;
20720   }
20721 }
20722 final class MapArrayTypeSpecifier extends EditableSyntax {
20723   private EditableSyntax $_keyword;
20724   private EditableSyntax $_left_angle;
20725   private EditableSyntax $_key;
20726   private EditableSyntax $_comma;
20727   private EditableSyntax $_value;
20728   private EditableSyntax $_right_angle;
20729   public function __construct(
20730     EditableSyntax $keyword,
20731     EditableSyntax $left_angle,
20732     EditableSyntax $key,
20733     EditableSyntax $comma,
20734     EditableSyntax $value,
20735     EditableSyntax $right_angle) {
20736     parent::__construct('map_array_type_specifier');
20737     $this->_keyword = $keyword;
20738     $this->_left_angle = $left_angle;
20739     $this->_key = $key;
20740     $this->_comma = $comma;
20741     $this->_value = $value;
20742     $this->_right_angle = $right_angle;
20743   }
20744   public function keyword(): EditableSyntax {
20745     return $this->_keyword;
20746   }
20747   public function left_angle(): EditableSyntax {
20748     return $this->_left_angle;
20749   }
20750   public function key(): EditableSyntax {
20751     return $this->_key;
20752   }
20753   public function comma(): EditableSyntax {
20754     return $this->_comma;
20755   }
20756   public function value(): EditableSyntax {
20757     return $this->_value;
20758   }
20759   public function right_angle(): EditableSyntax {
20760     return $this->_right_angle;
20761   }
20762   public function with_keyword(EditableSyntax $keyword): MapArrayTypeSpecifier {
20763     return new MapArrayTypeSpecifier(
20764       $keyword,
20765       $this->_left_angle,
20766       $this->_key,
20767       $this->_comma,
20768       $this->_value,
20769       $this->_right_angle);
20770   }
20771   public function with_left_angle(EditableSyntax $left_angle): MapArrayTypeSpecifier {
20772     return new MapArrayTypeSpecifier(
20773       $this->_keyword,
20774       $left_angle,
20775       $this->_key,
20776       $this->_comma,
20777       $this->_value,
20778       $this->_right_angle);
20779   }
20780   public function with_key(EditableSyntax $key): MapArrayTypeSpecifier {
20781     return new MapArrayTypeSpecifier(
20782       $this->_keyword,
20783       $this->_left_angle,
20784       $key,
20785       $this->_comma,
20786       $this->_value,
20787       $this->_right_angle);
20788   }
20789   public function with_comma(EditableSyntax $comma): MapArrayTypeSpecifier {
20790     return new MapArrayTypeSpecifier(
20791       $this->_keyword,
20792       $this->_left_angle,
20793       $this->_key,
20794       $comma,
20795       $this->_value,
20796       $this->_right_angle);
20797   }
20798   public function with_value(EditableSyntax $value): MapArrayTypeSpecifier {
20799     return new MapArrayTypeSpecifier(
20800       $this->_keyword,
20801       $this->_left_angle,
20802       $this->_key,
20803       $this->_comma,
20804       $value,
20805       $this->_right_angle);
20806   }
20807   public function with_right_angle(EditableSyntax $right_angle): MapArrayTypeSpecifier {
20808     return new MapArrayTypeSpecifier(
20809       $this->_keyword,
20810       $this->_left_angle,
20811       $this->_key,
20812       $this->_comma,
20813       $this->_value,
20814       $right_angle);
20815   }
20816
20817   public function rewrite(
20818     ( function
20819       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
20820     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
20821     $new_parents = $parents ?? [];
20822     array_push($new_parents, $this);
20823     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
20824     $left_angle = $this->left_angle()->rewrite($rewriter, $new_parents);
20825     $key = $this->key()->rewrite($rewriter, $new_parents);
20826     $comma = $this->comma()->rewrite($rewriter, $new_parents);
20827     $value = $this->value()->rewrite($rewriter, $new_parents);
20828     $right_angle = $this->right_angle()->rewrite($rewriter, $new_parents);
20829     if (
20830       $keyword === $this->keyword() &&
20831       $left_angle === $this->left_angle() &&
20832       $key === $this->key() &&
20833       $comma === $this->comma() &&
20834       $value === $this->value() &&
20835       $right_angle === $this->right_angle()) {
20836       return $rewriter($this, $parents ?? []);
20837     } else {
20838       return $rewriter(new MapArrayTypeSpecifier(
20839         $keyword,
20840         $left_angle,
20841         $key,
20842         $comma,
20843         $value,
20844         $right_angle), $parents ?? []);
20845     }
20846   }
20847
20848   public static function from_json(mixed $json, int $position, string $source) {
20849     $keyword = EditableSyntax::from_json(
20850       $json->map_array_keyword, $position, $source);
20851     $position += $keyword->width();
20852     $left_angle = EditableSyntax::from_json(
20853       $json->map_array_left_angle, $position, $source);
20854     $position += $left_angle->width();
20855     $key = EditableSyntax::from_json(
20856       $json->map_array_key, $position, $source);
20857     $position += $key->width();
20858     $comma = EditableSyntax::from_json(
20859       $json->map_array_comma, $position, $source);
20860     $position += $comma->width();
20861     $value = EditableSyntax::from_json(
20862       $json->map_array_value, $position, $source);
20863     $position += $value->width();
20864     $right_angle = EditableSyntax::from_json(
20865       $json->map_array_right_angle, $position, $source);
20866     $position += $right_angle->width();
20867     return new MapArrayTypeSpecifier(
20868         $keyword,
20869         $left_angle,
20870         $key,
20871         $comma,
20872         $value,
20873         $right_angle);
20874   }
20875   public function children(): Generator<string, EditableSyntax, void> {
20876     yield $this->_keyword;
20877     yield $this->_left_angle;
20878     yield $this->_key;
20879     yield $this->_comma;
20880     yield $this->_value;
20881     yield $this->_right_angle;
20882     yield break;
20883   }
20884 }
20885 final class DictionaryTypeSpecifier extends EditableSyntax {
20886   private EditableSyntax $_keyword;
20887   private EditableSyntax $_left_angle;
20888   private EditableSyntax $_members;
20889   private EditableSyntax $_right_angle;
20890   public function __construct(
20891     EditableSyntax $keyword,
20892     EditableSyntax $left_angle,
20893     EditableSyntax $members,
20894     EditableSyntax $right_angle) {
20895     parent::__construct('dictionary_type_specifier');
20896     $this->_keyword = $keyword;
20897     $this->_left_angle = $left_angle;
20898     $this->_members = $members;
20899     $this->_right_angle = $right_angle;
20900   }
20901   public function keyword(): EditableSyntax {
20902     return $this->_keyword;
20903   }
20904   public function left_angle(): EditableSyntax {
20905     return $this->_left_angle;
20906   }
20907   public function members(): EditableSyntax {
20908     return $this->_members;
20909   }
20910   public function right_angle(): EditableSyntax {
20911     return $this->_right_angle;
20912   }
20913   public function with_keyword(EditableSyntax $keyword): DictionaryTypeSpecifier {
20914     return new DictionaryTypeSpecifier(
20915       $keyword,
20916       $this->_left_angle,
20917       $this->_members,
20918       $this->_right_angle);
20919   }
20920   public function with_left_angle(EditableSyntax $left_angle): DictionaryTypeSpecifier {
20921     return new DictionaryTypeSpecifier(
20922       $this->_keyword,
20923       $left_angle,
20924       $this->_members,
20925       $this->_right_angle);
20926   }
20927   public function with_members(EditableSyntax $members): DictionaryTypeSpecifier {
20928     return new DictionaryTypeSpecifier(
20929       $this->_keyword,
20930       $this->_left_angle,
20931       $members,
20932       $this->_right_angle);
20933   }
20934   public function with_right_angle(EditableSyntax $right_angle): DictionaryTypeSpecifier {
20935     return new DictionaryTypeSpecifier(
20936       $this->_keyword,
20937       $this->_left_angle,
20938       $this->_members,
20939       $right_angle);
20940   }
20941
20942   public function rewrite(
20943     ( function
20944       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
20945     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
20946     $new_parents = $parents ?? [];
20947     array_push($new_parents, $this);
20948     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
20949     $left_angle = $this->left_angle()->rewrite($rewriter, $new_parents);
20950     $members = $this->members()->rewrite($rewriter, $new_parents);
20951     $right_angle = $this->right_angle()->rewrite($rewriter, $new_parents);
20952     if (
20953       $keyword === $this->keyword() &&
20954       $left_angle === $this->left_angle() &&
20955       $members === $this->members() &&
20956       $right_angle === $this->right_angle()) {
20957       return $rewriter($this, $parents ?? []);
20958     } else {
20959       return $rewriter(new DictionaryTypeSpecifier(
20960         $keyword,
20961         $left_angle,
20962         $members,
20963         $right_angle), $parents ?? []);
20964     }
20965   }
20966
20967   public static function from_json(mixed $json, int $position, string $source) {
20968     $keyword = EditableSyntax::from_json(
20969       $json->dictionary_type_keyword, $position, $source);
20970     $position += $keyword->width();
20971     $left_angle = EditableSyntax::from_json(
20972       $json->dictionary_type_left_angle, $position, $source);
20973     $position += $left_angle->width();
20974     $members = EditableSyntax::from_json(
20975       $json->dictionary_type_members, $position, $source);
20976     $position += $members->width();
20977     $right_angle = EditableSyntax::from_json(
20978       $json->dictionary_type_right_angle, $position, $source);
20979     $position += $right_angle->width();
20980     return new DictionaryTypeSpecifier(
20981         $keyword,
20982         $left_angle,
20983         $members,
20984         $right_angle);
20985   }
20986   public function children(): Generator<string, EditableSyntax, void> {
20987     yield $this->_keyword;
20988     yield $this->_left_angle;
20989     yield $this->_members;
20990     yield $this->_right_angle;
20991     yield break;
20992   }
20993 }
20994 final class ClosureTypeSpecifier extends EditableSyntax {
20995   private EditableSyntax $_outer_left_paren;
20996   private EditableSyntax $_coroutine;
20997   private EditableSyntax $_function_keyword;
20998   private EditableSyntax $_inner_left_paren;
20999   private EditableSyntax $_parameter_list;
21000   private EditableSyntax $_inner_right_paren;
21001   private EditableSyntax $_colon;
21002   private EditableSyntax $_return_type;
21003   private EditableSyntax $_outer_right_paren;
21004   public function __construct(
21005     EditableSyntax $outer_left_paren,
21006     EditableSyntax $coroutine,
21007     EditableSyntax $function_keyword,
21008     EditableSyntax $inner_left_paren,
21009     EditableSyntax $parameter_list,
21010     EditableSyntax $inner_right_paren,
21011     EditableSyntax $colon,
21012     EditableSyntax $return_type,
21013     EditableSyntax $outer_right_paren) {
21014     parent::__construct('closure_type_specifier');
21015     $this->_outer_left_paren = $outer_left_paren;
21016     $this->_coroutine = $coroutine;
21017     $this->_function_keyword = $function_keyword;
21018     $this->_inner_left_paren = $inner_left_paren;
21019     $this->_parameter_list = $parameter_list;
21020     $this->_inner_right_paren = $inner_right_paren;
21021     $this->_colon = $colon;
21022     $this->_return_type = $return_type;
21023     $this->_outer_right_paren = $outer_right_paren;
21024   }
21025   public function outer_left_paren(): EditableSyntax {
21026     return $this->_outer_left_paren;
21027   }
21028   public function coroutine(): EditableSyntax {
21029     return $this->_coroutine;
21030   }
21031   public function function_keyword(): EditableSyntax {
21032     return $this->_function_keyword;
21033   }
21034   public function inner_left_paren(): EditableSyntax {
21035     return $this->_inner_left_paren;
21036   }
21037   public function parameter_list(): EditableSyntax {
21038     return $this->_parameter_list;
21039   }
21040   public function inner_right_paren(): EditableSyntax {
21041     return $this->_inner_right_paren;
21042   }
21043   public function colon(): EditableSyntax {
21044     return $this->_colon;
21045   }
21046   public function return_type(): EditableSyntax {
21047     return $this->_return_type;
21048   }
21049   public function outer_right_paren(): EditableSyntax {
21050     return $this->_outer_right_paren;
21051   }
21052   public function with_outer_left_paren(EditableSyntax $outer_left_paren): ClosureTypeSpecifier {
21053     return new ClosureTypeSpecifier(
21054       $outer_left_paren,
21055       $this->_coroutine,
21056       $this->_function_keyword,
21057       $this->_inner_left_paren,
21058       $this->_parameter_list,
21059       $this->_inner_right_paren,
21060       $this->_colon,
21061       $this->_return_type,
21062       $this->_outer_right_paren);
21063   }
21064   public function with_coroutine(EditableSyntax $coroutine): ClosureTypeSpecifier {
21065     return new ClosureTypeSpecifier(
21066       $this->_outer_left_paren,
21067       $coroutine,
21068       $this->_function_keyword,
21069       $this->_inner_left_paren,
21070       $this->_parameter_list,
21071       $this->_inner_right_paren,
21072       $this->_colon,
21073       $this->_return_type,
21074       $this->_outer_right_paren);
21075   }
21076   public function with_function_keyword(EditableSyntax $function_keyword): ClosureTypeSpecifier {
21077     return new ClosureTypeSpecifier(
21078       $this->_outer_left_paren,
21079       $this->_coroutine,
21080       $function_keyword,
21081       $this->_inner_left_paren,
21082       $this->_parameter_list,
21083       $this->_inner_right_paren,
21084       $this->_colon,
21085       $this->_return_type,
21086       $this->_outer_right_paren);
21087   }
21088   public function with_inner_left_paren(EditableSyntax $inner_left_paren): ClosureTypeSpecifier {
21089     return new ClosureTypeSpecifier(
21090       $this->_outer_left_paren,
21091       $this->_coroutine,
21092       $this->_function_keyword,
21093       $inner_left_paren,
21094       $this->_parameter_list,
21095       $this->_inner_right_paren,
21096       $this->_colon,
21097       $this->_return_type,
21098       $this->_outer_right_paren);
21099   }
21100   public function with_parameter_list(EditableSyntax $parameter_list): ClosureTypeSpecifier {
21101     return new ClosureTypeSpecifier(
21102       $this->_outer_left_paren,
21103       $this->_coroutine,
21104       $this->_function_keyword,
21105       $this->_inner_left_paren,
21106       $parameter_list,
21107       $this->_inner_right_paren,
21108       $this->_colon,
21109       $this->_return_type,
21110       $this->_outer_right_paren);
21111   }
21112   public function with_inner_right_paren(EditableSyntax $inner_right_paren): ClosureTypeSpecifier {
21113     return new ClosureTypeSpecifier(
21114       $this->_outer_left_paren,
21115       $this->_coroutine,
21116       $this->_function_keyword,
21117       $this->_inner_left_paren,
21118       $this->_parameter_list,
21119       $inner_right_paren,
21120       $this->_colon,
21121       $this->_return_type,
21122       $this->_outer_right_paren);
21123   }
21124   public function with_colon(EditableSyntax $colon): ClosureTypeSpecifier {
21125     return new ClosureTypeSpecifier(
21126       $this->_outer_left_paren,
21127       $this->_coroutine,
21128       $this->_function_keyword,
21129       $this->_inner_left_paren,
21130       $this->_parameter_list,
21131       $this->_inner_right_paren,
21132       $colon,
21133       $this->_return_type,
21134       $this->_outer_right_paren);
21135   }
21136   public function with_return_type(EditableSyntax $return_type): ClosureTypeSpecifier {
21137     return new ClosureTypeSpecifier(
21138       $this->_outer_left_paren,
21139       $this->_coroutine,
21140       $this->_function_keyword,
21141       $this->_inner_left_paren,
21142       $this->_parameter_list,
21143       $this->_inner_right_paren,
21144       $this->_colon,
21145       $return_type,
21146       $this->_outer_right_paren);
21147   }
21148   public function with_outer_right_paren(EditableSyntax $outer_right_paren): ClosureTypeSpecifier {
21149     return new ClosureTypeSpecifier(
21150       $this->_outer_left_paren,
21151       $this->_coroutine,
21152       $this->_function_keyword,
21153       $this->_inner_left_paren,
21154       $this->_parameter_list,
21155       $this->_inner_right_paren,
21156       $this->_colon,
21157       $this->_return_type,
21158       $outer_right_paren);
21159   }
21160
21161   public function rewrite(
21162     ( function
21163       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
21164     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
21165     $new_parents = $parents ?? [];
21166     array_push($new_parents, $this);
21167     $outer_left_paren = $this->outer_left_paren()->rewrite($rewriter, $new_parents);
21168     $coroutine = $this->coroutine()->rewrite($rewriter, $new_parents);
21169     $function_keyword = $this->function_keyword()->rewrite($rewriter, $new_parents);
21170     $inner_left_paren = $this->inner_left_paren()->rewrite($rewriter, $new_parents);
21171     $parameter_list = $this->parameter_list()->rewrite($rewriter, $new_parents);
21172     $inner_right_paren = $this->inner_right_paren()->rewrite($rewriter, $new_parents);
21173     $colon = $this->colon()->rewrite($rewriter, $new_parents);
21174     $return_type = $this->return_type()->rewrite($rewriter, $new_parents);
21175     $outer_right_paren = $this->outer_right_paren()->rewrite($rewriter, $new_parents);
21176     if (
21177       $outer_left_paren === $this->outer_left_paren() &&
21178       $coroutine === $this->coroutine() &&
21179       $function_keyword === $this->function_keyword() &&
21180       $inner_left_paren === $this->inner_left_paren() &&
21181       $parameter_list === $this->parameter_list() &&
21182       $inner_right_paren === $this->inner_right_paren() &&
21183       $colon === $this->colon() &&
21184       $return_type === $this->return_type() &&
21185       $outer_right_paren === $this->outer_right_paren()) {
21186       return $rewriter($this, $parents ?? []);
21187     } else {
21188       return $rewriter(new ClosureTypeSpecifier(
21189         $outer_left_paren,
21190         $coroutine,
21191         $function_keyword,
21192         $inner_left_paren,
21193         $parameter_list,
21194         $inner_right_paren,
21195         $colon,
21196         $return_type,
21197         $outer_right_paren), $parents ?? []);
21198     }
21199   }
21200
21201   public static function from_json(mixed $json, int $position, string $source) {
21202     $outer_left_paren = EditableSyntax::from_json(
21203       $json->closure_outer_left_paren, $position, $source);
21204     $position += $outer_left_paren->width();
21205     $coroutine = EditableSyntax::from_json(
21206       $json->closure_coroutine, $position, $source);
21207     $position += $coroutine->width();
21208     $function_keyword = EditableSyntax::from_json(
21209       $json->closure_function_keyword, $position, $source);
21210     $position += $function_keyword->width();
21211     $inner_left_paren = EditableSyntax::from_json(
21212       $json->closure_inner_left_paren, $position, $source);
21213     $position += $inner_left_paren->width();
21214     $parameter_list = EditableSyntax::from_json(
21215       $json->closure_parameter_list, $position, $source);
21216     $position += $parameter_list->width();
21217     $inner_right_paren = EditableSyntax::from_json(
21218       $json->closure_inner_right_paren, $position, $source);
21219     $position += $inner_right_paren->width();
21220     $colon = EditableSyntax::from_json(
21221       $json->closure_colon, $position, $source);
21222     $position += $colon->width();
21223     $return_type = EditableSyntax::from_json(
21224       $json->closure_return_type, $position, $source);
21225     $position += $return_type->width();
21226     $outer_right_paren = EditableSyntax::from_json(
21227       $json->closure_outer_right_paren, $position, $source);
21228     $position += $outer_right_paren->width();
21229     return new ClosureTypeSpecifier(
21230         $outer_left_paren,
21231         $coroutine,
21232         $function_keyword,
21233         $inner_left_paren,
21234         $parameter_list,
21235         $inner_right_paren,
21236         $colon,
21237         $return_type,
21238         $outer_right_paren);
21239   }
21240   public function children(): Generator<string, EditableSyntax, void> {
21241     yield $this->_outer_left_paren;
21242     yield $this->_coroutine;
21243     yield $this->_function_keyword;
21244     yield $this->_inner_left_paren;
21245     yield $this->_parameter_list;
21246     yield $this->_inner_right_paren;
21247     yield $this->_colon;
21248     yield $this->_return_type;
21249     yield $this->_outer_right_paren;
21250     yield break;
21251   }
21252 }
21253 final class ClosureParameterTypeSpecifier extends EditableSyntax {
21254   private EditableSyntax $_call_convention;
21255   private EditableSyntax $_type;
21256   public function __construct(
21257     EditableSyntax $call_convention,
21258     EditableSyntax $type) {
21259     parent::__construct('closure_parameter_type_specifier');
21260     $this->_call_convention = $call_convention;
21261     $this->_type = $type;
21262   }
21263   public function call_convention(): EditableSyntax {
21264     return $this->_call_convention;
21265   }
21266   public function type(): EditableSyntax {
21267     return $this->_type;
21268   }
21269   public function with_call_convention(EditableSyntax $call_convention): ClosureParameterTypeSpecifier {
21270     return new ClosureParameterTypeSpecifier(
21271       $call_convention,
21272       $this->_type);
21273   }
21274   public function with_type(EditableSyntax $type): ClosureParameterTypeSpecifier {
21275     return new ClosureParameterTypeSpecifier(
21276       $this->_call_convention,
21277       $type);
21278   }
21279
21280   public function rewrite(
21281     ( function
21282       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
21283     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
21284     $new_parents = $parents ?? [];
21285     array_push($new_parents, $this);
21286     $call_convention = $this->call_convention()->rewrite($rewriter, $new_parents);
21287     $type = $this->type()->rewrite($rewriter, $new_parents);
21288     if (
21289       $call_convention === $this->call_convention() &&
21290       $type === $this->type()) {
21291       return $rewriter($this, $parents ?? []);
21292     } else {
21293       return $rewriter(new ClosureParameterTypeSpecifier(
21294         $call_convention,
21295         $type), $parents ?? []);
21296     }
21297   }
21298
21299   public static function from_json(mixed $json, int $position, string $source) {
21300     $call_convention = EditableSyntax::from_json(
21301       $json->closure_parameter_call_convention, $position, $source);
21302     $position += $call_convention->width();
21303     $type = EditableSyntax::from_json(
21304       $json->closure_parameter_type, $position, $source);
21305     $position += $type->width();
21306     return new ClosureParameterTypeSpecifier(
21307         $call_convention,
21308         $type);
21309   }
21310   public function children(): Generator<string, EditableSyntax, void> {
21311     yield $this->_call_convention;
21312     yield $this->_type;
21313     yield break;
21314   }
21315 }
21316 final class ClassnameTypeSpecifier extends EditableSyntax {
21317   private EditableSyntax $_keyword;
21318   private EditableSyntax $_left_angle;
21319   private EditableSyntax $_type;
21320   private EditableSyntax $_trailing_comma;
21321   private EditableSyntax $_right_angle;
21322   public function __construct(
21323     EditableSyntax $keyword,
21324     EditableSyntax $left_angle,
21325     EditableSyntax $type,
21326     EditableSyntax $trailing_comma,
21327     EditableSyntax $right_angle) {
21328     parent::__construct('classname_type_specifier');
21329     $this->_keyword = $keyword;
21330     $this->_left_angle = $left_angle;
21331     $this->_type = $type;
21332     $this->_trailing_comma = $trailing_comma;
21333     $this->_right_angle = $right_angle;
21334   }
21335   public function keyword(): EditableSyntax {
21336     return $this->_keyword;
21337   }
21338   public function left_angle(): EditableSyntax {
21339     return $this->_left_angle;
21340   }
21341   public function type(): EditableSyntax {
21342     return $this->_type;
21343   }
21344   public function trailing_comma(): EditableSyntax {
21345     return $this->_trailing_comma;
21346   }
21347   public function right_angle(): EditableSyntax {
21348     return $this->_right_angle;
21349   }
21350   public function with_keyword(EditableSyntax $keyword): ClassnameTypeSpecifier {
21351     return new ClassnameTypeSpecifier(
21352       $keyword,
21353       $this->_left_angle,
21354       $this->_type,
21355       $this->_trailing_comma,
21356       $this->_right_angle);
21357   }
21358   public function with_left_angle(EditableSyntax $left_angle): ClassnameTypeSpecifier {
21359     return new ClassnameTypeSpecifier(
21360       $this->_keyword,
21361       $left_angle,
21362       $this->_type,
21363       $this->_trailing_comma,
21364       $this->_right_angle);
21365   }
21366   public function with_type(EditableSyntax $type): ClassnameTypeSpecifier {
21367     return new ClassnameTypeSpecifier(
21368       $this->_keyword,
21369       $this->_left_angle,
21370       $type,
21371       $this->_trailing_comma,
21372       $this->_right_angle);
21373   }
21374   public function with_trailing_comma(EditableSyntax $trailing_comma): ClassnameTypeSpecifier {
21375     return new ClassnameTypeSpecifier(
21376       $this->_keyword,
21377       $this->_left_angle,
21378       $this->_type,
21379       $trailing_comma,
21380       $this->_right_angle);
21381   }
21382   public function with_right_angle(EditableSyntax $right_angle): ClassnameTypeSpecifier {
21383     return new ClassnameTypeSpecifier(
21384       $this->_keyword,
21385       $this->_left_angle,
21386       $this->_type,
21387       $this->_trailing_comma,
21388       $right_angle);
21389   }
21390
21391   public function rewrite(
21392     ( function
21393       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
21394     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
21395     $new_parents = $parents ?? [];
21396     array_push($new_parents, $this);
21397     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
21398     $left_angle = $this->left_angle()->rewrite($rewriter, $new_parents);
21399     $type = $this->type()->rewrite($rewriter, $new_parents);
21400     $trailing_comma = $this->trailing_comma()->rewrite($rewriter, $new_parents);
21401     $right_angle = $this->right_angle()->rewrite($rewriter, $new_parents);
21402     if (
21403       $keyword === $this->keyword() &&
21404       $left_angle === $this->left_angle() &&
21405       $type === $this->type() &&
21406       $trailing_comma === $this->trailing_comma() &&
21407       $right_angle === $this->right_angle()) {
21408       return $rewriter($this, $parents ?? []);
21409     } else {
21410       return $rewriter(new ClassnameTypeSpecifier(
21411         $keyword,
21412         $left_angle,
21413         $type,
21414         $trailing_comma,
21415         $right_angle), $parents ?? []);
21416     }
21417   }
21418
21419   public static function from_json(mixed $json, int $position, string $source) {
21420     $keyword = EditableSyntax::from_json(
21421       $json->classname_keyword, $position, $source);
21422     $position += $keyword->width();
21423     $left_angle = EditableSyntax::from_json(
21424       $json->classname_left_angle, $position, $source);
21425     $position += $left_angle->width();
21426     $type = EditableSyntax::from_json(
21427       $json->classname_type, $position, $source);
21428     $position += $type->width();
21429     $trailing_comma = EditableSyntax::from_json(
21430       $json->classname_trailing_comma, $position, $source);
21431     $position += $trailing_comma->width();
21432     $right_angle = EditableSyntax::from_json(
21433       $json->classname_right_angle, $position, $source);
21434     $position += $right_angle->width();
21435     return new ClassnameTypeSpecifier(
21436         $keyword,
21437         $left_angle,
21438         $type,
21439         $trailing_comma,
21440         $right_angle);
21441   }
21442   public function children(): Generator<string, EditableSyntax, void> {
21443     yield $this->_keyword;
21444     yield $this->_left_angle;
21445     yield $this->_type;
21446     yield $this->_trailing_comma;
21447     yield $this->_right_angle;
21448     yield break;
21449   }
21450 }
21451 final class FieldSpecifier extends EditableSyntax {
21452   private EditableSyntax $_question;
21453   private EditableSyntax $_name;
21454   private EditableSyntax $_arrow;
21455   private EditableSyntax $_type;
21456   public function __construct(
21457     EditableSyntax $question,
21458     EditableSyntax $name,
21459     EditableSyntax $arrow,
21460     EditableSyntax $type) {
21461     parent::__construct('field_specifier');
21462     $this->_question = $question;
21463     $this->_name = $name;
21464     $this->_arrow = $arrow;
21465     $this->_type = $type;
21466   }
21467   public function question(): EditableSyntax {
21468     return $this->_question;
21469   }
21470   public function name(): EditableSyntax {
21471     return $this->_name;
21472   }
21473   public function arrow(): EditableSyntax {
21474     return $this->_arrow;
21475   }
21476   public function type(): EditableSyntax {
21477     return $this->_type;
21478   }
21479   public function with_question(EditableSyntax $question): FieldSpecifier {
21480     return new FieldSpecifier(
21481       $question,
21482       $this->_name,
21483       $this->_arrow,
21484       $this->_type);
21485   }
21486   public function with_name(EditableSyntax $name): FieldSpecifier {
21487     return new FieldSpecifier(
21488       $this->_question,
21489       $name,
21490       $this->_arrow,
21491       $this->_type);
21492   }
21493   public function with_arrow(EditableSyntax $arrow): FieldSpecifier {
21494     return new FieldSpecifier(
21495       $this->_question,
21496       $this->_name,
21497       $arrow,
21498       $this->_type);
21499   }
21500   public function with_type(EditableSyntax $type): FieldSpecifier {
21501     return new FieldSpecifier(
21502       $this->_question,
21503       $this->_name,
21504       $this->_arrow,
21505       $type);
21506   }
21507
21508   public function rewrite(
21509     ( function
21510       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
21511     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
21512     $new_parents = $parents ?? [];
21513     array_push($new_parents, $this);
21514     $question = $this->question()->rewrite($rewriter, $new_parents);
21515     $name = $this->name()->rewrite($rewriter, $new_parents);
21516     $arrow = $this->arrow()->rewrite($rewriter, $new_parents);
21517     $type = $this->type()->rewrite($rewriter, $new_parents);
21518     if (
21519       $question === $this->question() &&
21520       $name === $this->name() &&
21521       $arrow === $this->arrow() &&
21522       $type === $this->type()) {
21523       return $rewriter($this, $parents ?? []);
21524     } else {
21525       return $rewriter(new FieldSpecifier(
21526         $question,
21527         $name,
21528         $arrow,
21529         $type), $parents ?? []);
21530     }
21531   }
21532
21533   public static function from_json(mixed $json, int $position, string $source) {
21534     $question = EditableSyntax::from_json(
21535       $json->field_question, $position, $source);
21536     $position += $question->width();
21537     $name = EditableSyntax::from_json(
21538       $json->field_name, $position, $source);
21539     $position += $name->width();
21540     $arrow = EditableSyntax::from_json(
21541       $json->field_arrow, $position, $source);
21542     $position += $arrow->width();
21543     $type = EditableSyntax::from_json(
21544       $json->field_type, $position, $source);
21545     $position += $type->width();
21546     return new FieldSpecifier(
21547         $question,
21548         $name,
21549         $arrow,
21550         $type);
21551   }
21552   public function children(): Generator<string, EditableSyntax, void> {
21553     yield $this->_question;
21554     yield $this->_name;
21555     yield $this->_arrow;
21556     yield $this->_type;
21557     yield break;
21558   }
21559 }
21560 final class FieldInitializer extends EditableSyntax {
21561   private EditableSyntax $_name;
21562   private EditableSyntax $_arrow;
21563   private EditableSyntax $_value;
21564   public function __construct(
21565     EditableSyntax $name,
21566     EditableSyntax $arrow,
21567     EditableSyntax $value) {
21568     parent::__construct('field_initializer');
21569     $this->_name = $name;
21570     $this->_arrow = $arrow;
21571     $this->_value = $value;
21572   }
21573   public function name(): EditableSyntax {
21574     return $this->_name;
21575   }
21576   public function arrow(): EditableSyntax {
21577     return $this->_arrow;
21578   }
21579   public function value(): EditableSyntax {
21580     return $this->_value;
21581   }
21582   public function with_name(EditableSyntax $name): FieldInitializer {
21583     return new FieldInitializer(
21584       $name,
21585       $this->_arrow,
21586       $this->_value);
21587   }
21588   public function with_arrow(EditableSyntax $arrow): FieldInitializer {
21589     return new FieldInitializer(
21590       $this->_name,
21591       $arrow,
21592       $this->_value);
21593   }
21594   public function with_value(EditableSyntax $value): FieldInitializer {
21595     return new FieldInitializer(
21596       $this->_name,
21597       $this->_arrow,
21598       $value);
21599   }
21600
21601   public function rewrite(
21602     ( function
21603       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
21604     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
21605     $new_parents = $parents ?? [];
21606     array_push($new_parents, $this);
21607     $name = $this->name()->rewrite($rewriter, $new_parents);
21608     $arrow = $this->arrow()->rewrite($rewriter, $new_parents);
21609     $value = $this->value()->rewrite($rewriter, $new_parents);
21610     if (
21611       $name === $this->name() &&
21612       $arrow === $this->arrow() &&
21613       $value === $this->value()) {
21614       return $rewriter($this, $parents ?? []);
21615     } else {
21616       return $rewriter(new FieldInitializer(
21617         $name,
21618         $arrow,
21619         $value), $parents ?? []);
21620     }
21621   }
21622
21623   public static function from_json(mixed $json, int $position, string $source) {
21624     $name = EditableSyntax::from_json(
21625       $json->field_initializer_name, $position, $source);
21626     $position += $name->width();
21627     $arrow = EditableSyntax::from_json(
21628       $json->field_initializer_arrow, $position, $source);
21629     $position += $arrow->width();
21630     $value = EditableSyntax::from_json(
21631       $json->field_initializer_value, $position, $source);
21632     $position += $value->width();
21633     return new FieldInitializer(
21634         $name,
21635         $arrow,
21636         $value);
21637   }
21638   public function children(): Generator<string, EditableSyntax, void> {
21639     yield $this->_name;
21640     yield $this->_arrow;
21641     yield $this->_value;
21642     yield break;
21643   }
21644 }
21645 final class ShapeTypeSpecifier extends EditableSyntax {
21646   private EditableSyntax $_keyword;
21647   private EditableSyntax $_left_paren;
21648   private EditableSyntax $_fields;
21649   private EditableSyntax $_ellipsis;
21650   private EditableSyntax $_right_paren;
21651   public function __construct(
21652     EditableSyntax $keyword,
21653     EditableSyntax $left_paren,
21654     EditableSyntax $fields,
21655     EditableSyntax $ellipsis,
21656     EditableSyntax $right_paren) {
21657     parent::__construct('shape_type_specifier');
21658     $this->_keyword = $keyword;
21659     $this->_left_paren = $left_paren;
21660     $this->_fields = $fields;
21661     $this->_ellipsis = $ellipsis;
21662     $this->_right_paren = $right_paren;
21663   }
21664   public function keyword(): EditableSyntax {
21665     return $this->_keyword;
21666   }
21667   public function left_paren(): EditableSyntax {
21668     return $this->_left_paren;
21669   }
21670   public function fields(): EditableSyntax {
21671     return $this->_fields;
21672   }
21673   public function ellipsis(): EditableSyntax {
21674     return $this->_ellipsis;
21675   }
21676   public function right_paren(): EditableSyntax {
21677     return $this->_right_paren;
21678   }
21679   public function with_keyword(EditableSyntax $keyword): ShapeTypeSpecifier {
21680     return new ShapeTypeSpecifier(
21681       $keyword,
21682       $this->_left_paren,
21683       $this->_fields,
21684       $this->_ellipsis,
21685       $this->_right_paren);
21686   }
21687   public function with_left_paren(EditableSyntax $left_paren): ShapeTypeSpecifier {
21688     return new ShapeTypeSpecifier(
21689       $this->_keyword,
21690       $left_paren,
21691       $this->_fields,
21692       $this->_ellipsis,
21693       $this->_right_paren);
21694   }
21695   public function with_fields(EditableSyntax $fields): ShapeTypeSpecifier {
21696     return new ShapeTypeSpecifier(
21697       $this->_keyword,
21698       $this->_left_paren,
21699       $fields,
21700       $this->_ellipsis,
21701       $this->_right_paren);
21702   }
21703   public function with_ellipsis(EditableSyntax $ellipsis): ShapeTypeSpecifier {
21704     return new ShapeTypeSpecifier(
21705       $this->_keyword,
21706       $this->_left_paren,
21707       $this->_fields,
21708       $ellipsis,
21709       $this->_right_paren);
21710   }
21711   public function with_right_paren(EditableSyntax $right_paren): ShapeTypeSpecifier {
21712     return new ShapeTypeSpecifier(
21713       $this->_keyword,
21714       $this->_left_paren,
21715       $this->_fields,
21716       $this->_ellipsis,
21717       $right_paren);
21718   }
21719
21720   public function rewrite(
21721     ( function
21722       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
21723     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
21724     $new_parents = $parents ?? [];
21725     array_push($new_parents, $this);
21726     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
21727     $left_paren = $this->left_paren()->rewrite($rewriter, $new_parents);
21728     $fields = $this->fields()->rewrite($rewriter, $new_parents);
21729     $ellipsis = $this->ellipsis()->rewrite($rewriter, $new_parents);
21730     $right_paren = $this->right_paren()->rewrite($rewriter, $new_parents);
21731     if (
21732       $keyword === $this->keyword() &&
21733       $left_paren === $this->left_paren() &&
21734       $fields === $this->fields() &&
21735       $ellipsis === $this->ellipsis() &&
21736       $right_paren === $this->right_paren()) {
21737       return $rewriter($this, $parents ?? []);
21738     } else {
21739       return $rewriter(new ShapeTypeSpecifier(
21740         $keyword,
21741         $left_paren,
21742         $fields,
21743         $ellipsis,
21744         $right_paren), $parents ?? []);
21745     }
21746   }
21747
21748   public static function from_json(mixed $json, int $position, string $source) {
21749     $keyword = EditableSyntax::from_json(
21750       $json->shape_type_keyword, $position, $source);
21751     $position += $keyword->width();
21752     $left_paren = EditableSyntax::from_json(
21753       $json->shape_type_left_paren, $position, $source);
21754     $position += $left_paren->width();
21755     $fields = EditableSyntax::from_json(
21756       $json->shape_type_fields, $position, $source);
21757     $position += $fields->width();
21758     $ellipsis = EditableSyntax::from_json(
21759       $json->shape_type_ellipsis, $position, $source);
21760     $position += $ellipsis->width();
21761     $right_paren = EditableSyntax::from_json(
21762       $json->shape_type_right_paren, $position, $source);
21763     $position += $right_paren->width();
21764     return new ShapeTypeSpecifier(
21765         $keyword,
21766         $left_paren,
21767         $fields,
21768         $ellipsis,
21769         $right_paren);
21770   }
21771   public function children(): Generator<string, EditableSyntax, void> {
21772     yield $this->_keyword;
21773     yield $this->_left_paren;
21774     yield $this->_fields;
21775     yield $this->_ellipsis;
21776     yield $this->_right_paren;
21777     yield break;
21778   }
21779 }
21780 final class ShapeExpression extends EditableSyntax {
21781   private EditableSyntax $_keyword;
21782   private EditableSyntax $_left_paren;
21783   private EditableSyntax $_fields;
21784   private EditableSyntax $_right_paren;
21785   public function __construct(
21786     EditableSyntax $keyword,
21787     EditableSyntax $left_paren,
21788     EditableSyntax $fields,
21789     EditableSyntax $right_paren) {
21790     parent::__construct('shape_expression');
21791     $this->_keyword = $keyword;
21792     $this->_left_paren = $left_paren;
21793     $this->_fields = $fields;
21794     $this->_right_paren = $right_paren;
21795   }
21796   public function keyword(): EditableSyntax {
21797     return $this->_keyword;
21798   }
21799   public function left_paren(): EditableSyntax {
21800     return $this->_left_paren;
21801   }
21802   public function fields(): EditableSyntax {
21803     return $this->_fields;
21804   }
21805   public function right_paren(): EditableSyntax {
21806     return $this->_right_paren;
21807   }
21808   public function with_keyword(EditableSyntax $keyword): ShapeExpression {
21809     return new ShapeExpression(
21810       $keyword,
21811       $this->_left_paren,
21812       $this->_fields,
21813       $this->_right_paren);
21814   }
21815   public function with_left_paren(EditableSyntax $left_paren): ShapeExpression {
21816     return new ShapeExpression(
21817       $this->_keyword,
21818       $left_paren,
21819       $this->_fields,
21820       $this->_right_paren);
21821   }
21822   public function with_fields(EditableSyntax $fields): ShapeExpression {
21823     return new ShapeExpression(
21824       $this->_keyword,
21825       $this->_left_paren,
21826       $fields,
21827       $this->_right_paren);
21828   }
21829   public function with_right_paren(EditableSyntax $right_paren): ShapeExpression {
21830     return new ShapeExpression(
21831       $this->_keyword,
21832       $this->_left_paren,
21833       $this->_fields,
21834       $right_paren);
21835   }
21836
21837   public function rewrite(
21838     ( function
21839       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
21840     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
21841     $new_parents = $parents ?? [];
21842     array_push($new_parents, $this);
21843     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
21844     $left_paren = $this->left_paren()->rewrite($rewriter, $new_parents);
21845     $fields = $this->fields()->rewrite($rewriter, $new_parents);
21846     $right_paren = $this->right_paren()->rewrite($rewriter, $new_parents);
21847     if (
21848       $keyword === $this->keyword() &&
21849       $left_paren === $this->left_paren() &&
21850       $fields === $this->fields() &&
21851       $right_paren === $this->right_paren()) {
21852       return $rewriter($this, $parents ?? []);
21853     } else {
21854       return $rewriter(new ShapeExpression(
21855         $keyword,
21856         $left_paren,
21857         $fields,
21858         $right_paren), $parents ?? []);
21859     }
21860   }
21861
21862   public static function from_json(mixed $json, int $position, string $source) {
21863     $keyword = EditableSyntax::from_json(
21864       $json->shape_expression_keyword, $position, $source);
21865     $position += $keyword->width();
21866     $left_paren = EditableSyntax::from_json(
21867       $json->shape_expression_left_paren, $position, $source);
21868     $position += $left_paren->width();
21869     $fields = EditableSyntax::from_json(
21870       $json->shape_expression_fields, $position, $source);
21871     $position += $fields->width();
21872     $right_paren = EditableSyntax::from_json(
21873       $json->shape_expression_right_paren, $position, $source);
21874     $position += $right_paren->width();
21875     return new ShapeExpression(
21876         $keyword,
21877         $left_paren,
21878         $fields,
21879         $right_paren);
21880   }
21881   public function children(): Generator<string, EditableSyntax, void> {
21882     yield $this->_keyword;
21883     yield $this->_left_paren;
21884     yield $this->_fields;
21885     yield $this->_right_paren;
21886     yield break;
21887   }
21888 }
21889 final class TupleExpression extends EditableSyntax {
21890   private EditableSyntax $_keyword;
21891   private EditableSyntax $_left_paren;
21892   private EditableSyntax $_items;
21893   private EditableSyntax $_right_paren;
21894   public function __construct(
21895     EditableSyntax $keyword,
21896     EditableSyntax $left_paren,
21897     EditableSyntax $items,
21898     EditableSyntax $right_paren) {
21899     parent::__construct('tuple_expression');
21900     $this->_keyword = $keyword;
21901     $this->_left_paren = $left_paren;
21902     $this->_items = $items;
21903     $this->_right_paren = $right_paren;
21904   }
21905   public function keyword(): EditableSyntax {
21906     return $this->_keyword;
21907   }
21908   public function left_paren(): EditableSyntax {
21909     return $this->_left_paren;
21910   }
21911   public function items(): EditableSyntax {
21912     return $this->_items;
21913   }
21914   public function right_paren(): EditableSyntax {
21915     return $this->_right_paren;
21916   }
21917   public function with_keyword(EditableSyntax $keyword): TupleExpression {
21918     return new TupleExpression(
21919       $keyword,
21920       $this->_left_paren,
21921       $this->_items,
21922       $this->_right_paren);
21923   }
21924   public function with_left_paren(EditableSyntax $left_paren): TupleExpression {
21925     return new TupleExpression(
21926       $this->_keyword,
21927       $left_paren,
21928       $this->_items,
21929       $this->_right_paren);
21930   }
21931   public function with_items(EditableSyntax $items): TupleExpression {
21932     return new TupleExpression(
21933       $this->_keyword,
21934       $this->_left_paren,
21935       $items,
21936       $this->_right_paren);
21937   }
21938   public function with_right_paren(EditableSyntax $right_paren): TupleExpression {
21939     return new TupleExpression(
21940       $this->_keyword,
21941       $this->_left_paren,
21942       $this->_items,
21943       $right_paren);
21944   }
21945
21946   public function rewrite(
21947     ( function
21948       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
21949     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
21950     $new_parents = $parents ?? [];
21951     array_push($new_parents, $this);
21952     $keyword = $this->keyword()->rewrite($rewriter, $new_parents);
21953     $left_paren = $this->left_paren()->rewrite($rewriter, $new_parents);
21954     $items = $this->items()->rewrite($rewriter, $new_parents);
21955     $right_paren = $this->right_paren()->rewrite($rewriter, $new_parents);
21956     if (
21957       $keyword === $this->keyword() &&
21958       $left_paren === $this->left_paren() &&
21959       $items === $this->items() &&
21960       $right_paren === $this->right_paren()) {
21961       return $rewriter($this, $parents ?? []);
21962     } else {
21963       return $rewriter(new TupleExpression(
21964         $keyword,
21965         $left_paren,
21966         $items,
21967         $right_paren), $parents ?? []);
21968     }
21969   }
21970
21971   public static function from_json(mixed $json, int $position, string $source) {
21972     $keyword = EditableSyntax::from_json(
21973       $json->tuple_expression_keyword, $position, $source);
21974     $position += $keyword->width();
21975     $left_paren = EditableSyntax::from_json(
21976       $json->tuple_expression_left_paren, $position, $source);
21977     $position += $left_paren->width();
21978     $items = EditableSyntax::from_json(
21979       $json->tuple_expression_items, $position, $source);
21980     $position += $items->width();
21981     $right_paren = EditableSyntax::from_json(
21982       $json->tuple_expression_right_paren, $position, $source);
21983     $position += $right_paren->width();
21984     return new TupleExpression(
21985         $keyword,
21986         $left_paren,
21987         $items,
21988         $right_paren);
21989   }
21990   public function children(): Generator<string, EditableSyntax, void> {
21991     yield $this->_keyword;
21992     yield $this->_left_paren;
21993     yield $this->_items;
21994     yield $this->_right_paren;
21995     yield break;
21996   }
21997 }
21998 final class GenericTypeSpecifier extends EditableSyntax {
21999   private EditableSyntax $_class_type;
22000   private EditableSyntax $_argument_list;
22001   public function __construct(
22002     EditableSyntax $class_type,
22003     EditableSyntax $argument_list) {
22004     parent::__construct('generic_type_specifier');
22005     $this->_class_type = $class_type;
22006     $this->_argument_list = $argument_list;
22007   }
22008   public function class_type(): EditableSyntax {
22009     return $this->_class_type;
22010   }
22011   public function argument_list(): EditableSyntax {
22012     return $this->_argument_list;
22013   }
22014   public function with_class_type(EditableSyntax $class_type): GenericTypeSpecifier {
22015     return new GenericTypeSpecifier(
22016       $class_type,
22017       $this->_argument_list);
22018   }
22019   public function with_argument_list(EditableSyntax $argument_list): GenericTypeSpecifier {
22020     return new GenericTypeSpecifier(
22021       $this->_class_type,
22022       $argument_list);
22023   }
22024
22025   public function rewrite(
22026     ( function
22027       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
22028     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
22029     $new_parents = $parents ?? [];
22030     array_push($new_parents, $this);
22031     $class_type = $this->class_type()->rewrite($rewriter, $new_parents);
22032     $argument_list = $this->argument_list()->rewrite($rewriter, $new_parents);
22033     if (
22034       $class_type === $this->class_type() &&
22035       $argument_list === $this->argument_list()) {
22036       return $rewriter($this, $parents ?? []);
22037     } else {
22038       return $rewriter(new GenericTypeSpecifier(
22039         $class_type,
22040         $argument_list), $parents ?? []);
22041     }
22042   }
22043
22044   public static function from_json(mixed $json, int $position, string $source) {
22045     $class_type = EditableSyntax::from_json(
22046       $json->generic_class_type, $position, $source);
22047     $position += $class_type->width();
22048     $argument_list = EditableSyntax::from_json(
22049       $json->generic_argument_list, $position, $source);
22050     $position += $argument_list->width();
22051     return new GenericTypeSpecifier(
22052         $class_type,
22053         $argument_list);
22054   }
22055   public function children(): Generator<string, EditableSyntax, void> {
22056     yield $this->_class_type;
22057     yield $this->_argument_list;
22058     yield break;
22059   }
22060 }
22061 final class NullableTypeSpecifier extends EditableSyntax {
22062   private EditableSyntax $_question;
22063   private EditableSyntax $_type;
22064   public function __construct(
22065     EditableSyntax $question,
22066     EditableSyntax $type) {
22067     parent::__construct('nullable_type_specifier');
22068     $this->_question = $question;
22069     $this->_type = $type;
22070   }
22071   public function question(): EditableSyntax {
22072     return $this->_question;
22073   }
22074   public function type(): EditableSyntax {
22075     return $this->_type;
22076   }
22077   public function with_question(EditableSyntax $question): NullableTypeSpecifier {
22078     return new NullableTypeSpecifier(
22079       $question,
22080       $this->_type);
22081   }
22082   public function with_type(EditableSyntax $type): NullableTypeSpecifier {
22083     return new NullableTypeSpecifier(
22084       $this->_question,
22085       $type);
22086   }
22087
22088   public function rewrite(
22089     ( function
22090       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
22091     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
22092     $new_parents = $parents ?? [];
22093     array_push($new_parents, $this);
22094     $question = $this->question()->rewrite($rewriter, $new_parents);
22095     $type = $this->type()->rewrite($rewriter, $new_parents);
22096     if (
22097       $question === $this->question() &&
22098       $type === $this->type()) {
22099       return $rewriter($this, $parents ?? []);
22100     } else {
22101       return $rewriter(new NullableTypeSpecifier(
22102         $question,
22103         $type), $parents ?? []);
22104     }
22105   }
22106
22107   public static function from_json(mixed $json, int $position, string $source) {
22108     $question = EditableSyntax::from_json(
22109       $json->nullable_question, $position, $source);
22110     $position += $question->width();
22111     $type = EditableSyntax::from_json(
22112       $json->nullable_type, $position, $source);
22113     $position += $type->width();
22114     return new NullableTypeSpecifier(
22115         $question,
22116         $type);
22117   }
22118   public function children(): Generator<string, EditableSyntax, void> {
22119     yield $this->_question;
22120     yield $this->_type;
22121     yield break;
22122   }
22123 }
22124 final class SoftTypeSpecifier extends EditableSyntax {
22125   private EditableSyntax $_at;
22126   private EditableSyntax $_type;
22127   public function __construct(
22128     EditableSyntax $at,
22129     EditableSyntax $type) {
22130     parent::__construct('soft_type_specifier');
22131     $this->_at = $at;
22132     $this->_type = $type;
22133   }
22134   public function at(): EditableSyntax {
22135     return $this->_at;
22136   }
22137   public function type(): EditableSyntax {
22138     return $this->_type;
22139   }
22140   public function with_at(EditableSyntax $at): SoftTypeSpecifier {
22141     return new SoftTypeSpecifier(
22142       $at,
22143       $this->_type);
22144   }
22145   public function with_type(EditableSyntax $type): SoftTypeSpecifier {
22146     return new SoftTypeSpecifier(
22147       $this->_at,
22148       $type);
22149   }
22150
22151   public function rewrite(
22152     ( function
22153       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
22154     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
22155     $new_parents = $parents ?? [];
22156     array_push($new_parents, $this);
22157     $at = $this->at()->rewrite($rewriter, $new_parents);
22158     $type = $this->type()->rewrite($rewriter, $new_parents);
22159     if (
22160       $at === $this->at() &&
22161       $type === $this->type()) {
22162       return $rewriter($this, $parents ?? []);
22163     } else {
22164       return $rewriter(new SoftTypeSpecifier(
22165         $at,
22166         $type), $parents ?? []);
22167     }
22168   }
22169
22170   public static function from_json(mixed $json, int $position, string $source) {
22171     $at = EditableSyntax::from_json(
22172       $json->soft_at, $position, $source);
22173     $position += $at->width();
22174     $type = EditableSyntax::from_json(
22175       $json->soft_type, $position, $source);
22176     $position += $type->width();
22177     return new SoftTypeSpecifier(
22178         $at,
22179         $type);
22180   }
22181   public function children(): Generator<string, EditableSyntax, void> {
22182     yield $this->_at;
22183     yield $this->_type;
22184     yield break;
22185   }
22186 }
22187 final class TypeArguments extends EditableSyntax {
22188   private EditableSyntax $_left_angle;
22189   private EditableSyntax $_types;
22190   private EditableSyntax $_right_angle;
22191   public function __construct(
22192     EditableSyntax $left_angle,
22193     EditableSyntax $types,
22194     EditableSyntax $right_angle) {
22195     parent::__construct('type_arguments');
22196     $this->_left_angle = $left_angle;
22197     $this->_types = $types;
22198     $this->_right_angle = $right_angle;
22199   }
22200   public function left_angle(): EditableSyntax {
22201     return $this->_left_angle;
22202   }
22203   public function types(): EditableSyntax {
22204     return $this->_types;
22205   }
22206   public function right_angle(): EditableSyntax {
22207     return $this->_right_angle;
22208   }
22209   public function with_left_angle(EditableSyntax $left_angle): TypeArguments {
22210     return new TypeArguments(
22211       $left_angle,
22212       $this->_types,
22213       $this->_right_angle);
22214   }
22215   public function with_types(EditableSyntax $types): TypeArguments {
22216     return new TypeArguments(
22217       $this->_left_angle,
22218       $types,
22219       $this->_right_angle);
22220   }
22221   public function with_right_angle(EditableSyntax $right_angle): TypeArguments {
22222     return new TypeArguments(
22223       $this->_left_angle,
22224       $this->_types,
22225       $right_angle);
22226   }
22227
22228   public function rewrite(
22229     ( function
22230       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
22231     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
22232     $new_parents = $parents ?? [];
22233     array_push($new_parents, $this);
22234     $left_angle = $this->left_angle()->rewrite($rewriter, $new_parents);
22235     $types = $this->types()->rewrite($rewriter, $new_parents);
22236     $right_angle = $this->right_angle()->rewrite($rewriter, $new_parents);
22237     if (
22238       $left_angle === $this->left_angle() &&
22239       $types === $this->types() &&
22240       $right_angle === $this->right_angle()) {
22241       return $rewriter($this, $parents ?? []);
22242     } else {
22243       return $rewriter(new TypeArguments(
22244         $left_angle,
22245         $types,
22246         $right_angle), $parents ?? []);
22247     }
22248   }
22249
22250   public static function from_json(mixed $json, int $position, string $source) {
22251     $left_angle = EditableSyntax::from_json(
22252       $json->type_arguments_left_angle, $position, $source);
22253     $position += $left_angle->width();
22254     $types = EditableSyntax::from_json(
22255       $json->type_arguments_types, $position, $source);
22256     $position += $types->width();
22257     $right_angle = EditableSyntax::from_json(
22258       $json->type_arguments_right_angle, $position, $source);
22259     $position += $right_angle->width();
22260     return new TypeArguments(
22261         $left_angle,
22262         $types,
22263         $right_angle);
22264   }
22265   public function children(): Generator<string, EditableSyntax, void> {
22266     yield $this->_left_angle;
22267     yield $this->_types;
22268     yield $this->_right_angle;
22269     yield break;
22270   }
22271 }
22272 final class TypeParameters extends EditableSyntax {
22273   private EditableSyntax $_left_angle;
22274   private EditableSyntax $_parameters;
22275   private EditableSyntax $_right_angle;
22276   public function __construct(
22277     EditableSyntax $left_angle,
22278     EditableSyntax $parameters,
22279     EditableSyntax $right_angle) {
22280     parent::__construct('type_parameters');
22281     $this->_left_angle = $left_angle;
22282     $this->_parameters = $parameters;
22283     $this->_right_angle = $right_angle;
22284   }
22285   public function left_angle(): EditableSyntax {
22286     return $this->_left_angle;
22287   }
22288   public function parameters(): EditableSyntax {
22289     return $this->_parameters;
22290   }
22291   public function right_angle(): EditableSyntax {
22292     return $this->_right_angle;
22293   }
22294   public function with_left_angle(EditableSyntax $left_angle): TypeParameters {
22295     return new TypeParameters(
22296       $left_angle,
22297       $this->_parameters,
22298       $this->_right_angle);
22299   }
22300   public function with_parameters(EditableSyntax $parameters): TypeParameters {
22301     return new TypeParameters(
22302       $this->_left_angle,
22303       $parameters,
22304       $this->_right_angle);
22305   }
22306   public function with_right_angle(EditableSyntax $right_angle): TypeParameters {
22307     return new TypeParameters(
22308       $this->_left_angle,
22309       $this->_parameters,
22310       $right_angle);
22311   }
22312
22313   public function rewrite(
22314     ( function
22315       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
22316     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
22317     $new_parents = $parents ?? [];
22318     array_push($new_parents, $this);
22319     $left_angle = $this->left_angle()->rewrite($rewriter, $new_parents);
22320     $parameters = $this->parameters()->rewrite($rewriter, $new_parents);
22321     $right_angle = $this->right_angle()->rewrite($rewriter, $new_parents);
22322     if (
22323       $left_angle === $this->left_angle() &&
22324       $parameters === $this->parameters() &&
22325       $right_angle === $this->right_angle()) {
22326       return $rewriter($this, $parents ?? []);
22327     } else {
22328       return $rewriter(new TypeParameters(
22329         $left_angle,
22330         $parameters,
22331         $right_angle), $parents ?? []);
22332     }
22333   }
22334
22335   public static function from_json(mixed $json, int $position, string $source) {
22336     $left_angle = EditableSyntax::from_json(
22337       $json->type_parameters_left_angle, $position, $source);
22338     $position += $left_angle->width();
22339     $parameters = EditableSyntax::from_json(
22340       $json->type_parameters_parameters, $position, $source);
22341     $position += $parameters->width();
22342     $right_angle = EditableSyntax::from_json(
22343       $json->type_parameters_right_angle, $position, $source);
22344     $position += $right_angle->width();
22345     return new TypeParameters(
22346         $left_angle,
22347         $parameters,
22348         $right_angle);
22349   }
22350   public function children(): Generator<string, EditableSyntax, void> {
22351     yield $this->_left_angle;
22352     yield $this->_parameters;
22353     yield $this->_right_angle;
22354     yield break;
22355   }
22356 }
22357 final class TupleTypeSpecifier extends EditableSyntax {
22358   private EditableSyntax $_left_paren;
22359   private EditableSyntax $_types;
22360   private EditableSyntax $_right_paren;
22361   public function __construct(
22362     EditableSyntax $left_paren,
22363     EditableSyntax $types,
22364     EditableSyntax $right_paren) {
22365     parent::__construct('tuple_type_specifier');
22366     $this->_left_paren = $left_paren;
22367     $this->_types = $types;
22368     $this->_right_paren = $right_paren;
22369   }
22370   public function left_paren(): EditableSyntax {
22371     return $this->_left_paren;
22372   }
22373   public function types(): EditableSyntax {
22374     return $this->_types;
22375   }
22376   public function right_paren(): EditableSyntax {
22377     return $this->_right_paren;
22378   }
22379   public function with_left_paren(EditableSyntax $left_paren): TupleTypeSpecifier {
22380     return new TupleTypeSpecifier(
22381       $left_paren,
22382       $this->_types,
22383       $this->_right_paren);
22384   }
22385   public function with_types(EditableSyntax $types): TupleTypeSpecifier {
22386     return new TupleTypeSpecifier(
22387       $this->_left_paren,
22388       $types,
22389       $this->_right_paren);
22390   }
22391   public function with_right_paren(EditableSyntax $right_paren): TupleTypeSpecifier {
22392     return new TupleTypeSpecifier(
22393       $this->_left_paren,
22394       $this->_types,
22395       $right_paren);
22396   }
22397
22398   public function rewrite(
22399     ( function
22400       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
22401     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
22402     $new_parents = $parents ?? [];
22403     array_push($new_parents, $this);
22404     $left_paren = $this->left_paren()->rewrite($rewriter, $new_parents);
22405     $types = $this->types()->rewrite($rewriter, $new_parents);
22406     $right_paren = $this->right_paren()->rewrite($rewriter, $new_parents);
22407     if (
22408       $left_paren === $this->left_paren() &&
22409       $types === $this->types() &&
22410       $right_paren === $this->right_paren()) {
22411       return $rewriter($this, $parents ?? []);
22412     } else {
22413       return $rewriter(new TupleTypeSpecifier(
22414         $left_paren,
22415         $types,
22416         $right_paren), $parents ?? []);
22417     }
22418   }
22419
22420   public static function from_json(mixed $json, int $position, string $source) {
22421     $left_paren = EditableSyntax::from_json(
22422       $json->tuple_left_paren, $position, $source);
22423     $position += $left_paren->width();
22424     $types = EditableSyntax::from_json(
22425       $json->tuple_types, $position, $source);
22426     $position += $types->width();
22427     $right_paren = EditableSyntax::from_json(
22428       $json->tuple_right_paren, $position, $source);
22429     $position += $right_paren->width();
22430     return new TupleTypeSpecifier(
22431         $left_paren,
22432         $types,
22433         $right_paren);
22434   }
22435   public function children(): Generator<string, EditableSyntax, void> {
22436     yield $this->_left_paren;
22437     yield $this->_types;
22438     yield $this->_right_paren;
22439     yield break;
22440   }
22441 }
22442 final class ErrorSyntax extends EditableSyntax {
22443   private EditableSyntax $_error;
22444   public function __construct(
22445     EditableSyntax $error) {
22446     parent::__construct('error');
22447     $this->_error = $error;
22448   }
22449   public function error(): EditableSyntax {
22450     return $this->_error;
22451   }
22452   public function with_error(EditableSyntax $error): ErrorSyntax {
22453     return new ErrorSyntax(
22454       $error);
22455   }
22456
22457   public function rewrite(
22458     ( function
22459       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
22460     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
22461     $new_parents = $parents ?? [];
22462     array_push($new_parents, $this);
22463     $error = $this->error()->rewrite($rewriter, $new_parents);
22464     if (
22465       $error === $this->error()) {
22466       return $rewriter($this, $parents ?? []);
22467     } else {
22468       return $rewriter(new ErrorSyntax(
22469         $error), $parents ?? []);
22470     }
22471   }
22472
22473   public static function from_json(mixed $json, int $position, string $source) {
22474     $error = EditableSyntax::from_json(
22475       $json->error_error, $position, $source);
22476     $position += $error->width();
22477     return new ErrorSyntax(
22478         $error);
22479   }
22480   public function children(): Generator<string, EditableSyntax, void> {
22481     yield $this->_error;
22482     yield break;
22483   }
22484 }
22485 final class ListItem extends EditableSyntax {
22486   private EditableSyntax $_item;
22487   private EditableSyntax $_separator;
22488   public function __construct(
22489     EditableSyntax $item,
22490     EditableSyntax $separator) {
22491     parent::__construct('list_item');
22492     $this->_item = $item;
22493     $this->_separator = $separator;
22494   }
22495   public function item(): EditableSyntax {
22496     return $this->_item;
22497   }
22498   public function separator(): EditableSyntax {
22499     return $this->_separator;
22500   }
22501   public function with_item(EditableSyntax $item): ListItem {
22502     return new ListItem(
22503       $item,
22504       $this->_separator);
22505   }
22506   public function with_separator(EditableSyntax $separator): ListItem {
22507     return new ListItem(
22508       $this->_item,
22509       $separator);
22510   }
22511
22512   public function rewrite(
22513     ( function
22514       (EditableSyntax, ?array<EditableSyntax>): ?EditableSyntax ) $rewriter,
22515     ?array<EditableSyntax> $parents = null): ?EditableSyntax {
22516     $new_parents = $parents ?? [];
22517     array_push($new_parents, $this);
22518     $item = $this->item()->rewrite($rewriter, $new_parents);
22519     $separator = $this->separator()->rewrite($rewriter, $new_parents);
22520     if (
22521       $item === $this->item() &&
22522       $separator === $this->separator()) {
22523       return $rewriter($this, $parents ?? []);
22524     } else {
22525       return $rewriter(new ListItem(
22526         $item,
22527         $separator), $parents ?? []);
22528     }
22529   }
22530
22531   public static function from_json(mixed $json, int $position, string $source) {
22532     $item = EditableSyntax::from_json(
22533       $json->list_item, $position, $source);
22534     $position += $item->width();
22535     $separator = EditableSyntax::from_json(
22536       $json->list_separator, $position, $source);
22537     $position += $separator->width();
22538     return new ListItem(
22539         $item,
22540         $separator);
22541   }
22542   public function children(): Generator<string, EditableSyntax, void> {
22543     yield $this->_item;
22544     yield $this->_separator;
22545     yield break;
22546   }
22547 }
22548
22549
22550 function from_json(mixed $json): EditableSyntax {
22551   return EditableSyntax::from_json($json->parse_tree, 0, $json->program_text);
22552 }
22553 /* End full_fidelity_editable.php */