hphp/hack/src/parser/js/full_fidelity_editable.js

   1 /**
   2  * Copyright (c) 2016, Facebook, Inc.
   3  * All rights reserved.
   4  *
   5  * This source code is licensed under the MIT license found in the
   6  * LICENSE file in the "hack" directory of this source tree. An additional
   7  * directory.
   8  *
   9  **
  10  *
  11  * THIS FILE IS @generated; DO NOT EDIT IT
  12  * To regenerate this file, run
  13  *
  14  *   buck run //hphp/hack/src:generate_full_fidelity
  15  *
  16  **
  17  *
  18  */
  19
  20 "use strict";
  21
  22 let utils = require('./full_fidelity_utils.js');
  23 let array_map_reduce = utils.array_map_reduce;
  24 let array_sum = utils.array_sum;
  25
  26 class EditableSyntax
  27 {
  28   constructor(syntax_kind, children)
  29   {
  30     this._syntax_kind = syntax_kind;
  31     this._children = children;
  32     let width = 0;
  33     for(let child in children)
  34       width += children[child].width;
  35     this._children_width = width;
  36   }
  37   get syntax_kind() { return this._syntax_kind; }
  38   get children() { return this._children; }
  39   get is_token() { return false; }
  40   get is_trivia() { return false; }
  41   get is_list() { return false; }
  42   get is_missing() { return false; }
  43
  44   get width() { return this._children_width; }
  45
  46   get full_text()
  47   {
  48     let s = '';
  49     for(let key of this.children_keys)
  50       s += this.children[key].full_text;
  51     return s;
  52   }
  53
  54   static from_json(json, position, source)
  55   {
  56     switch(json.kind)
  57     {
  58     case 'token':
  59       return EditableToken.from_json(json.token, position, source);
  60     case 'list':
  61       return EditableList.from_json(json, position, source);
  62     case 'whitespace':
  63       return WhiteSpace.from_json(json, position, source);
  64     case 'end_of_line':
  65       return EndOfLine.from_json(json, position, source);
  66     case 'delimited_comment':
  67       return DelimitedComment.from_json(json, position, source);
  68     case 'single_line_comment':
  69       return SingleLineComment.from_json(json, position, source);
  70     case 'unsafe':
  71       return Unsafe.from_json(json, position, source);
  72     case 'unsafe_expression':
  73       return UnsafeExpression.from_json(json, position, source);
  74     case 'fix_me':
  75       return FixMe.from_json(json, position, source);
  76     case 'ignore_error':
  77       return IgnoreError.from_json(json, position, source);
  78     case 'fall_through':
  79       return FallThrough.from_json(json, position, source);
  80     case 'extra_token_error':
  81       return ExtraTokenError.from_json(json, position, source);
  82     case 'after_halt_compiler':
  83       return AfterHaltCompiler.from_json(json, position, source);
  84
  85     case 'missing':
  86       return Missing.missing;
  87     case 'end_of_file':
  88       return EndOfFile.from_json(json, position, source);
  89     case 'script':
  90       return Script.from_json(json, position, source);
  91     case 'qualified_name':
  92       return QualifiedName.from_json(json, position, source);
  93     case 'simple_type_specifier':
  94       return SimpleTypeSpecifier.from_json(json, position, source);
  95     case 'literal':
  96       return LiteralExpression.from_json(json, position, source);
  97     case 'prefixed_string':
  98       return PrefixedStringExpression.from_json(json, position, source);
  99     case 'variable':
 100       return VariableExpression.from_json(json, position, source);
 101     case 'pipe_variable':
 102       return PipeVariableExpression.from_json(json, position, source);
 103     case 'file_attribute_specification':
 104       return FileAttributeSpecification.from_json(json, position, source);
 105     case 'enum_declaration':
 106       return EnumDeclaration.from_json(json, position, source);
 107     case 'enumerator':
 108       return Enumerator.from_json(json, position, source);
 109     case 'alias_declaration':
 110       return AliasDeclaration.from_json(json, position, source);
 111     case 'property_declaration':
 112       return PropertyDeclaration.from_json(json, position, source);
 113     case 'property_declarator':
 114       return PropertyDeclarator.from_json(json, position, source);
 115     case 'namespace_declaration':
 116       return NamespaceDeclaration.from_json(json, position, source);
 117     case 'namespace_body':
 118       return NamespaceBody.from_json(json, position, source);
 119     case 'namespace_empty_body':
 120       return NamespaceEmptyBody.from_json(json, position, source);
 121     case 'namespace_use_declaration':
 122       return NamespaceUseDeclaration.from_json(json, position, source);
 123     case 'namespace_group_use_declaration':
 124       return NamespaceGroupUseDeclaration.from_json(json, position, source);
 125     case 'namespace_use_clause':
 126       return NamespaceUseClause.from_json(json, position, source);
 127     case 'function_declaration':
 128       return FunctionDeclaration.from_json(json, position, source);
 129     case 'function_declaration_header':
 130       return FunctionDeclarationHeader.from_json(json, position, source);
 131     case 'where_clause':
 132       return WhereClause.from_json(json, position, source);
 133     case 'where_constraint':
 134       return WhereConstraint.from_json(json, position, source);
 135     case 'methodish_declaration':
 136       return MethodishDeclaration.from_json(json, position, source);
 137     case 'methodish_trait_resolution':
 138       return MethodishTraitResolution.from_json(json, position, source);
 139     case 'classish_declaration':
 140       return ClassishDeclaration.from_json(json, position, source);
 141     case 'classish_body':
 142       return ClassishBody.from_json(json, position, source);
 143     case 'trait_use_precedence_item':
 144       return TraitUsePrecedenceItem.from_json(json, position, source);
 145     case 'trait_use_alias_item':
 146       return TraitUseAliasItem.from_json(json, position, source);
 147     case 'trait_use_conflict_resolution':
 148       return TraitUseConflictResolution.from_json(json, position, source);
 149     case 'trait_use':
 150       return TraitUse.from_json(json, position, source);
 151     case 'require_clause':
 152       return RequireClause.from_json(json, position, source);
 153     case 'const_declaration':
 154       return ConstDeclaration.from_json(json, position, source);
 155     case 'constant_declarator':
 156       return ConstantDeclarator.from_json(json, position, source);
 157     case 'type_const_declaration':
 158       return TypeConstDeclaration.from_json(json, position, source);
 159     case 'decorated_expression':
 160       return DecoratedExpression.from_json(json, position, source);
 161     case 'parameter_declaration':
 162       return ParameterDeclaration.from_json(json, position, source);
 163     case 'variadic_parameter':
 164       return VariadicParameter.from_json(json, position, source);
 165     case 'attribute_specification':
 166       return AttributeSpecification.from_json(json, position, source);
 167     case 'inclusion_expression':
 168       return InclusionExpression.from_json(json, position, source);
 169     case 'inclusion_directive':
 170       return InclusionDirective.from_json(json, position, source);
 171     case 'compound_statement':
 172       return CompoundStatement.from_json(json, position, source);
 173     case 'alternate_loop_statement':
 174       return AlternateLoopStatement.from_json(json, position, source);
 175     case 'expression_statement':
 176       return ExpressionStatement.from_json(json, position, source);
 177     case 'markup_section':
 178       return MarkupSection.from_json(json, position, source);
 179     case 'markup_suffix':
 180       return MarkupSuffix.from_json(json, position, source);
 181     case 'unset_statement':
 182       return UnsetStatement.from_json(json, position, source);
 183     case 'let_statement':
 184       return LetStatement.from_json(json, position, source);
 185     case 'using_statement_block_scoped':
 186       return UsingStatementBlockScoped.from_json(json, position, source);
 187     case 'using_statement_function_scoped':
 188       return UsingStatementFunctionScoped.from_json(json, position, source);
 189     case 'declare_directive_statement':
 190       return DeclareDirectiveStatement.from_json(json, position, source);
 191     case 'declare_block_statement':
 192       return DeclareBlockStatement.from_json(json, position, source);
 193     case 'while_statement':
 194       return WhileStatement.from_json(json, position, source);
 195     case 'if_statement':
 196       return IfStatement.from_json(json, position, source);
 197     case 'elseif_clause':
 198       return ElseifClause.from_json(json, position, source);
 199     case 'else_clause':
 200       return ElseClause.from_json(json, position, source);
 201     case 'alternate_if_statement':
 202       return AlternateIfStatement.from_json(json, position, source);
 203     case 'alternate_elseif_clause':
 204       return AlternateElseifClause.from_json(json, position, source);
 205     case 'alternate_else_clause':
 206       return AlternateElseClause.from_json(json, position, source);
 207     case 'try_statement':
 208       return TryStatement.from_json(json, position, source);
 209     case 'catch_clause':
 210       return CatchClause.from_json(json, position, source);
 211     case 'finally_clause':
 212       return FinallyClause.from_json(json, position, source);
 213     case 'do_statement':
 214       return DoStatement.from_json(json, position, source);
 215     case 'for_statement':
 216       return ForStatement.from_json(json, position, source);
 217     case 'foreach_statement':
 218       return ForeachStatement.from_json(json, position, source);
 219     case 'switch_statement':
 220       return SwitchStatement.from_json(json, position, source);
 221     case 'alternate_switch_statement':
 222       return AlternateSwitchStatement.from_json(json, position, source);
 223     case 'switch_section':
 224       return SwitchSection.from_json(json, position, source);
 225     case 'switch_fallthrough':
 226       return SwitchFallthrough.from_json(json, position, source);
 227     case 'case_label':
 228       return CaseLabel.from_json(json, position, source);
 229     case 'default_label':
 230       return DefaultLabel.from_json(json, position, source);
 231     case 'return_statement':
 232       return ReturnStatement.from_json(json, position, source);
 233     case 'goto_label':
 234       return GotoLabel.from_json(json, position, source);
 235     case 'goto_statement':
 236       return GotoStatement.from_json(json, position, source);
 237     case 'throw_statement':
 238       return ThrowStatement.from_json(json, position, source);
 239     case 'break_statement':
 240       return BreakStatement.from_json(json, position, source);
 241     case 'continue_statement':
 242       return ContinueStatement.from_json(json, position, source);
 243     case 'echo_statement':
 244       return EchoStatement.from_json(json, position, source);
 245     case 'global_statement':
 246       return GlobalStatement.from_json(json, position, source);
 247     case 'concurrent_statement':
 248       return ConcurrentStatement.from_json(json, position, source);
 249     case 'simple_initializer':
 250       return SimpleInitializer.from_json(json, position, source);
 251     case 'anonymous_class':
 252       return AnonymousClass.from_json(json, position, source);
 253     case 'anonymous_function':
 254       return AnonymousFunction.from_json(json, position, source);
 255     case 'php7_anonymous_function':
 256       return Php7AnonymousFunction.from_json(json, position, source);
 257     case 'anonymous_function_use_clause':
 258       return AnonymousFunctionUseClause.from_json(json, position, source);
 259     case 'lambda_expression':
 260       return LambdaExpression.from_json(json, position, source);
 261     case 'lambda_signature':
 262       return LambdaSignature.from_json(json, position, source);
 263     case 'cast_expression':
 264       return CastExpression.from_json(json, position, source);
 265     case 'scope_resolution_expression':
 266       return ScopeResolutionExpression.from_json(json, position, source);
 267     case 'member_selection_expression':
 268       return MemberSelectionExpression.from_json(json, position, source);
 269     case 'safe_member_selection_expression':
 270       return SafeMemberSelectionExpression.from_json(json, position, source);
 271     case 'embedded_member_selection_expression':
 272       return EmbeddedMemberSelectionExpression.from_json(json, position, source);
 273     case 'yield_expression':
 274       return YieldExpression.from_json(json, position, source);
 275     case 'yield_from_expression':
 276       return YieldFromExpression.from_json(json, position, source);
 277     case 'prefix_unary_expression':
 278       return PrefixUnaryExpression.from_json(json, position, source);
 279     case 'postfix_unary_expression':
 280       return PostfixUnaryExpression.from_json(json, position, source);
 281     case 'binary_expression':
 282       return BinaryExpression.from_json(json, position, source);
 283     case 'instanceof_expression':
 284       return InstanceofExpression.from_json(json, position, source);
 285     case 'is_expression':
 286       return IsExpression.from_json(json, position, source);
 287     case 'as_expression':
 288       return AsExpression.from_json(json, position, source);
 289     case 'nullable_as_expression':
 290       return NullableAsExpression.from_json(json, position, source);
 291     case 'conditional_expression':
 292       return ConditionalExpression.from_json(json, position, source);
 293     case 'eval_expression':
 294       return EvalExpression.from_json(json, position, source);
 295     case 'empty_expression':
 296       return EmptyExpression.from_json(json, position, source);
 297     case 'define_expression':
 298       return DefineExpression.from_json(json, position, source);
 299     case 'halt_compiler_expression':
 300       return HaltCompilerExpression.from_json(json, position, source);
 301     case 'isset_expression':
 302       return IssetExpression.from_json(json, position, source);
 303     case 'function_call_expression':
 304       return FunctionCallExpression.from_json(json, position, source);
 305     case 'function_call_with_type_arguments_expression':
 306       return FunctionCallWithTypeArgumentsExpression.from_json(json, position, source);
 307     case 'parenthesized_expression':
 308       return ParenthesizedExpression.from_json(json, position, source);
 309     case 'braced_expression':
 310       return BracedExpression.from_json(json, position, source);
 311     case 'embedded_braced_expression':
 312       return EmbeddedBracedExpression.from_json(json, position, source);
 313     case 'list_expression':
 314       return ListExpression.from_json(json, position, source);
 315     case 'collection_literal_expression':
 316       return CollectionLiteralExpression.from_json(json, position, source);
 317     case 'object_creation_expression':
 318       return ObjectCreationExpression.from_json(json, position, source);
 319     case 'constructor_call':
 320       return ConstructorCall.from_json(json, position, source);
 321     case 'array_creation_expression':
 322       return ArrayCreationExpression.from_json(json, position, source);
 323     case 'array_intrinsic_expression':
 324       return ArrayIntrinsicExpression.from_json(json, position, source);
 325     case 'darray_intrinsic_expression':
 326       return DarrayIntrinsicExpression.from_json(json, position, source);
 327     case 'dictionary_intrinsic_expression':
 328       return DictionaryIntrinsicExpression.from_json(json, position, source);
 329     case 'keyset_intrinsic_expression':
 330       return KeysetIntrinsicExpression.from_json(json, position, source);
 331     case 'varray_intrinsic_expression':
 332       return VarrayIntrinsicExpression.from_json(json, position, source);
 333     case 'vector_intrinsic_expression':
 334       return VectorIntrinsicExpression.from_json(json, position, source);
 335     case 'element_initializer':
 336       return ElementInitializer.from_json(json, position, source);
 337     case 'subscript_expression':
 338       return SubscriptExpression.from_json(json, position, source);
 339     case 'embedded_subscript_expression':
 340       return EmbeddedSubscriptExpression.from_json(json, position, source);
 341     case 'awaitable_creation_expression':
 342       return AwaitableCreationExpression.from_json(json, position, source);
 343     case 'xhp_children_declaration':
 344       return XHPChildrenDeclaration.from_json(json, position, source);
 345     case 'xhp_children_parenthesized_list':
 346       return XHPChildrenParenthesizedList.from_json(json, position, source);
 347     case 'xhp_category_declaration':
 348       return XHPCategoryDeclaration.from_json(json, position, source);
 349     case 'xhp_enum_type':
 350       return XHPEnumType.from_json(json, position, source);
 351     case 'xhp_required':
 352       return XHPRequired.from_json(json, position, source);
 353     case 'xhp_class_attribute_declaration':
 354       return XHPClassAttributeDeclaration.from_json(json, position, source);
 355     case 'xhp_class_attribute':
 356       return XHPClassAttribute.from_json(json, position, source);
 357     case 'xhp_simple_class_attribute':
 358       return XHPSimpleClassAttribute.from_json(json, position, source);
 359     case 'xhp_simple_attribute':
 360       return XHPSimpleAttribute.from_json(json, position, source);
 361     case 'xhp_spread_attribute':
 362       return XHPSpreadAttribute.from_json(json, position, source);
 363     case 'xhp_open':
 364       return XHPOpen.from_json(json, position, source);
 365     case 'xhp_expression':
 366       return XHPExpression.from_json(json, position, source);
 367     case 'xhp_close':
 368       return XHPClose.from_json(json, position, source);
 369     case 'type_constant':
 370       return TypeConstant.from_json(json, position, source);
 371     case 'vector_type_specifier':
 372       return VectorTypeSpecifier.from_json(json, position, source);
 373     case 'keyset_type_specifier':
 374       return KeysetTypeSpecifier.from_json(json, position, source);
 375     case 'tuple_type_explicit_specifier':
 376       return TupleTypeExplicitSpecifier.from_json(json, position, source);
 377     case 'varray_type_specifier':
 378       return VarrayTypeSpecifier.from_json(json, position, source);
 379     case 'vector_array_type_specifier':
 380       return VectorArrayTypeSpecifier.from_json(json, position, source);
 381     case 'type_parameter':
 382       return TypeParameter.from_json(json, position, source);
 383     case 'type_constraint':
 384       return TypeConstraint.from_json(json, position, source);
 385     case 'darray_type_specifier':
 386       return DarrayTypeSpecifier.from_json(json, position, source);
 387     case 'map_array_type_specifier':
 388       return MapArrayTypeSpecifier.from_json(json, position, source);
 389     case 'dictionary_type_specifier':
 390       return DictionaryTypeSpecifier.from_json(json, position, source);
 391     case 'closure_type_specifier':
 392       return ClosureTypeSpecifier.from_json(json, position, source);
 393     case 'closure_parameter_type_specifier':
 394       return ClosureParameterTypeSpecifier.from_json(json, position, source);
 395     case 'classname_type_specifier':
 396       return ClassnameTypeSpecifier.from_json(json, position, source);
 397     case 'field_specifier':
 398       return FieldSpecifier.from_json(json, position, source);
 399     case 'field_initializer':
 400       return FieldInitializer.from_json(json, position, source);
 401     case 'shape_type_specifier':
 402       return ShapeTypeSpecifier.from_json(json, position, source);
 403     case 'shape_expression':
 404       return ShapeExpression.from_json(json, position, source);
 405     case 'tuple_expression':
 406       return TupleExpression.from_json(json, position, source);
 407     case 'generic_type_specifier':
 408       return GenericTypeSpecifier.from_json(json, position, source);
 409     case 'nullable_type_specifier':
 410       return NullableTypeSpecifier.from_json(json, position, source);
 411     case 'soft_type_specifier':
 412       return SoftTypeSpecifier.from_json(json, position, source);
 413     case 'reified_type_argument':
 414       return ReifiedTypeArgument.from_json(json, position, source);
 415     case 'type_arguments':
 416       return TypeArguments.from_json(json, position, source);
 417     case 'type_parameters':
 418       return TypeParameters.from_json(json, position, source);
 419     case 'tuple_type_specifier':
 420       return TupleTypeSpecifier.from_json(json, position, source);
 421     case 'error':
 422       return ErrorSyntax.from_json(json, position, source);
 423     case 'list_item':
 424       return ListItem.from_json(json, position, source);
 425     case 'pocket_atom':
 426       return PocketAtomExpression.from_json(json, position, source);
 427     case 'pocket_identifier':
 428       return PocketIdentifierExpression.from_json(json, position, source);
 429     case 'pocket_atom_mapping':
 430       return PocketAtomMappingDeclaration.from_json(json, position, source);
 431     case 'pocket_enum_declaration':
 432       return PocketEnumDeclaration.from_json(json, position, source);
 433     case 'pocket_field_type_expr_declaration':
 434       return PocketFieldTypeExprDeclaration.from_json(json, position, source);
 435     case 'pocket_field_type_declaration':
 436       return PocketFieldTypeDeclaration.from_json(json, position, source);
 437     case 'pocket_mapping_id_declaration':
 438       return PocketMappingIdDeclaration.from_json(json, position, source);
 439     case 'pocket_mapping_type_declaration':
 440       return PocketMappingTypeDeclaration.from_json(json, position, source);
 441
 442     default:
 443       throw 'unexpected json kind: ' + json.kind; // TODO: Better exception
 444     }
 445   }
 446
 447   reduce(reducer, accumulator, parents)
 448   {
 449     if (parents == undefined)
 450       parents = [];
 451     let new_parents = parents.slice();
 452     new_parents.push(this);
 453     for(let key of this.children_keys)
 454     {
 455       accumulator = this.children[key].reduce(
 456         reducer, accumulator, new_parents);
 457     }
 458     return reducer(this, accumulator, parents);
 459   }
 460
 461   // Returns all the parents (and the node itself) of the first node
 462   // that matches a predicate, or [] if there is no such node.
 463   find(predicate, parents)
 464   {
 465     if (parents == undefined)
 466       parents = [];
 467     let new_parents = parents.slice();
 468     new_parents.push(this);
 469     if (predicate(this))
 470       return new_parents;
 471     for(let key of this.children_keys)
 472     {
 473       let result = this.children[key].find(predicate, new_parents);
 474       if (result.length != 0)
 475         return result;
 476     }
 477     return [];
 478   }
 479
 480   // Returns a list of nodes that match a predicate.
 481   filter(predicate)
 482   {
 483     let reducer = (node, acc, parents) => {
 484       if (predicate(node))
 485         acc.push(node);
 486       return acc;
 487     };
 488     return this.reduce(reducer, []);
 489   }
 490
 491   of_syntax_kind(kind)
 492   {
 493     return this.filter((node) => node.syntax_kind == kind);
 494   }
 495
 496   remove_where(predicate)
 497   {
 498     return this.rewrite(
 499       (node, parents) => predicate(node) ? Missing.missing : node);
 500   }
 501
 502   without(target)
 503   {
 504     return this.remove_where((node) => node === target);
 505   }
 506
 507   replace(new_node, target)
 508   {
 509     return this.rewrite((node, parents) => node === target ? new_node : node);
 510   }
 511
 512   pre_order(action, parents)
 513   {
 514     if (parents == undefined)
 515       parents = [];
 516     action(this, parents);
 517     let new_parents = parents.slice();
 518     new_parents.push(this);
 519     for(let key of this.children_keys)
 520       this.children[key].pre_order(action, new_parents);
 521   }
 522
 523   get leftmost_token()
 524   {
 525     if (this.is_token)
 526       return this;
 527
 528     for(let key of this.children_keys)
 529     {
 530       if (!this.children[key].is_missing)
 531         return this.children[key].leftmost_token;
 532     }
 533     return null;
 534   }
 535
 536   get rightmost_token()
 537   {
 538     if (this.is_token)
 539       return this;
 540
 541     for (let i = this.children_keys.length - 1; i >= 0; i--)
 542     {
 543       if (!this.children[this.children_keys[i]].is_missing)
 544         return this.children[key].rightmost_token;
 545     }
 546     return null;
 547   }
 548
 549   insert_before(new_node, target)
 550   {
 551     // Inserting before missing is an error.
 552     if (target.is_missing)
 553       throw 'Target must not be missing in insert_before.';
 554
 555     // Inserting missing is a no-op
 556     if (new_node.is_missing)
 557       return this;
 558
 559     if (new_node.is_trivia && !target.is_trivia)
 560     {
 561       let token = target.is_token ? target : target.leftmost_token;
 562       if (token == null)
 563         throw 'Unable to find token to insert trivia.';
 564
 565       // Inserting trivia before token is inserting to the right end of
 566       // the leading trivia.
 567       let new_leading = EditableSyntax.concatenate_lists(
 568         token.leading, new_node);
 569       let new_token = token.with_leading(new_leading);
 570       return this.replace(new_token, token);
 571     }
 572
 573     return this.replace(
 574       EditableSyntax.concatenate_lists(new_node, target), target);
 575   }
 576
 577   insert_after(new_node, target)
 578   {
 579     // Inserting after missing is an error.
 580     if (target.is_missing)
 581       throw 'Target must not be missing in insert_after.';
 582
 583     // Inserting missing is a no-op
 584     if (new_node.is_missing)
 585       return this;
 586
 587     if (new_node.is_trivia && !target.is_trivia)
 588     {
 589       let token = target.is_token ? target : target.rightmost_token;
 590       if (token == null)
 591         throw 'Unable to find token to insert trivia.';
 592
 593       // Inserting trivia after token is inserting to the left end of
 594       // the trailing trivia.
 595       let new_trailing = EditableSyntax.concatenate_lists(
 596         new_node, token.trailing);
 597       let new_token = token.with_trailing(new_trailing);
 598       return this.replace(new_token, token);
 599     }
 600
 601     return this.replace(
 602       EditableSyntax.concatenate_lists(target, new_node), target);
 603   }
 604
 605   static to_list(syntax_list)
 606   {
 607     if (syntax_list.length == 0)
 608       return Missing.missing;
 609     else
 610       return new EditableList(syntax_list);
 611   }
 612
 613   static concatenate_lists(left, right)
 614   {
 615     if (left.is_missing)
 616       return right;
 617     if (right.is_missing)
 618       return left;
 619     if (left.is_list && right.is_list)
 620       return new EditableList(left.children.concat(right.children));
 621     if (left.is_list)
 622       return new EditableList(left.children.splice().push(right));
 623     if (right.is_list)
 624       return new EditableList([right].concat(left.children));
 625     return new EditableList([left, right]);
 626   }
 627 }
 628
 629 class EditableList extends EditableSyntax
 630 {
 631   constructor(children)
 632   {
 633     super('list', children);
 634   }
 635   get is_list() { return true; }
 636
 637   static from_json(json, position, source)
 638   {
 639     let children = [];
 640     let current_position = position;
 641     for(let element of json.elements)
 642     {
 643       let child = EditableSyntax.from_json(element, current_position, source);
 644       children.push(child);
 645       current_position += child.width;
 646     }
 647     return new EditableList(children);
 648   }
 649
 650   rewrite(rewriter, parents)
 651   {
 652     let dirty = false;
 653     let new_children = [];
 654     let new_parents = parents.slice();
 655     new_parents.push(this);
 656     for (let key of this.children_keys)
 657     {
 658       let child = this.children[key];
 659       let new_child = child.rewrite(rewriter, new_parents);
 660       if (new_child != child)
 661         dirty = true;
 662       if (new_child != null)
 663       {
 664         if (new_child.is_list)
 665         {
 666           for(let n of new_child.children)
 667             new_children.push(n);
 668         }
 669         else
 670           new_children.push(new_child);
 671       }
 672     }
 673     let result = this;
 674     if (dirty)
 675     {
 676       if (new_children.length === 0)
 677         result = Missing.missing;
 678       else if (new_children.length === 1)
 679         result = new_children[0];
 680       else
 681         result = new EditableList(new_children);
 682     }
 683     return rewriter(result, parents);
 684   }
 685   get children_keys()
 686   {
 687     return Object.keys(this.children);
 688   }
 689 }
 690
 691 class EditableToken extends EditableSyntax
 692 {
 693   constructor(token_kind, leading, trailing, text)
 694   {
 695     super('token', { leading : leading, trailing : trailing });
 696     this._token_kind = token_kind;
 697     this._text = text;
 698   }
 699
 700   get token_kind() { return this._token_kind; }
 701   get text() { return this._text; }
 702   get leading() { return this.children.leading; }
 703   get trailing() { return this.children.trailing; }
 704   get width()
 705   {
 706     return this.text.length + this.leading.width + this.trailing.width;
 707   }
 708   get is_token() { return true; }
 709   get full_text()
 710   {
 711     return this.leading.full_text + this.text + this.trailing.full_text;
 712   }
 713   with_leading(leading)
 714   {
 715     return EditableToken.factory(
 716       this.token_kind, leading, this.trailing, this.text);
 717   }
 718   with_trailing(trailing)
 719   {
 720     return EditableToken.factory(
 721       this.token_kind, this.leading, trailing, this.text);
 722   }
 723   static factory(token_kind, leading, trailing, token_text)
 724   {
 725     switch(token_kind)
 726     {
 727     case 'end_of_file':
 728        return new EndOfFileToken(leading, trailing);
 729
 730     case 'abstract':
 731        return new AbstractToken(leading, trailing);
 732     case 'and':
 733        return new AndToken(leading, trailing);
 734     case 'array':
 735        return new ArrayToken(leading, trailing);
 736     case 'arraykey':
 737        return new ArraykeyToken(leading, trailing);
 738     case 'as':
 739        return new AsToken(leading, trailing);
 740     case 'async':
 741        return new AsyncToken(leading, trailing);
 742     case 'attribute':
 743        return new AttributeToken(leading, trailing);
 744     case 'await':
 745        return new AwaitToken(leading, trailing);
 746     case '\':
 747        return new BackslashToken(leading, trailing);
 748     case 'binary':
 749        return new BinaryToken(leading, trailing);
 750     case 'bool':
 751        return new BoolToken(leading, trailing);
 752     case 'boolean':
 753        return new BooleanToken(leading, trailing);
 754     case 'break':
 755        return new BreakToken(leading, trailing);
 756     case 'case':
 757        return new CaseToken(leading, trailing);
 758     case 'catch':
 759        return new CatchToken(leading, trailing);
 760     case 'category':
 761        return new CategoryToken(leading, trailing);
 762     case 'children':
 763        return new ChildrenToken(leading, trailing);
 764     case 'class':
 765        return new ClassToken(leading, trailing);
 766     case 'classname':
 767        return new ClassnameToken(leading, trailing);
 768     case 'clone':
 769        return new CloneToken(leading, trailing);
 770     case 'const':
 771        return new ConstToken(leading, trailing);
 772     case '__construct':
 773        return new ConstructToken(leading, trailing);
 774     case 'continue':
 775        return new ContinueToken(leading, trailing);
 776     case 'coroutine':
 777        return new CoroutineToken(leading, trailing);
 778     case 'darray':
 779        return new DarrayToken(leading, trailing);
 780     case 'declare':
 781        return new DeclareToken(leading, trailing);
 782     case 'default':
 783        return new DefaultToken(leading, trailing);
 784     case 'define':
 785        return new DefineToken(leading, trailing);
 786     case '__destruct':
 787        return new DestructToken(leading, trailing);
 788     case 'dict':
 789        return new DictToken(leading, trailing);
 790     case 'do':
 791        return new DoToken(leading, trailing);
 792     case 'double':
 793        return new DoubleToken(leading, trailing);
 794     case 'echo':
 795        return new EchoToken(leading, trailing);
 796     case 'else':
 797        return new ElseToken(leading, trailing);
 798     case 'elseif':
 799        return new ElseifToken(leading, trailing);
 800     case 'empty':
 801        return new EmptyToken(leading, trailing);
 802     case 'endfor':
 803        return new EndforToken(leading, trailing);
 804     case 'endforeach':
 805        return new EndforeachToken(leading, trailing);
 806     case 'enddeclare':
 807        return new EnddeclareToken(leading, trailing);
 808     case 'endif':
 809        return new EndifToken(leading, trailing);
 810     case 'endswitch':
 811        return new EndswitchToken(leading, trailing);
 812     case 'endwhile':
 813        return new EndwhileToken(leading, trailing);
 814     case 'enum':
 815        return new EnumToken(leading, trailing);
 816     case 'eval':
 817        return new EvalToken(leading, trailing);
 818     case 'extends':
 819        return new ExtendsToken(leading, trailing);
 820     case 'fallthrough':
 821        return new FallthroughToken(leading, trailing);
 822     case 'float':
 823        return new FloatToken(leading, trailing);
 824     case 'file':
 825        return new FileToken(leading, trailing);
 826     case 'final':
 827        return new FinalToken(leading, trailing);
 828     case 'finally':
 829        return new FinallyToken(leading, trailing);
 830     case 'for':
 831        return new ForToken(leading, trailing);
 832     case 'foreach':
 833        return new ForeachToken(leading, trailing);
 834     case 'from':
 835        return new FromToken(leading, trailing);
 836     case 'function':
 837        return new FunctionToken(leading, trailing);
 838     case 'global':
 839        return new GlobalToken(leading, trailing);
 840     case 'concurrent':
 841        return new ConcurrentToken(leading, trailing);
 842     case 'goto':
 843        return new GotoToken(leading, trailing);
 844     case '__halt_compiler':
 845        return new HaltCompilerToken(leading, trailing);
 846     case 'if':
 847        return new IfToken(leading, trailing);
 848     case 'implements':
 849        return new ImplementsToken(leading, trailing);
 850     case 'include':
 851        return new IncludeToken(leading, trailing);
 852     case 'include_once':
 853        return new Include_onceToken(leading, trailing);
 854     case 'inout':
 855        return new InoutToken(leading, trailing);
 856     case 'instanceof':
 857        return new InstanceofToken(leading, trailing);
 858     case 'insteadof':
 859        return new InsteadofToken(leading, trailing);
 860     case 'int':
 861        return new IntToken(leading, trailing);
 862     case 'integer':
 863        return new IntegerToken(leading, trailing);
 864     case 'interface':
 865        return new InterfaceToken(leading, trailing);
 866     case 'is':
 867        return new IsToken(leading, trailing);
 868     case 'isset':
 869        return new IssetToken(leading, trailing);
 870     case 'keyset':
 871        return new KeysetToken(leading, trailing);
 872     case 'let':
 873        return new LetToken(leading, trailing);
 874     case 'list':
 875        return new ListToken(leading, trailing);
 876     case 'mixed':
 877        return new MixedToken(leading, trailing);
 878     case 'namespace':
 879        return new NamespaceToken(leading, trailing);
 880     case 'new':
 881        return new NewToken(leading, trailing);
 882     case 'newtype':
 883        return new NewtypeToken(leading, trailing);
 884     case 'noreturn':
 885        return new NoreturnToken(leading, trailing);
 886     case 'num':
 887        return new NumToken(leading, trailing);
 888     case 'object':
 889        return new ObjectToken(leading, trailing);
 890     case 'or':
 891        return new OrToken(leading, trailing);
 892     case 'parent':
 893        return new ParentToken(leading, trailing);
 894     case 'print':
 895        return new PrintToken(leading, trailing);
 896     case 'private':
 897        return new PrivateToken(leading, trailing);
 898     case 'protected':
 899        return new ProtectedToken(leading, trailing);
 900     case 'public':
 901        return new PublicToken(leading, trailing);
 902     case 'real':
 903        return new RealToken(leading, trailing);
 904     case 'reify':
 905        return new ReifyToken(leading, trailing);
 906     case 'require':
 907        return new RequireToken(leading, trailing);
 908     case 'require_once':
 909        return new Require_onceToken(leading, trailing);
 910     case 'required':
 911        return new RequiredToken(leading, trailing);
 912     case 'resource':
 913        return new ResourceToken(leading, trailing);
 914     case 'return':
 915        return new ReturnToken(leading, trailing);
 916     case 'self':
 917        return new SelfToken(leading, trailing);
 918     case 'shape':
 919        return new ShapeToken(leading, trailing);
 920     case 'static':
 921        return new StaticToken(leading, trailing);
 922     case 'string':
 923        return new StringToken(leading, trailing);
 924     case 'super':
 925        return new SuperToken(leading, trailing);
 926     case 'suspend':
 927        return new SuspendToken(leading, trailing);
 928     case 'switch':
 929        return new SwitchToken(leading, trailing);
 930     case 'this':
 931        return new ThisToken(leading, trailing);
 932     case 'throw':
 933        return new ThrowToken(leading, trailing);
 934     case 'trait':
 935        return new TraitToken(leading, trailing);
 936     case 'try':
 937        return new TryToken(leading, trailing);
 938     case 'tuple':
 939        return new TupleToken(leading, trailing);
 940     case 'type':
 941        return new TypeToken(leading, trailing);
 942     case 'unset':
 943        return new UnsetToken(leading, trailing);
 944     case 'use':
 945        return new UseToken(leading, trailing);
 946     case 'using':
 947        return new UsingToken(leading, trailing);
 948     case 'var':
 949        return new VarToken(leading, trailing);
 950     case 'varray':
 951        return new VarrayToken(leading, trailing);
 952     case 'vec':
 953        return new VecToken(leading, trailing);
 954     case 'void':
 955        return new VoidToken(leading, trailing);
 956     case 'where':
 957        return new WhereToken(leading, trailing);
 958     case 'while':
 959        return new WhileToken(leading, trailing);
 960     case 'xor':
 961        return new XorToken(leading, trailing);
 962     case 'yield':
 963        return new YieldToken(leading, trailing);
 964     case 'null':
 965        return new NullLiteralToken(leading, trailing);
 966     case '[':
 967        return new LeftBracketToken(leading, trailing);
 968     case ']':
 969        return new RightBracketToken(leading, trailing);
 970     case '(':
 971        return new LeftParenToken(leading, trailing);
 972     case ')':
 973        return new RightParenToken(leading, trailing);
 974     case '{':
 975        return new LeftBraceToken(leading, trailing);
 976     case '}':
 977        return new RightBraceToken(leading, trailing);
 978     case '.':
 979        return new DotToken(leading, trailing);
 980     case '->':
 981        return new MinusGreaterThanToken(leading, trailing);
 982     case '++':
 983        return new PlusPlusToken(leading, trailing);
 984     case '--':
 985        return new MinusMinusToken(leading, trailing);
 986     case '**':
 987        return new StarStarToken(leading, trailing);
 988     case '*':
 989        return new StarToken(leading, trailing);
 990     case '+':
 991        return new PlusToken(leading, trailing);
 992     case '-':
 993        return new MinusToken(leading, trailing);
 994     case '~':
 995        return new TildeToken(leading, trailing);
 996     case '!':
 997        return new ExclamationToken(leading, trailing);
 998     case '$':
 999        return new DollarToken(leading, trailing);
1000     case '/':
1001        return new SlashToken(leading, trailing);
1002     case '%':
1003        return new PercentToken(leading, trailing);
1004     case '<>':
1005        return new LessThanGreaterThanToken(leading, trailing);
1006     case '<=>':
1007        return new LessThanEqualGreaterThanToken(leading, trailing);
1008     case '<<':
1009        return new LessThanLessThanToken(leading, trailing);
1010     case '>>':
1011        return new GreaterThanGreaterThanToken(leading, trailing);
1012     case '<':
1013        return new LessThanToken(leading, trailing);
1014     case '>':
1015        return new GreaterThanToken(leading, trailing);
1016     case '<=':
1017        return new LessThanEqualToken(leading, trailing);
1018     case '>=':
1019        return new GreaterThanEqualToken(leading, trailing);
1020     case '==':
1021        return new EqualEqualToken(leading, trailing);
1022     case '===':
1023        return new EqualEqualEqualToken(leading, trailing);
1024     case '!=':
1025        return new ExclamationEqualToken(leading, trailing);
1026     case '!==':
1027        return new ExclamationEqualEqualToken(leading, trailing);
1028     case '^':
1029        return new CaratToken(leading, trailing);
1030     case '|':
1031        return new BarToken(leading, trailing);
1032     case '&':
1033        return new AmpersandToken(leading, trailing);
1034     case '&&':
1035        return new AmpersandAmpersandToken(leading, trailing);
1036     case '||':
1037        return new BarBarToken(leading, trailing);
1038     case '?':
1039        return new QuestionToken(leading, trailing);
1040     case '?as':
1041        return new QuestionAsToken(leading, trailing);
1042     case '?:':
1043        return new QuestionColonToken(leading, trailing);
1044     case '??':
1045        return new QuestionQuestionToken(leading, trailing);
1046     case '??=':
1047        return new QuestionQuestionEqualToken(leading, trailing);
1048     case ':':
1049        return new ColonToken(leading, trailing);
1050     case ';':
1051        return new SemicolonToken(leading, trailing);
1052     case '=':
1053        return new EqualToken(leading, trailing);
1054     case '**=':
1055        return new StarStarEqualToken(leading, trailing);
1056     case '*=':
1057        return new StarEqualToken(leading, trailing);
1058     case '/=':
1059        return new SlashEqualToken(leading, trailing);
1060     case '%=':
1061        return new PercentEqualToken(leading, trailing);
1062     case '+=':
1063        return new PlusEqualToken(leading, trailing);
1064     case '-=':
1065        return new MinusEqualToken(leading, trailing);
1066     case '.=':
1067        return new DotEqualToken(leading, trailing);
1068     case '<<=':
1069        return new LessThanLessThanEqualToken(leading, trailing);
1070     case '>>=':
1071        return new GreaterThanGreaterThanEqualToken(leading, trailing);
1072     case '&=':
1073        return new AmpersandEqualToken(leading, trailing);
1074     case '^=':
1075        return new CaratEqualToken(leading, trailing);
1076     case '|=':
1077        return new BarEqualToken(leading, trailing);
1078     case ',':
1079        return new CommaToken(leading, trailing);
1080     case '@':
1081        return new AtToken(leading, trailing);
1082     case '::':
1083        return new ColonColonToken(leading, trailing);
1084     case '=>':
1085        return new EqualGreaterThanToken(leading, trailing);
1086     case '==>':
1087        return new EqualEqualGreaterThanToken(leading, trailing);
1088     case '?->':
1089        return new QuestionMinusGreaterThanToken(leading, trailing);
1090     case '...':
1091        return new DotDotDotToken(leading, trailing);
1092     case '$$':
1093        return new DollarDollarToken(leading, trailing);
1094     case '|>':
1095        return new BarGreaterThanToken(leading, trailing);
1096     case '/>':
1097        return new SlashGreaterThanToken(leading, trailing);
1098     case '</':
1099        return new LessThanSlashToken(leading, trailing);
1100     case '<?':
1101        return new LessThanQuestionToken(leading, trailing);
1102     case '?>':
1103        return new QuestionGreaterThanToken(leading, trailing);
1104     case ':@':
1105        return new ColonAtToken(leading, trailing);
1106
1107     case 'error_token':
1108        return new ErrorTokenToken(leading, trailing, token_text);
1109     case 'name':
1110        return new NameToken(leading, trailing, token_text);
1111     case 'variable':
1112        return new VariableToken(leading, trailing, token_text);
1113     case 'decimal_literal':
1114        return new DecimalLiteralToken(leading, trailing, token_text);
1115     case 'octal_literal':
1116        return new OctalLiteralToken(leading, trailing, token_text);
1117     case 'hexadecimal_literal':
1118        return new HexadecimalLiteralToken(leading, trailing, token_text);
1119     case 'binary_literal':
1120        return new BinaryLiteralToken(leading, trailing, token_text);
1121     case 'floating_literal':
1122        return new FloatingLiteralToken(leading, trailing, token_text);
1123     case 'single_quoted_string_literal':
1124        return new SingleQuotedStringLiteralToken(leading, trailing, token_text);
1125     case 'double_quoted_string_literal':
1126        return new DoubleQuotedStringLiteralToken(leading, trailing, token_text);
1127     case 'double_quoted_string_literal_head':
1128        return new DoubleQuotedStringLiteralHeadToken(leading, trailing, token_text);
1129     case 'string_literal_body':
1130        return new StringLiteralBodyToken(leading, trailing, token_text);
1131     case 'double_quoted_string_literal_tail':
1132        return new DoubleQuotedStringLiteralTailToken(leading, trailing, token_text);
1133     case 'heredoc_string_literal':
1134        return new HeredocStringLiteralToken(leading, trailing, token_text);
1135     case 'heredoc_string_literal_head':
1136        return new HeredocStringLiteralHeadToken(leading, trailing, token_text);
1137     case 'heredoc_string_literal_tail':
1138        return new HeredocStringLiteralTailToken(leading, trailing, token_text);
1139     case 'nowdoc_string_literal':
1140        return new NowdocStringLiteralToken(leading, trailing, token_text);
1141     case 'boolean_literal':
1142        return new BooleanLiteralToken(leading, trailing, token_text);
1143     case 'XHP_category_name':
1144        return new XHPCategoryNameToken(leading, trailing, token_text);
1145     case 'XHP_element_name':
1146        return new XHPElementNameToken(leading, trailing, token_text);
1147     case 'XHP_class_name':
1148        return new XHPClassNameToken(leading, trailing, token_text);
1149     case 'XHP_string_literal':
1150        return new XHPStringLiteralToken(leading, trailing, token_text);
1151     case 'XHP_body':
1152        return new XHPBodyToken(leading, trailing, token_text);
1153     case 'XHP_comment':
1154        return new XHPCommentToken(leading, trailing, token_text);
1155     case 'markup':
1156        return new MarkupToken(leading, trailing, token_text);
1157
1158       default: throw 'unexpected token kind; ' + token_kind;
1159       // TODO: Better error
1160     }
1161   }
1162
1163   rewrite(rewriter, parents)
1164   {
1165     let new_parents = parents.slice();
1166     new_parents.push(this);
1167     let leading = this.leading.rewrite(rewriter, new_parents);
1168     let trailing = this.trailing.rewrite(rewriter, new_parents);
1169     if (leading === this.leading && trailing === this.trailing)
1170       return rewriter(this, parents);
1171     else
1172       return rewriter(EditableToken.factory(
1173         this.token_kind, leading, trailing, this.text), parents);
1174   }
1175
1176   reduce(reducer, accumulator)
1177   {
1178     accumulator = this.leading.reduce(reducer, accumulator);
1179     accumulator = reducer(this, accumulator);
1180     accumulator = this.trailing.reduce(reducer, accumulator);
1181     return accumulator;
1182   }
1183
1184   static from_json(json, position, source)
1185   {
1186     let leading_list = array_map_reduce(
1187       json.leading,
1188       (json, position) => EditableSyntax.from_json(json, position, source),
1189       (json, position) => json.width + position,
1190       position);
1191     let leading = EditableSyntax.to_list(leading_list);
1192     let token_position = position + leading.width;
1193     let token_text = source.substring(
1194       token_position, token_position + json.width);
1195     let trailing_position = token_position + json.width;
1196     let trailing_list = array_map_reduce(
1197       json.trailing,
1198       (json, position) => EditableSyntax.from_json(json, position, source),
1199       (json, position) => json.width + position,
1200       trailing_position);
1201     let trailing = EditableSyntax.to_list(trailing_list);
1202     return EditableToken.factory(json.kind, leading, trailing, token_text);
1203   }
1204
1205   get children_keys()
1206   {
1207     if (EditableToken._children_keys == null)
1208       EditableToken._children_keys = ['leading', 'trailing'];
1209     return EditableToken._children_keys;
1210   }
1211 }
1212
1213 class EndOfFileToken extends EditableToken
1214 {
1215   constructor(leading, trailing)
1216   {
1217     super('end_of_file', leading, trailing, '');
1218   }
1219 }
1220
1221 class AbstractToken extends EditableToken
1222 {
1223   constructor(leading, trailing)
1224   {
1225     super('abstract', leading, trailing, 'abstract');
1226   }
1227 }
1228 class AndToken extends EditableToken
1229 {
1230   constructor(leading, trailing)
1231   {
1232     super('and', leading, trailing, 'and');
1233   }
1234 }
1235 class ArrayToken extends EditableToken
1236 {
1237   constructor(leading, trailing)
1238   {
1239     super('array', leading, trailing, 'array');
1240   }
1241 }
1242 class ArraykeyToken extends EditableToken
1243 {
1244   constructor(leading, trailing)
1245   {
1246     super('arraykey', leading, trailing, 'arraykey');
1247   }
1248 }
1249 class AsToken extends EditableToken
1250 {
1251   constructor(leading, trailing)
1252   {
1253     super('as', leading, trailing, 'as');
1254   }
1255 }
1256 class AsyncToken extends EditableToken
1257 {
1258   constructor(leading, trailing)
1259   {
1260     super('async', leading, trailing, 'async');
1261   }
1262 }
1263 class AttributeToken extends EditableToken
1264 {
1265   constructor(leading, trailing)
1266   {
1267     super('attribute', leading, trailing, 'attribute');
1268   }
1269 }
1270 class AwaitToken extends EditableToken
1271 {
1272   constructor(leading, trailing)
1273   {
1274     super('await', leading, trailing, 'await');
1275   }
1276 }
1277 class BackslashToken extends EditableToken
1278 {
1279   constructor(leading, trailing)
1280   {
1281     super('\', leading, trailing, '\');
1282   }
1283 }
1284 class BinaryToken extends EditableToken
1285 {
1286   constructor(leading, trailing)
1287   {
1288     super('binary', leading, trailing, 'binary');
1289   }
1290 }
1291 class BoolToken extends EditableToken
1292 {
1293   constructor(leading, trailing)
1294   {
1295     super('bool', leading, trailing, 'bool');
1296   }
1297 }
1298 class BooleanToken extends EditableToken
1299 {
1300   constructor(leading, trailing)
1301   {
1302     super('boolean', leading, trailing, 'boolean');
1303   }
1304 }
1305 class BreakToken extends EditableToken
1306 {
1307   constructor(leading, trailing)
1308   {
1309     super('break', leading, trailing, 'break');
1310   }
1311 }
1312 class CaseToken extends EditableToken
1313 {
1314   constructor(leading, trailing)
1315   {
1316     super('case', leading, trailing, 'case');
1317   }
1318 }
1319 class CatchToken extends EditableToken
1320 {
1321   constructor(leading, trailing)
1322   {
1323     super('catch', leading, trailing, 'catch');
1324   }
1325 }
1326 class CategoryToken extends EditableToken
1327 {
1328   constructor(leading, trailing)
1329   {
1330     super('category', leading, trailing, 'category');
1331   }
1332 }
1333 class ChildrenToken extends EditableToken
1334 {
1335   constructor(leading, trailing)
1336   {
1337     super('children', leading, trailing, 'children');
1338   }
1339 }
1340 class ClassToken extends EditableToken
1341 {
1342   constructor(leading, trailing)
1343   {
1344     super('class', leading, trailing, 'class');
1345   }
1346 }
1347 class ClassnameToken extends EditableToken
1348 {
1349   constructor(leading, trailing)
1350   {
1351     super('classname', leading, trailing, 'classname');
1352   }
1353 }
1354 class CloneToken extends EditableToken
1355 {
1356   constructor(leading, trailing)
1357   {
1358     super('clone', leading, trailing, 'clone');
1359   }
1360 }
1361 class ConstToken extends EditableToken
1362 {
1363   constructor(leading, trailing)
1364   {
1365     super('const', leading, trailing, 'const');
1366   }
1367 }
1368 class ConstructToken extends EditableToken
1369 {
1370   constructor(leading, trailing)
1371   {
1372     super('__construct', leading, trailing, '__construct');
1373   }
1374 }
1375 class ContinueToken extends EditableToken
1376 {
1377   constructor(leading, trailing)
1378   {
1379     super('continue', leading, trailing, 'continue');
1380   }
1381 }
1382 class CoroutineToken extends EditableToken
1383 {
1384   constructor(leading, trailing)
1385   {
1386     super('coroutine', leading, trailing, 'coroutine');
1387   }
1388 }
1389 class DarrayToken extends EditableToken
1390 {
1391   constructor(leading, trailing)
1392   {
1393     super('darray', leading, trailing, 'darray');
1394   }
1395 }
1396 class DeclareToken extends EditableToken
1397 {
1398   constructor(leading, trailing)
1399   {
1400     super('declare', leading, trailing, 'declare');
1401   }
1402 }
1403 class DefaultToken extends EditableToken
1404 {
1405   constructor(leading, trailing)
1406   {
1407     super('default', leading, trailing, 'default');
1408   }
1409 }
1410 class DefineToken extends EditableToken
1411 {
1412   constructor(leading, trailing)
1413   {
1414     super('define', leading, trailing, 'define');
1415   }
1416 }
1417 class DestructToken extends EditableToken
1418 {
1419   constructor(leading, trailing)
1420   {
1421     super('__destruct', leading, trailing, '__destruct');
1422   }
1423 }
1424 class DictToken extends EditableToken
1425 {
1426   constructor(leading, trailing)
1427   {
1428     super('dict', leading, trailing, 'dict');
1429   }
1430 }
1431 class DoToken extends EditableToken
1432 {
1433   constructor(leading, trailing)
1434   {
1435     super('do', leading, trailing, 'do');
1436   }
1437 }
1438 class DoubleToken extends EditableToken
1439 {
1440   constructor(leading, trailing)
1441   {
1442     super('double', leading, trailing, 'double');
1443   }
1444 }
1445 class EchoToken extends EditableToken
1446 {
1447   constructor(leading, trailing)
1448   {
1449     super('echo', leading, trailing, 'echo');
1450   }
1451 }
1452 class ElseToken extends EditableToken
1453 {
1454   constructor(leading, trailing)
1455   {
1456     super('else', leading, trailing, 'else');
1457   }
1458 }
1459 class ElseifToken extends EditableToken
1460 {
1461   constructor(leading, trailing)
1462   {
1463     super('elseif', leading, trailing, 'elseif');
1464   }
1465 }
1466 class EmptyToken extends EditableToken
1467 {
1468   constructor(leading, trailing)
1469   {
1470     super('empty', leading, trailing, 'empty');
1471   }
1472 }
1473 class EndforToken extends EditableToken
1474 {
1475   constructor(leading, trailing)
1476   {
1477     super('endfor', leading, trailing, 'endfor');
1478   }
1479 }
1480 class EndforeachToken extends EditableToken
1481 {
1482   constructor(leading, trailing)
1483   {
1484     super('endforeach', leading, trailing, 'endforeach');
1485   }
1486 }
1487 class EnddeclareToken extends EditableToken
1488 {
1489   constructor(leading, trailing)
1490   {
1491     super('enddeclare', leading, trailing, 'enddeclare');
1492   }
1493 }
1494 class EndifToken extends EditableToken
1495 {
1496   constructor(leading, trailing)
1497   {
1498     super('endif', leading, trailing, 'endif');
1499   }
1500 }
1501 class EndswitchToken extends EditableToken
1502 {
1503   constructor(leading, trailing)
1504   {
1505     super('endswitch', leading, trailing, 'endswitch');
1506   }
1507 }
1508 class EndwhileToken extends EditableToken
1509 {
1510   constructor(leading, trailing)
1511   {
1512     super('endwhile', leading, trailing, 'endwhile');
1513   }
1514 }
1515 class EnumToken extends EditableToken
1516 {
1517   constructor(leading, trailing)
1518   {
1519     super('enum', leading, trailing, 'enum');
1520   }
1521 }
1522 class EvalToken extends EditableToken
1523 {
1524   constructor(leading, trailing)
1525   {
1526     super('eval', leading, trailing, 'eval');
1527   }
1528 }
1529 class ExtendsToken extends EditableToken
1530 {
1531   constructor(leading, trailing)
1532   {
1533     super('extends', leading, trailing, 'extends');
1534   }
1535 }
1536 class FallthroughToken extends EditableToken
1537 {
1538   constructor(leading, trailing)
1539   {
1540     super('fallthrough', leading, trailing, 'fallthrough');
1541   }
1542 }
1543 class FloatToken extends EditableToken
1544 {
1545   constructor(leading, trailing)
1546   {
1547     super('float', leading, trailing, 'float');
1548   }
1549 }
1550 class FileToken extends EditableToken
1551 {
1552   constructor(leading, trailing)
1553   {
1554     super('file', leading, trailing, 'file');
1555   }
1556 }
1557 class FinalToken extends EditableToken
1558 {
1559   constructor(leading, trailing)
1560   {
1561     super('final', leading, trailing, 'final');
1562   }
1563 }
1564 class FinallyToken extends EditableToken
1565 {
1566   constructor(leading, trailing)
1567   {
1568     super('finally', leading, trailing, 'finally');
1569   }
1570 }
1571 class ForToken extends EditableToken
1572 {
1573   constructor(leading, trailing)
1574   {
1575     super('for', leading, trailing, 'for');
1576   }
1577 }
1578 class ForeachToken extends EditableToken
1579 {
1580   constructor(leading, trailing)
1581   {
1582     super('foreach', leading, trailing, 'foreach');
1583   }
1584 }
1585 class FromToken extends EditableToken
1586 {
1587   constructor(leading, trailing)
1588   {
1589     super('from', leading, trailing, 'from');
1590   }
1591 }
1592 class FunctionToken extends EditableToken
1593 {
1594   constructor(leading, trailing)
1595   {
1596     super('function', leading, trailing, 'function');
1597   }
1598 }
1599 class GlobalToken extends EditableToken
1600 {
1601   constructor(leading, trailing)
1602   {
1603     super('global', leading, trailing, 'global');
1604   }
1605 }
1606 class ConcurrentToken extends EditableToken
1607 {
1608   constructor(leading, trailing)
1609   {
1610     super('concurrent', leading, trailing, 'concurrent');
1611   }
1612 }
1613 class GotoToken extends EditableToken
1614 {
1615   constructor(leading, trailing)
1616   {
1617     super('goto', leading, trailing, 'goto');
1618   }
1619 }
1620 class HaltCompilerToken extends EditableToken
1621 {
1622   constructor(leading, trailing)
1623   {
1624     super('__halt_compiler', leading, trailing, '__halt_compiler');
1625   }
1626 }
1627 class IfToken extends EditableToken
1628 {
1629   constructor(leading, trailing)
1630   {
1631     super('if', leading, trailing, 'if');
1632   }
1633 }
1634 class ImplementsToken extends EditableToken
1635 {
1636   constructor(leading, trailing)
1637   {
1638     super('implements', leading, trailing, 'implements');
1639   }
1640 }
1641 class IncludeToken extends EditableToken
1642 {
1643   constructor(leading, trailing)
1644   {
1645     super('include', leading, trailing, 'include');
1646   }
1647 }
1648 class Include_onceToken extends EditableToken
1649 {
1650   constructor(leading, trailing)
1651   {
1652     super('include_once', leading, trailing, 'include_once');
1653   }
1654 }
1655 class InoutToken extends EditableToken
1656 {
1657   constructor(leading, trailing)
1658   {
1659     super('inout', leading, trailing, 'inout');
1660   }
1661 }
1662 class InstanceofToken extends EditableToken
1663 {
1664   constructor(leading, trailing)
1665   {
1666     super('instanceof', leading, trailing, 'instanceof');
1667   }
1668 }
1669 class InsteadofToken extends EditableToken
1670 {
1671   constructor(leading, trailing)
1672   {
1673     super('insteadof', leading, trailing, 'insteadof');
1674   }
1675 }
1676 class IntToken extends EditableToken
1677 {
1678   constructor(leading, trailing)
1679   {
1680     super('int', leading, trailing, 'int');
1681   }
1682 }
1683 class IntegerToken extends EditableToken
1684 {
1685   constructor(leading, trailing)
1686   {
1687     super('integer', leading, trailing, 'integer');
1688   }
1689 }
1690 class InterfaceToken extends EditableToken
1691 {
1692   constructor(leading, trailing)
1693   {
1694     super('interface', leading, trailing, 'interface');
1695   }
1696 }
1697 class IsToken extends EditableToken
1698 {
1699   constructor(leading, trailing)
1700   {
1701     super('is', leading, trailing, 'is');
1702   }
1703 }
1704 class IssetToken extends EditableToken
1705 {
1706   constructor(leading, trailing)
1707   {
1708     super('isset', leading, trailing, 'isset');
1709   }
1710 }
1711 class KeysetToken extends EditableToken
1712 {
1713   constructor(leading, trailing)
1714   {
1715     super('keyset', leading, trailing, 'keyset');
1716   }
1717 }
1718 class LetToken extends EditableToken
1719 {
1720   constructor(leading, trailing)
1721   {
1722     super('let', leading, trailing, 'let');
1723   }
1724 }
1725 class ListToken extends EditableToken
1726 {
1727   constructor(leading, trailing)
1728   {
1729     super('list', leading, trailing, 'list');
1730   }
1731 }
1732 class MixedToken extends EditableToken
1733 {
1734   constructor(leading, trailing)
1735   {
1736     super('mixed', leading, trailing, 'mixed');
1737   }
1738 }
1739 class NamespaceToken extends EditableToken
1740 {
1741   constructor(leading, trailing)
1742   {
1743     super('namespace', leading, trailing, 'namespace');
1744   }
1745 }
1746 class NewToken extends EditableToken
1747 {
1748   constructor(leading, trailing)
1749   {
1750     super('new', leading, trailing, 'new');
1751   }
1752 }
1753 class NewtypeToken extends EditableToken
1754 {
1755   constructor(leading, trailing)
1756   {
1757     super('newtype', leading, trailing, 'newtype');
1758   }
1759 }
1760 class NoreturnToken extends EditableToken
1761 {
1762   constructor(leading, trailing)
1763   {
1764     super('noreturn', leading, trailing, 'noreturn');
1765   }
1766 }
1767 class NumToken extends EditableToken
1768 {
1769   constructor(leading, trailing)
1770   {
1771     super('num', leading, trailing, 'num');
1772   }
1773 }
1774 class ObjectToken extends EditableToken
1775 {
1776   constructor(leading, trailing)
1777   {
1778     super('object', leading, trailing, 'object');
1779   }
1780 }
1781 class OrToken extends EditableToken
1782 {
1783   constructor(leading, trailing)
1784   {
1785     super('or', leading, trailing, 'or');
1786   }
1787 }
1788 class ParentToken extends EditableToken
1789 {
1790   constructor(leading, trailing)
1791   {
1792     super('parent', leading, trailing, 'parent');
1793   }
1794 }
1795 class PrintToken extends EditableToken
1796 {
1797   constructor(leading, trailing)
1798   {
1799     super('print', leading, trailing, 'print');
1800   }
1801 }
1802 class PrivateToken extends EditableToken
1803 {
1804   constructor(leading, trailing)
1805   {
1806     super('private', leading, trailing, 'private');
1807   }
1808 }
1809 class ProtectedToken extends EditableToken
1810 {
1811   constructor(leading, trailing)
1812   {
1813     super('protected', leading, trailing, 'protected');
1814   }
1815 }
1816 class PublicToken extends EditableToken
1817 {
1818   constructor(leading, trailing)
1819   {
1820     super('public', leading, trailing, 'public');
1821   }
1822 }
1823 class RealToken extends EditableToken
1824 {
1825   constructor(leading, trailing)
1826   {
1827     super('real', leading, trailing, 'real');
1828   }
1829 }
1830 class ReifyToken extends EditableToken
1831 {
1832   constructor(leading, trailing)
1833   {
1834     super('reify', leading, trailing, 'reify');
1835   }
1836 }
1837 class RequireToken extends EditableToken
1838 {
1839   constructor(leading, trailing)
1840   {
1841     super('require', leading, trailing, 'require');
1842   }
1843 }
1844 class Require_onceToken extends EditableToken
1845 {
1846   constructor(leading, trailing)
1847   {
1848     super('require_once', leading, trailing, 'require_once');
1849   }
1850 }
1851 class RequiredToken extends EditableToken
1852 {
1853   constructor(leading, trailing)
1854   {
1855     super('required', leading, trailing, 'required');
1856   }
1857 }
1858 class ResourceToken extends EditableToken
1859 {
1860   constructor(leading, trailing)
1861   {
1862     super('resource', leading, trailing, 'resource');
1863   }
1864 }
1865 class ReturnToken extends EditableToken
1866 {
1867   constructor(leading, trailing)
1868   {
1869     super('return', leading, trailing, 'return');
1870   }
1871 }
1872 class SelfToken extends EditableToken
1873 {
1874   constructor(leading, trailing)
1875   {
1876     super('self', leading, trailing, 'self');
1877   }
1878 }
1879 class ShapeToken extends EditableToken
1880 {
1881   constructor(leading, trailing)
1882   {
1883     super('shape', leading, trailing, 'shape');
1884   }
1885 }
1886 class StaticToken extends EditableToken
1887 {
1888   constructor(leading, trailing)
1889   {
1890     super('static', leading, trailing, 'static');
1891   }
1892 }
1893 class StringToken extends EditableToken
1894 {
1895   constructor(leading, trailing)
1896   {
1897     super('string', leading, trailing, 'string');
1898   }
1899 }
1900 class SuperToken extends EditableToken
1901 {
1902   constructor(leading, trailing)
1903   {
1904     super('super', leading, trailing, 'super');
1905   }
1906 }
1907 class SuspendToken extends EditableToken
1908 {
1909   constructor(leading, trailing)
1910   {
1911     super('suspend', leading, trailing, 'suspend');
1912   }
1913 }
1914 class SwitchToken extends EditableToken
1915 {
1916   constructor(leading, trailing)
1917   {
1918     super('switch', leading, trailing, 'switch');
1919   }
1920 }
1921 class ThisToken extends EditableToken
1922 {
1923   constructor(leading, trailing)
1924   {
1925     super('this', leading, trailing, 'this');
1926   }
1927 }
1928 class ThrowToken extends EditableToken
1929 {
1930   constructor(leading, trailing)
1931   {
1932     super('throw', leading, trailing, 'throw');
1933   }
1934 }
1935 class TraitToken extends EditableToken
1936 {
1937   constructor(leading, trailing)
1938   {
1939     super('trait', leading, trailing, 'trait');
1940   }
1941 }
1942 class TryToken extends EditableToken
1943 {
1944   constructor(leading, trailing)
1945   {
1946     super('try', leading, trailing, 'try');
1947   }
1948 }
1949 class TupleToken extends EditableToken
1950 {
1951   constructor(leading, trailing)
1952   {
1953     super('tuple', leading, trailing, 'tuple');
1954   }
1955 }
1956 class TypeToken extends EditableToken
1957 {
1958   constructor(leading, trailing)
1959   {
1960     super('type', leading, trailing, 'type');
1961   }
1962 }
1963 class UnsetToken extends EditableToken
1964 {
1965   constructor(leading, trailing)
1966   {
1967     super('unset', leading, trailing, 'unset');
1968   }
1969 }
1970 class UseToken extends EditableToken
1971 {
1972   constructor(leading, trailing)
1973   {
1974     super('use', leading, trailing, 'use');
1975   }
1976 }
1977 class UsingToken extends EditableToken
1978 {
1979   constructor(leading, trailing)
1980   {
1981     super('using', leading, trailing, 'using');
1982   }
1983 }
1984 class VarToken extends EditableToken
1985 {
1986   constructor(leading, trailing)
1987   {
1988     super('var', leading, trailing, 'var');
1989   }
1990 }
1991 class VarrayToken extends EditableToken
1992 {
1993   constructor(leading, trailing)
1994   {
1995     super('varray', leading, trailing, 'varray');
1996   }
1997 }
1998 class VecToken extends EditableToken
1999 {
2000   constructor(leading, trailing)
2001   {
2002     super('vec', leading, trailing, 'vec');
2003   }
2004 }
2005 class VoidToken extends EditableToken
2006 {
2007   constructor(leading, trailing)
2008   {
2009     super('void', leading, trailing, 'void');
2010   }
2011 }
2012 class WhereToken extends EditableToken
2013 {
2014   constructor(leading, trailing)
2015   {
2016     super('where', leading, trailing, 'where');
2017   }
2018 }
2019 class WhileToken extends EditableToken
2020 {
2021   constructor(leading, trailing)
2022   {
2023     super('while', leading, trailing, 'while');
2024   }
2025 }
2026 class XorToken extends EditableToken
2027 {
2028   constructor(leading, trailing)
2029   {
2030     super('xor', leading, trailing, 'xor');
2031   }
2032 }
2033 class YieldToken extends EditableToken
2034 {
2035   constructor(leading, trailing)
2036   {
2037     super('yield', leading, trailing, 'yield');
2038   }
2039 }
2040 class NullLiteralToken extends EditableToken
2041 {
2042   constructor(leading, trailing)
2043   {
2044     super('null', leading, trailing, 'null');
2045   }
2046 }
2047 class LeftBracketToken extends EditableToken
2048 {
2049   constructor(leading, trailing)
2050   {
2051     super('[', leading, trailing, '[');
2052   }
2053 }
2054 class RightBracketToken extends EditableToken
2055 {
2056   constructor(leading, trailing)
2057   {
2058     super(']', leading, trailing, ']');
2059   }
2060 }
2061 class LeftParenToken extends EditableToken
2062 {
2063   constructor(leading, trailing)
2064   {
2065     super('(', leading, trailing, '(');
2066   }
2067 }
2068 class RightParenToken extends EditableToken
2069 {
2070   constructor(leading, trailing)
2071   {
2072     super(')', leading, trailing, ')');
2073   }
2074 }
2075 class LeftBraceToken extends EditableToken
2076 {
2077   constructor(leading, trailing)
2078   {
2079     super('{', leading, trailing, '{');
2080   }
2081 }
2082 class RightBraceToken extends EditableToken
2083 {
2084   constructor(leading, trailing)
2085   {
2086     super('}', leading, trailing, '}');
2087   }
2088 }
2089 class DotToken extends EditableToken
2090 {
2091   constructor(leading, trailing)
2092   {
2093     super('.', leading, trailing, '.');
2094   }
2095 }
2096 class MinusGreaterThanToken extends EditableToken
2097 {
2098   constructor(leading, trailing)
2099   {
2100     super('->', leading, trailing, '->');
2101   }
2102 }
2103 class PlusPlusToken extends EditableToken
2104 {
2105   constructor(leading, trailing)
2106   {
2107     super('++', leading, trailing, '++');
2108   }
2109 }
2110 class MinusMinusToken extends EditableToken
2111 {
2112   constructor(leading, trailing)
2113   {
2114     super('--', leading, trailing, '--');
2115   }
2116 }
2117 class StarStarToken extends EditableToken
2118 {
2119   constructor(leading, trailing)
2120   {
2121     super('**', leading, trailing, '**');
2122   }
2123 }
2124 class StarToken extends EditableToken
2125 {
2126   constructor(leading, trailing)
2127   {
2128     super('*', leading, trailing, '*');
2129   }
2130 }
2131 class PlusToken extends EditableToken
2132 {
2133   constructor(leading, trailing)
2134   {
2135     super('+', leading, trailing, '+');
2136   }
2137 }
2138 class MinusToken extends EditableToken
2139 {
2140   constructor(leading, trailing)
2141   {
2142     super('-', leading, trailing, '-');
2143   }
2144 }
2145 class TildeToken extends EditableToken
2146 {
2147   constructor(leading, trailing)
2148   {
2149     super('~', leading, trailing, '~');
2150   }
2151 }
2152 class ExclamationToken extends EditableToken
2153 {
2154   constructor(leading, trailing)
2155   {
2156     super('!', leading, trailing, '!');
2157   }
2158 }
2159 class DollarToken extends EditableToken
2160 {
2161   constructor(leading, trailing)
2162   {
2163     super('$', leading, trailing, '$');
2164   }
2165 }
2166 class SlashToken extends EditableToken
2167 {
2168   constructor(leading, trailing)
2169   {
2170     super('/', leading, trailing, '/');
2171   }
2172 }
2173 class PercentToken extends EditableToken
2174 {
2175   constructor(leading, trailing)
2176   {
2177     super('%', leading, trailing, '%');
2178   }
2179 }
2180 class LessThanGreaterThanToken extends EditableToken
2181 {
2182   constructor(leading, trailing)
2183   {
2184     super('<>', leading, trailing, '<>');
2185   }
2186 }
2187 class LessThanEqualGreaterThanToken extends EditableToken
2188 {
2189   constructor(leading, trailing)
2190   {
2191     super('<=>', leading, trailing, '<=>');
2192   }
2193 }
2194 class LessThanLessThanToken extends EditableToken
2195 {
2196   constructor(leading, trailing)
2197   {
2198     super('<<', leading, trailing, '<<');
2199   }
2200 }
2201 class GreaterThanGreaterThanToken extends EditableToken
2202 {
2203   constructor(leading, trailing)
2204   {
2205     super('>>', leading, trailing, '>>');
2206   }
2207 }
2208 class LessThanToken extends EditableToken
2209 {
2210   constructor(leading, trailing)
2211   {
2212     super('<', leading, trailing, '<');
2213   }
2214 }
2215 class GreaterThanToken extends EditableToken
2216 {
2217   constructor(leading, trailing)
2218   {
2219     super('>', leading, trailing, '>');
2220   }
2221 }
2222 class LessThanEqualToken extends EditableToken
2223 {
2224   constructor(leading, trailing)
2225   {
2226     super('<=', leading, trailing, '<=');
2227   }
2228 }
2229 class GreaterThanEqualToken extends EditableToken
2230 {
2231   constructor(leading, trailing)
2232   {
2233     super('>=', leading, trailing, '>=');
2234   }
2235 }
2236 class EqualEqualToken extends EditableToken
2237 {
2238   constructor(leading, trailing)
2239   {
2240     super('==', leading, trailing, '==');
2241   }
2242 }
2243 class EqualEqualEqualToken extends EditableToken
2244 {
2245   constructor(leading, trailing)
2246   {
2247     super('===', leading, trailing, '===');
2248   }
2249 }
2250 class ExclamationEqualToken extends EditableToken
2251 {
2252   constructor(leading, trailing)
2253   {
2254     super('!=', leading, trailing, '!=');
2255   }
2256 }
2257 class ExclamationEqualEqualToken extends EditableToken
2258 {
2259   constructor(leading, trailing)
2260   {
2261     super('!==', leading, trailing, '!==');
2262   }
2263 }
2264 class CaratToken extends EditableToken
2265 {
2266   constructor(leading, trailing)
2267   {
2268     super('^', leading, trailing, '^');
2269   }
2270 }
2271 class BarToken extends EditableToken
2272 {
2273   constructor(leading, trailing)
2274   {
2275     super('|', leading, trailing, '|');
2276   }
2277 }
2278 class AmpersandToken extends EditableToken
2279 {
2280   constructor(leading, trailing)
2281   {
2282     super('&', leading, trailing, '&');
2283   }
2284 }
2285 class AmpersandAmpersandToken extends EditableToken
2286 {
2287   constructor(leading, trailing)
2288   {
2289     super('&&', leading, trailing, '&&');
2290   }
2291 }
2292 class BarBarToken extends EditableToken
2293 {
2294   constructor(leading, trailing)
2295   {
2296     super('||', leading, trailing, '||');
2297   }
2298 }
2299 class QuestionToken extends EditableToken
2300 {
2301   constructor(leading, trailing)
2302   {
2303     super('?', leading, trailing, '?');
2304   }
2305 }
2306 class QuestionAsToken extends EditableToken
2307 {
2308   constructor(leading, trailing)
2309   {
2310     super('?as', leading, trailing, '?as');
2311   }
2312 }
2313 class QuestionColonToken extends EditableToken
2314 {
2315   constructor(leading, trailing)
2316   {
2317     super('?:', leading, trailing, '?:');
2318   }
2319 }
2320 class QuestionQuestionToken extends EditableToken
2321 {
2322   constructor(leading, trailing)
2323   {
2324     super('??', leading, trailing, '??');
2325   }
2326 }
2327 class QuestionQuestionEqualToken extends EditableToken
2328 {
2329   constructor(leading, trailing)
2330   {
2331     super('??=', leading, trailing, '??=');
2332   }
2333 }
2334 class ColonToken extends EditableToken
2335 {
2336   constructor(leading, trailing)
2337   {
2338     super(':', leading, trailing, ':');
2339   }
2340 }
2341 class SemicolonToken extends EditableToken
2342 {
2343   constructor(leading, trailing)
2344   {
2345     super(';', leading, trailing, ';');
2346   }
2347 }
2348 class EqualToken extends EditableToken
2349 {
2350   constructor(leading, trailing)
2351   {
2352     super('=', leading, trailing, '=');
2353   }
2354 }
2355 class StarStarEqualToken extends EditableToken
2356 {
2357   constructor(leading, trailing)
2358   {
2359     super('**=', leading, trailing, '**=');
2360   }
2361 }
2362 class StarEqualToken extends EditableToken
2363 {
2364   constructor(leading, trailing)
2365   {
2366     super('*=', leading, trailing, '*=');
2367   }
2368 }
2369 class SlashEqualToken extends EditableToken
2370 {
2371   constructor(leading, trailing)
2372   {
2373     super('/=', leading, trailing, '/=');
2374   }
2375 }
2376 class PercentEqualToken extends EditableToken
2377 {
2378   constructor(leading, trailing)
2379   {
2380     super('%=', leading, trailing, '%=');
2381   }
2382 }
2383 class PlusEqualToken extends EditableToken
2384 {
2385   constructor(leading, trailing)
2386   {
2387     super('+=', leading, trailing, '+=');
2388   }
2389 }
2390 class MinusEqualToken extends EditableToken
2391 {
2392   constructor(leading, trailing)
2393   {
2394     super('-=', leading, trailing, '-=');
2395   }
2396 }
2397 class DotEqualToken extends EditableToken
2398 {
2399   constructor(leading, trailing)
2400   {
2401     super('.=', leading, trailing, '.=');
2402   }
2403 }
2404 class LessThanLessThanEqualToken extends EditableToken
2405 {
2406   constructor(leading, trailing)
2407   {
2408     super('<<=', leading, trailing, '<<=');
2409   }
2410 }
2411 class GreaterThanGreaterThanEqualToken extends EditableToken
2412 {
2413   constructor(leading, trailing)
2414   {
2415     super('>>=', leading, trailing, '>>=');
2416   }
2417 }
2418 class AmpersandEqualToken extends EditableToken
2419 {
2420   constructor(leading, trailing)
2421   {
2422     super('&=', leading, trailing, '&=');
2423   }
2424 }
2425 class CaratEqualToken extends EditableToken
2426 {
2427   constructor(leading, trailing)
2428   {
2429     super('^=', leading, trailing, '^=');
2430   }
2431 }
2432 class BarEqualToken extends EditableToken
2433 {
2434   constructor(leading, trailing)
2435   {
2436     super('|=', leading, trailing, '|=');
2437   }
2438 }
2439 class CommaToken extends EditableToken
2440 {
2441   constructor(leading, trailing)
2442   {
2443     super(',', leading, trailing, ',');
2444   }
2445 }
2446 class AtToken extends EditableToken
2447 {
2448   constructor(leading, trailing)
2449   {
2450     super('@', leading, trailing, '@');
2451   }
2452 }
2453 class ColonColonToken extends EditableToken
2454 {
2455   constructor(leading, trailing)
2456   {
2457     super('::', leading, trailing, '::');
2458   }
2459 }
2460 class EqualGreaterThanToken extends EditableToken
2461 {
2462   constructor(leading, trailing)
2463   {
2464     super('=>', leading, trailing, '=>');
2465   }
2466 }
2467 class EqualEqualGreaterThanToken extends EditableToken
2468 {
2469   constructor(leading, trailing)
2470   {
2471     super('==>', leading, trailing, '==>');
2472   }
2473 }
2474 class QuestionMinusGreaterThanToken extends EditableToken
2475 {
2476   constructor(leading, trailing)
2477   {
2478     super('?->', leading, trailing, '?->');
2479   }
2480 }
2481 class DotDotDotToken extends EditableToken
2482 {
2483   constructor(leading, trailing)
2484   {
2485     super('...', leading, trailing, '...');
2486   }
2487 }
2488 class DollarDollarToken extends EditableToken
2489 {
2490   constructor(leading, trailing)
2491   {
2492     super('$$', leading, trailing, '$$');
2493   }
2494 }
2495 class BarGreaterThanToken extends EditableToken
2496 {
2497   constructor(leading, trailing)
2498   {
2499     super('|>', leading, trailing, '|>');
2500   }
2501 }
2502 class SlashGreaterThanToken extends EditableToken
2503 {
2504   constructor(leading, trailing)
2505   {
2506     super('/>', leading, trailing, '/>');
2507   }
2508 }
2509 class LessThanSlashToken extends EditableToken
2510 {
2511   constructor(leading, trailing)
2512   {
2513     super('</', leading, trailing, '</');
2514   }
2515 }
2516 class LessThanQuestionToken extends EditableToken
2517 {
2518   constructor(leading, trailing)
2519   {
2520     super('<?', leading, trailing, '<?');
2521   }
2522 }
2523 class QuestionGreaterThanToken extends EditableToken
2524 {
2525   constructor(leading, trailing)
2526   {
2527     super('?>', leading, trailing, '?>');
2528   }
2529 }
2530 class ColonAtToken extends EditableToken
2531 {
2532   constructor(leading, trailing)
2533   {
2534     super(':@', leading, trailing, ':@');
2535   }
2536 }
2537
2538 class ErrorTokenToken extends EditableToken
2539 {
2540   constructor(leading, trailing, text)
2541   {
2542     super('error_token', leading, trailing, text);
2543   }
2544   with_text(text)
2545   {
2546     return new ErrorTokenToken(this.leading, this.trailing, text);
2547   }
2548
2549 }
2550 class NameToken extends EditableToken
2551 {
2552   constructor(leading, trailing, text)
2553   {
2554     super('name', leading, trailing, text);
2555   }
2556   with_text(text)
2557   {
2558     return new NameToken(this.leading, this.trailing, text);
2559   }
2560
2561 }
2562 class VariableToken extends EditableToken
2563 {
2564   constructor(leading, trailing, text)
2565   {
2566     super('variable', leading, trailing, text);
2567   }
2568   with_text(text)
2569   {
2570     return new VariableToken(this.leading, this.trailing, text);
2571   }
2572
2573 }
2574 class DecimalLiteralToken extends EditableToken
2575 {
2576   constructor(leading, trailing, text)
2577   {
2578     super('decimal_literal', leading, trailing, text);
2579   }
2580   with_text(text)
2581   {
2582     return new DecimalLiteralToken(this.leading, this.trailing, text);
2583   }
2584
2585 }
2586 class OctalLiteralToken extends EditableToken
2587 {
2588   constructor(leading, trailing, text)
2589   {
2590     super('octal_literal', leading, trailing, text);
2591   }
2592   with_text(text)
2593   {
2594     return new OctalLiteralToken(this.leading, this.trailing, text);
2595   }
2596
2597 }
2598 class HexadecimalLiteralToken extends EditableToken
2599 {
2600   constructor(leading, trailing, text)
2601   {
2602     super('hexadecimal_literal', leading, trailing, text);
2603   }
2604   with_text(text)
2605   {
2606     return new HexadecimalLiteralToken(this.leading, this.trailing, text);
2607   }
2608
2609 }
2610 class BinaryLiteralToken extends EditableToken
2611 {
2612   constructor(leading, trailing, text)
2613   {
2614     super('binary_literal', leading, trailing, text);
2615   }
2616   with_text(text)
2617   {
2618     return new BinaryLiteralToken(this.leading, this.trailing, text);
2619   }
2620
2621 }
2622 class FloatingLiteralToken extends EditableToken
2623 {
2624   constructor(leading, trailing, text)
2625   {
2626     super('floating_literal', leading, trailing, text);
2627   }
2628   with_text(text)
2629   {
2630     return new FloatingLiteralToken(this.leading, this.trailing, text);
2631   }
2632
2633 }
2634 class SingleQuotedStringLiteralToken extends EditableToken
2635 {
2636   constructor(leading, trailing, text)
2637   {
2638     super('single_quoted_string_literal', leading, trailing, text);
2639   }
2640   with_text(text)
2641   {
2642     return new SingleQuotedStringLiteralToken(this.leading, this.trailing, text);
2643   }
2644
2645 }
2646 class DoubleQuotedStringLiteralToken extends EditableToken
2647 {
2648   constructor(leading, trailing, text)
2649   {
2650     super('double_quoted_string_literal', leading, trailing, text);
2651   }
2652   with_text(text)
2653   {
2654     return new DoubleQuotedStringLiteralToken(this.leading, this.trailing, text);
2655   }
2656
2657 }
2658 class DoubleQuotedStringLiteralHeadToken extends EditableToken
2659 {
2660   constructor(leading, trailing, text)
2661   {
2662     super('double_quoted_string_literal_head', leading, trailing, text);
2663   }
2664   with_text(text)
2665   {
2666     return new DoubleQuotedStringLiteralHeadToken(this.leading, this.trailing, text);
2667   }
2668
2669 }
2670 class StringLiteralBodyToken extends EditableToken
2671 {
2672   constructor(leading, trailing, text)
2673   {
2674     super('string_literal_body', leading, trailing, text);
2675   }
2676   with_text(text)
2677   {
2678     return new StringLiteralBodyToken(this.leading, this.trailing, text);
2679   }
2680
2681 }
2682 class DoubleQuotedStringLiteralTailToken extends EditableToken
2683 {
2684   constructor(leading, trailing, text)
2685   {
2686     super('double_quoted_string_literal_tail', leading, trailing, text);
2687   }
2688   with_text(text)
2689   {
2690     return new DoubleQuotedStringLiteralTailToken(this.leading, this.trailing, text);
2691   }
2692
2693 }
2694 class HeredocStringLiteralToken extends EditableToken
2695 {
2696   constructor(leading, trailing, text)
2697   {
2698     super('heredoc_string_literal', leading, trailing, text);
2699   }
2700   with_text(text)
2701   {
2702     return new HeredocStringLiteralToken(this.leading, this.trailing, text);
2703   }
2704
2705 }
2706 class HeredocStringLiteralHeadToken extends EditableToken
2707 {
2708   constructor(leading, trailing, text)
2709   {
2710     super('heredoc_string_literal_head', leading, trailing, text);
2711   }
2712   with_text(text)
2713   {
2714     return new HeredocStringLiteralHeadToken(this.leading, this.trailing, text);
2715   }
2716
2717 }
2718 class HeredocStringLiteralTailToken extends EditableToken
2719 {
2720   constructor(leading, trailing, text)
2721   {
2722     super('heredoc_string_literal_tail', leading, trailing, text);
2723   }
2724   with_text(text)
2725   {
2726     return new HeredocStringLiteralTailToken(this.leading, this.trailing, text);
2727   }
2728
2729 }
2730 class NowdocStringLiteralToken extends EditableToken
2731 {
2732   constructor(leading, trailing, text)
2733   {
2734     super('nowdoc_string_literal', leading, trailing, text);
2735   }
2736   with_text(text)
2737   {
2738     return new NowdocStringLiteralToken(this.leading, this.trailing, text);
2739   }
2740
2741 }
2742 class BooleanLiteralToken extends EditableToken
2743 {
2744   constructor(leading, trailing, text)
2745   {
2746     super('boolean_literal', leading, trailing, text);
2747   }
2748   with_text(text)
2749   {
2750     return new BooleanLiteralToken(this.leading, this.trailing, text);
2751   }
2752
2753 }
2754 class XHPCategoryNameToken extends EditableToken
2755 {
2756   constructor(leading, trailing, text)
2757   {
2758     super('XHP_category_name', leading, trailing, text);
2759   }
2760   with_text(text)
2761   {
2762     return new XHPCategoryNameToken(this.leading, this.trailing, text);
2763   }
2764
2765 }
2766 class XHPElementNameToken extends EditableToken
2767 {
2768   constructor(leading, trailing, text)
2769   {
2770     super('XHP_element_name', leading, trailing, text);
2771   }
2772   with_text(text)
2773   {
2774     return new XHPElementNameToken(this.leading, this.trailing, text);
2775   }
2776
2777 }
2778 class XHPClassNameToken extends EditableToken
2779 {
2780   constructor(leading, trailing, text)
2781   {
2782     super('XHP_class_name', leading, trailing, text);
2783   }
2784   with_text(text)
2785   {
2786     return new XHPClassNameToken(this.leading, this.trailing, text);
2787   }
2788
2789 }
2790 class XHPStringLiteralToken extends EditableToken
2791 {
2792   constructor(leading, trailing, text)
2793   {
2794     super('XHP_string_literal', leading, trailing, text);
2795   }
2796   with_text(text)
2797   {
2798     return new XHPStringLiteralToken(this.leading, this.trailing, text);
2799   }
2800
2801 }
2802 class XHPBodyToken extends EditableToken
2803 {
2804   constructor(leading, trailing, text)
2805   {
2806     super('XHP_body', leading, trailing, text);
2807   }
2808   with_text(text)
2809   {
2810     return new XHPBodyToken(this.leading, this.trailing, text);
2811   }
2812
2813 }
2814 class XHPCommentToken extends EditableToken
2815 {
2816   constructor(leading, trailing, text)
2817   {
2818     super('XHP_comment', leading, trailing, text);
2819   }
2820   with_text(text)
2821   {
2822     return new XHPCommentToken(this.leading, this.trailing, text);
2823   }
2824
2825 }
2826 class MarkupToken extends EditableToken
2827 {
2828   constructor(leading, trailing, text)
2829   {
2830     super('markup', leading, trailing, text);
2831   }
2832   with_text(text)
2833   {
2834     return new MarkupToken(this.leading, this.trailing, text);
2835   }
2836
2837 }
2838
2839
2840 class EditableTrivia extends EditableSyntax
2841 {
2842   constructor(trivia_kind, text)
2843   {
2844     super(trivia_kind, {});
2845     this._text = text;
2846   }
2847   get text() { return this._text; }
2848   get full_text() { return this.text; }
2849   get width() { return this.text.length; }
2850   get is_trivia() { return true; }
2851
2852   static from_json(json, position, source)
2853   {
2854     let trivia_text = source.substring(position, position + json.width);
2855     switch(json.kind)
2856     {
2857       case 'whitespace':
2858         return new WhiteSpace(trivia_text);
2859       case 'end_of_line':
2860         return new EndOfLine(trivia_text);
2861       case 'delimited_comment':
2862         return new DelimitedComment(trivia_text);
2863       case 'single_line_comment':
2864         return new SingleLineComment(trivia_text);
2865       case 'unsafe':
2866         return new Unsafe(trivia_text);
2867       case 'unsafe_expression':
2868         return new UnsafeExpression(trivia_text);
2869       case 'fix_me':
2870         return new FixMe(trivia_text);
2871       case 'ignore_error':
2872         return new IgnoreError(trivia_text);
2873       case 'fall_through':
2874         return new FallThrough(trivia_text);
2875       case 'extra_token_error':
2876         return new ExtraTokenError(trivia_text);
2877       case 'after_halt_compiler':
2878         return new AfterHaltCompiler(trivia_text);
2879
2880       default: throw 'unexpected json kind: ' + json.kind; // TODO: Better error
2881     }
2882   }
2883
2884   rewrite(rewriter, parents)
2885   {
2886     return rewriter(this, parents);
2887   }
2888   get children_keys()
2889   {
2890     return [];
2891   }
2892 }
2893
2894 class WhiteSpace extends EditableTrivia
2895 {
2896   constructor(text) { super('whitespace', text); }
2897   with_text(text)
2898   {
2899     return new WhiteSpace(text);
2900   }
2901 }
2902
2903 class EndOfLine extends EditableTrivia
2904 {
2905   constructor(text) { super('end_of_line', text); }
2906   with_text(text)
2907   {
2908     return new EndOfLine(text);
2909   }
2910 }
2911
2912 class DelimitedComment extends EditableTrivia
2913 {
2914   constructor(text) { super('delimited_comment', text); }
2915   with_text(text)
2916   {
2917     return new DelimitedComment(text);
2918   }
2919 }
2920
2921 class SingleLineComment extends EditableTrivia
2922 {
2923   constructor(text) { super('single_line_comment', text); }
2924   with_text(text)
2925   {
2926     return new SingleLineComment(text);
2927   }
2928 }
2929
2930 class Unsafe extends EditableTrivia
2931 {
2932   constructor(text) { super('unsafe', text); }
2933   with_text(text)
2934   {
2935     return new Unsafe(text);
2936   }
2937 }
2938
2939 class UnsafeExpression extends EditableTrivia
2940 {
2941   constructor(text) { super('unsafe_expression', text); }
2942   with_text(text)
2943   {
2944     return new UnsafeExpression(text);
2945   }
2946 }
2947
2948 class FixMe extends EditableTrivia
2949 {
2950   constructor(text) { super('fix_me', text); }
2951   with_text(text)
2952   {
2953     return new FixMe(text);
2954   }
2955 }
2956
2957 class IgnoreError extends EditableTrivia
2958 {
2959   constructor(text) { super('ignore_error', text); }
2960   with_text(text)
2961   {
2962     return new IgnoreError(text);
2963   }
2964 }
2965
2966 class FallThrough extends EditableTrivia
2967 {
2968   constructor(text) { super('fall_through', text); }
2969   with_text(text)
2970   {
2971     return new FallThrough(text);
2972   }
2973 }
2974
2975 class ExtraTokenError extends EditableTrivia
2976 {
2977   constructor(text) { super('extra_token_error', text); }
2978   with_text(text)
2979   {
2980     return new ExtraTokenError(text);
2981   }
2982 }
2983
2984 class AfterHaltCompiler extends EditableTrivia
2985 {
2986   constructor(text) { super('after_halt_compiler', text); }
2987   with_text(text)
2988   {
2989     return new AfterHaltCompiler(text);
2990   }
2991 }
2992
2993
2994
2995 class Missing extends EditableSyntax
2996 {
2997   constructor()
2998   {
2999     super('missing', {});
3000   }
3001   get is_missing() { return true; }
3002   static get missing() { return Missing._missing; }
3003   static from_json(json, position, source)
3004   {
3005     return Missing._missing;
3006   }
3007   rewrite(rewriter, parents)
3008   {
3009     return rewriter(this, parents);
3010   }
3011   get children_keys()
3012   {
3013     return [];
3014   }
3015 }
3016 Missing._missing = new Missing();
3017
3018 class EndOfFile extends EditableSyntax
3019 {
3020   constructor(
3021     token)
3022   {
3023     super('end_of_file', {
3024       token: token });
3025   }
3026   get token() { return this.children.token; }
3027   with_token(token){
3028     return new EndOfFile(
3029       token);
3030   }
3031   rewrite(rewriter, parents)
3032   {
3033     if (parents == undefined)
3034       parents = [];
3035     let new_parents = parents.slice();
3036     new_parents.push(this);
3037     var token = this.token.rewrite(rewriter, new_parents);
3038     if (
3039       token === this.token)
3040     {
3041       return rewriter(this, parents);
3042     }
3043     else
3044     {
3045       return rewriter(new EndOfFile(
3046         token), parents);
3047     }
3048   }
3049   static from_json(json, position, source)
3050   {
3051     let token = EditableSyntax.from_json(
3052       json.end_of_file_token, position, source);
3053     position += token.width;
3054     return new EndOfFile(
3055         token);
3056   }
3057   get children_keys()
3058   {
3059     if (EndOfFile._children_keys == null)
3060       EndOfFile._children_keys = [
3061         'token'];
3062     return EndOfFile._children_keys;
3063   }
3064 }
3065 class Script extends EditableSyntax
3066 {
3067   constructor(
3068     declarations)
3069   {
3070     super('script', {
3071       declarations: declarations });
3072   }
3073   get declarations() { return this.children.declarations; }
3074   with_declarations(declarations){
3075     return new Script(
3076       declarations);
3077   }
3078   rewrite(rewriter, parents)
3079   {
3080     if (parents == undefined)
3081       parents = [];
3082     let new_parents = parents.slice();
3083     new_parents.push(this);
3084     var declarations = this.declarations.rewrite(rewriter, new_parents);
3085     if (
3086       declarations === this.declarations)
3087     {
3088       return rewriter(this, parents);
3089     }
3090     else
3091     {
3092       return rewriter(new Script(
3093         declarations), parents);
3094     }
3095   }
3096   static from_json(json, position, source)
3097   {
3098     let declarations = EditableSyntax.from_json(
3099       json.script_declarations, position, source);
3100     position += declarations.width;
3101     return new Script(
3102         declarations);
3103   }
3104   get children_keys()
3105   {
3106     if (Script._children_keys == null)
3107       Script._children_keys = [
3108         'declarations'];
3109     return Script._children_keys;
3110   }
3111 }
3112 class QualifiedName extends EditableSyntax
3113 {
3114   constructor(
3115     parts)
3116   {
3117     super('qualified_name', {
3118       parts: parts });
3119   }
3120   get parts() { return this.children.parts; }
3121   with_parts(parts){
3122     return new QualifiedName(
3123       parts);
3124   }
3125   rewrite(rewriter, parents)
3126   {
3127     if (parents == undefined)
3128       parents = [];
3129     let new_parents = parents.slice();
3130     new_parents.push(this);
3131     var parts = this.parts.rewrite(rewriter, new_parents);
3132     if (
3133       parts === this.parts)
3134     {
3135       return rewriter(this, parents);
3136     }
3137     else
3138     {
3139       return rewriter(new QualifiedName(
3140         parts), parents);
3141     }
3142   }
3143   static from_json(json, position, source)
3144   {
3145     let parts = EditableSyntax.from_json(
3146       json.qualified_name_parts, position, source);
3147     position += parts.width;
3148     return new QualifiedName(
3149         parts);
3150   }
3151   get children_keys()
3152   {
3153     if (QualifiedName._children_keys == null)
3154       QualifiedName._children_keys = [
3155         'parts'];
3156     return QualifiedName._children_keys;
3157   }
3158 }
3159 class SimpleTypeSpecifier extends EditableSyntax
3160 {
3161   constructor(
3162     specifier)
3163   {
3164     super('simple_type_specifier', {
3165       specifier: specifier });
3166   }
3167   get specifier() { return this.children.specifier; }
3168   with_specifier(specifier){
3169     return new SimpleTypeSpecifier(
3170       specifier);
3171   }
3172   rewrite(rewriter, parents)
3173   {
3174     if (parents == undefined)
3175       parents = [];
3176     let new_parents = parents.slice();
3177     new_parents.push(this);
3178     var specifier = this.specifier.rewrite(rewriter, new_parents);
3179     if (
3180       specifier === this.specifier)
3181     {
3182       return rewriter(this, parents);
3183     }
3184     else
3185     {
3186       return rewriter(new SimpleTypeSpecifier(
3187         specifier), parents);
3188     }
3189   }
3190   static from_json(json, position, source)
3191   {
3192     let specifier = EditableSyntax.from_json(
3193       json.simple_type_specifier, position, source);
3194     position += specifier.width;
3195     return new SimpleTypeSpecifier(
3196         specifier);
3197   }
3198   get children_keys()
3199   {
3200     if (SimpleTypeSpecifier._children_keys == null)
3201       SimpleTypeSpecifier._children_keys = [
3202         'specifier'];
3203     return SimpleTypeSpecifier._children_keys;
3204   }
3205 }
3206 class LiteralExpression extends EditableSyntax
3207 {
3208   constructor(
3209     expression)
3210   {
3211     super('literal', {
3212       expression: expression });
3213   }
3214   get expression() { return this.children.expression; }
3215   with_expression(expression){
3216     return new LiteralExpression(
3217       expression);
3218   }
3219   rewrite(rewriter, parents)
3220   {
3221     if (parents == undefined)
3222       parents = [];
3223     let new_parents = parents.slice();
3224     new_parents.push(this);
3225     var expression = this.expression.rewrite(rewriter, new_parents);
3226     if (
3227       expression === this.expression)
3228     {
3229       return rewriter(this, parents);
3230     }
3231     else
3232     {
3233       return rewriter(new LiteralExpression(
3234         expression), parents);
3235     }
3236   }
3237   static from_json(json, position, source)
3238   {
3239     let expression = EditableSyntax.from_json(
3240       json.literal_expression, position, source);
3241     position += expression.width;
3242     return new LiteralExpression(
3243         expression);
3244   }
3245   get children_keys()
3246   {
3247     if (LiteralExpression._children_keys == null)
3248       LiteralExpression._children_keys = [
3249         'expression'];
3250     return LiteralExpression._children_keys;
3251   }
3252 }
3253 class PrefixedStringExpression extends EditableSyntax
3254 {
3255   constructor(
3256     name,
3257     str)
3258   {
3259     super('prefixed_string', {
3260       name: name,
3261       str: str });
3262   }
3263   get name() { return this.children.name; }
3264   get str() { return this.children.str; }
3265   with_name(name){
3266     return new PrefixedStringExpression(
3267       name,
3268       this.str);
3269   }
3270   with_str(str){
3271     return new PrefixedStringExpression(
3272       this.name,
3273       str);
3274   }
3275   rewrite(rewriter, parents)
3276   {
3277     if (parents == undefined)
3278       parents = [];
3279     let new_parents = parents.slice();
3280     new_parents.push(this);
3281     var name = this.name.rewrite(rewriter, new_parents);
3282     var str = this.str.rewrite(rewriter, new_parents);
3283     if (
3284       name === this.name &&
3285       str === this.str)
3286     {
3287       return rewriter(this, parents);
3288     }
3289     else
3290     {
3291       return rewriter(new PrefixedStringExpression(
3292         name,
3293         str), parents);
3294     }
3295   }
3296   static from_json(json, position, source)
3297   {
3298     let name = EditableSyntax.from_json(
3299       json.prefixed_string_name, position, source);
3300     position += name.width;
3301     let str = EditableSyntax.from_json(
3302       json.prefixed_string_str, position, source);
3303     position += str.width;
3304     return new PrefixedStringExpression(
3305         name,
3306         str);
3307   }
3308   get children_keys()
3309   {
3310     if (PrefixedStringExpression._children_keys == null)
3311       PrefixedStringExpression._children_keys = [
3312         'name',
3313         'str'];
3314     return PrefixedStringExpression._children_keys;
3315   }
3316 }
3317 class VariableExpression extends EditableSyntax
3318 {
3319   constructor(
3320     expression)
3321   {
3322     super('variable', {
3323       expression: expression });
3324   }
3325   get expression() { return this.children.expression; }
3326   with_expression(expression){
3327     return new VariableExpression(
3328       expression);
3329   }
3330   rewrite(rewriter, parents)
3331   {
3332     if (parents == undefined)
3333       parents = [];
3334     let new_parents = parents.slice();
3335     new_parents.push(this);
3336     var expression = this.expression.rewrite(rewriter, new_parents);
3337     if (
3338       expression === this.expression)
3339     {
3340       return rewriter(this, parents);
3341     }
3342     else
3343     {
3344       return rewriter(new VariableExpression(
3345         expression), parents);
3346     }
3347   }
3348   static from_json(json, position, source)
3349   {
3350     let expression = EditableSyntax.from_json(
3351       json.variable_expression, position, source);
3352     position += expression.width;
3353     return new VariableExpression(
3354         expression);
3355   }
3356   get children_keys()
3357   {
3358     if (VariableExpression._children_keys == null)
3359       VariableExpression._children_keys = [
3360         'expression'];
3361     return VariableExpression._children_keys;
3362   }
3363 }
3364 class PipeVariableExpression extends EditableSyntax
3365 {
3366   constructor(
3367     expression)
3368   {
3369     super('pipe_variable', {
3370       expression: expression });
3371   }
3372   get expression() { return this.children.expression; }
3373   with_expression(expression){
3374     return new PipeVariableExpression(
3375       expression);
3376   }
3377   rewrite(rewriter, parents)
3378   {
3379     if (parents == undefined)
3380       parents = [];
3381     let new_parents = parents.slice();
3382     new_parents.push(this);
3383     var expression = this.expression.rewrite(rewriter, new_parents);
3384     if (
3385       expression === this.expression)
3386     {
3387       return rewriter(this, parents);
3388     }
3389     else
3390     {
3391       return rewriter(new PipeVariableExpression(
3392         expression), parents);
3393     }
3394   }
3395   static from_json(json, position, source)
3396   {
3397     let expression = EditableSyntax.from_json(
3398       json.pipe_variable_expression, position, source);
3399     position += expression.width;
3400     return new PipeVariableExpression(
3401         expression);
3402   }
3403   get children_keys()
3404   {
3405     if (PipeVariableExpression._children_keys == null)
3406       PipeVariableExpression._children_keys = [
3407         'expression'];
3408     return PipeVariableExpression._children_keys;
3409   }
3410 }
3411 class FileAttributeSpecification extends EditableSyntax
3412 {
3413   constructor(
3414     left_double_angle,
3415     keyword,
3416     colon,
3417     attributes,
3418     right_double_angle)
3419   {
3420     super('file_attribute_specification', {
3421       left_double_angle: left_double_angle,
3422       keyword: keyword,
3423       colon: colon,
3424       attributes: attributes,
3425       right_double_angle: right_double_angle });
3426   }
3427   get left_double_angle() { return this.children.left_double_angle; }
3428   get keyword() { return this.children.keyword; }
3429   get colon() { return this.children.colon; }
3430   get attributes() { return this.children.attributes; }
3431   get right_double_angle() { return this.children.right_double_angle; }
3432   with_left_double_angle(left_double_angle){
3433     return new FileAttributeSpecification(
3434       left_double_angle,
3435       this.keyword,
3436       this.colon,
3437       this.attributes,
3438       this.right_double_angle);
3439   }
3440   with_keyword(keyword){
3441     return new FileAttributeSpecification(
3442       this.left_double_angle,
3443       keyword,
3444       this.colon,
3445       this.attributes,
3446       this.right_double_angle);
3447   }
3448   with_colon(colon){
3449     return new FileAttributeSpecification(
3450       this.left_double_angle,
3451       this.keyword,
3452       colon,
3453       this.attributes,
3454       this.right_double_angle);
3455   }
3456   with_attributes(attributes){
3457     return new FileAttributeSpecification(
3458       this.left_double_angle,
3459       this.keyword,
3460       this.colon,
3461       attributes,
3462       this.right_double_angle);
3463   }
3464   with_right_double_angle(right_double_angle){
3465     return new FileAttributeSpecification(
3466       this.left_double_angle,
3467       this.keyword,
3468       this.colon,
3469       this.attributes,
3470       right_double_angle);
3471   }
3472   rewrite(rewriter, parents)
3473   {
3474     if (parents == undefined)
3475       parents = [];
3476     let new_parents = parents.slice();
3477     new_parents.push(this);
3478     var left_double_angle = this.left_double_angle.rewrite(rewriter, new_parents);
3479     var keyword = this.keyword.rewrite(rewriter, new_parents);
3480     var colon = this.colon.rewrite(rewriter, new_parents);
3481     var attributes = this.attributes.rewrite(rewriter, new_parents);
3482     var right_double_angle = this.right_double_angle.rewrite(rewriter, new_parents);
3483     if (
3484       left_double_angle === this.left_double_angle &&
3485       keyword === this.keyword &&
3486       colon === this.colon &&
3487       attributes === this.attributes &&
3488       right_double_angle === this.right_double_angle)
3489     {
3490       return rewriter(this, parents);
3491     }
3492     else
3493     {
3494       return rewriter(new FileAttributeSpecification(
3495         left_double_angle,
3496         keyword,
3497         colon,
3498         attributes,
3499         right_double_angle), parents);
3500     }
3501   }
3502   static from_json(json, position, source)
3503   {
3504     let left_double_angle = EditableSyntax.from_json(
3505       json.file_attribute_specification_left_double_angle, position, source);
3506     position += left_double_angle.width;
3507     let keyword = EditableSyntax.from_json(
3508       json.file_attribute_specification_keyword, position, source);
3509     position += keyword.width;
3510     let colon = EditableSyntax.from_json(
3511       json.file_attribute_specification_colon, position, source);
3512     position += colon.width;
3513     let attributes = EditableSyntax.from_json(
3514       json.file_attribute_specification_attributes, position, source);
3515     position += attributes.width;
3516     let right_double_angle = EditableSyntax.from_json(
3517       json.file_attribute_specification_right_double_angle, position, source);
3518     position += right_double_angle.width;
3519     return new FileAttributeSpecification(
3520         left_double_angle,
3521         keyword,
3522         colon,
3523         attributes,
3524         right_double_angle);
3525   }
3526   get children_keys()
3527   {
3528     if (FileAttributeSpecification._children_keys == null)
3529       FileAttributeSpecification._children_keys = [
3530         'left_double_angle',
3531         'keyword',
3532         'colon',
3533         'attributes',
3534         'right_double_angle'];
3535     return FileAttributeSpecification._children_keys;
3536   }
3537 }
3538 class EnumDeclaration extends EditableSyntax
3539 {
3540   constructor(
3541     attribute_spec,
3542     keyword,
3543     name,
3544     colon,
3545     base,
3546     type,
3547     left_brace,
3548     enumerators,
3549     right_brace)
3550   {
3551     super('enum_declaration', {
3552       attribute_spec: attribute_spec,
3553       keyword: keyword,
3554       name: name,
3555       colon: colon,
3556       base: base,
3557       type: type,
3558       left_brace: left_brace,
3559       enumerators: enumerators,
3560       right_brace: right_brace });
3561   }
3562   get attribute_spec() { return this.children.attribute_spec; }
3563   get keyword() { return this.children.keyword; }
3564   get name() { return this.children.name; }
3565   get colon() { return this.children.colon; }
3566   get base() { return this.children.base; }
3567   get type() { return this.children.type; }
3568   get left_brace() { return this.children.left_brace; }
3569   get enumerators() { return this.children.enumerators; }
3570   get right_brace() { return this.children.right_brace; }
3571   with_attribute_spec(attribute_spec){
3572     return new EnumDeclaration(
3573       attribute_spec,
3574       this.keyword,
3575       this.name,
3576       this.colon,
3577       this.base,
3578       this.type,
3579       this.left_brace,
3580       this.enumerators,
3581       this.right_brace);
3582   }
3583   with_keyword(keyword){
3584     return new EnumDeclaration(
3585       this.attribute_spec,
3586       keyword,
3587       this.name,
3588       this.colon,
3589       this.base,
3590       this.type,
3591       this.left_brace,
3592       this.enumerators,
3593       this.right_brace);
3594   }
3595   with_name(name){
3596     return new EnumDeclaration(
3597       this.attribute_spec,
3598       this.keyword,
3599       name,
3600       this.colon,
3601       this.base,
3602       this.type,
3603       this.left_brace,
3604       this.enumerators,
3605       this.right_brace);
3606   }
3607   with_colon(colon){
3608     return new EnumDeclaration(
3609       this.attribute_spec,
3610       this.keyword,
3611       this.name,
3612       colon,
3613       this.base,
3614       this.type,
3615       this.left_brace,
3616       this.enumerators,
3617       this.right_brace);
3618   }
3619   with_base(base){
3620     return new EnumDeclaration(
3621       this.attribute_spec,
3622       this.keyword,
3623       this.name,
3624       this.colon,
3625       base,
3626       this.type,
3627       this.left_brace,
3628       this.enumerators,
3629       this.right_brace);
3630   }
3631   with_type(type){
3632     return new EnumDeclaration(
3633       this.attribute_spec,
3634       this.keyword,
3635       this.name,
3636       this.colon,
3637       this.base,
3638       type,
3639       this.left_brace,
3640       this.enumerators,
3641       this.right_brace);
3642   }
3643   with_left_brace(left_brace){
3644     return new EnumDeclaration(
3645       this.attribute_spec,
3646       this.keyword,
3647       this.name,
3648       this.colon,
3649       this.base,
3650       this.type,
3651       left_brace,
3652       this.enumerators,
3653       this.right_brace);
3654   }
3655   with_enumerators(enumerators){
3656     return new EnumDeclaration(
3657       this.attribute_spec,
3658       this.keyword,
3659       this.name,
3660       this.colon,
3661       this.base,
3662       this.type,
3663       this.left_brace,
3664       enumerators,
3665       this.right_brace);
3666   }
3667   with_right_brace(right_brace){
3668     return new EnumDeclaration(
3669       this.attribute_spec,
3670       this.keyword,
3671       this.name,
3672       this.colon,
3673       this.base,
3674       this.type,
3675       this.left_brace,
3676       this.enumerators,
3677       right_brace);
3678   }
3679   rewrite(rewriter, parents)
3680   {
3681     if (parents == undefined)
3682       parents = [];
3683     let new_parents = parents.slice();
3684     new_parents.push(this);
3685     var attribute_spec = this.attribute_spec.rewrite(rewriter, new_parents);
3686     var keyword = this.keyword.rewrite(rewriter, new_parents);
3687     var name = this.name.rewrite(rewriter, new_parents);
3688     var colon = this.colon.rewrite(rewriter, new_parents);
3689     var base = this.base.rewrite(rewriter, new_parents);
3690     var type = this.type.rewrite(rewriter, new_parents);
3691     var left_brace = this.left_brace.rewrite(rewriter, new_parents);
3692     var enumerators = this.enumerators.rewrite(rewriter, new_parents);
3693     var right_brace = this.right_brace.rewrite(rewriter, new_parents);
3694     if (
3695       attribute_spec === this.attribute_spec &&
3696       keyword === this.keyword &&
3697       name === this.name &&
3698       colon === this.colon &&
3699       base === this.base &&
3700       type === this.type &&
3701       left_brace === this.left_brace &&
3702       enumerators === this.enumerators &&
3703       right_brace === this.right_brace)
3704     {
3705       return rewriter(this, parents);
3706     }
3707     else
3708     {
3709       return rewriter(new EnumDeclaration(
3710         attribute_spec,
3711         keyword,
3712         name,
3713         colon,
3714         base,
3715         type,
3716         left_brace,
3717         enumerators,
3718         right_brace), parents);
3719     }
3720   }
3721   static from_json(json, position, source)
3722   {
3723     let attribute_spec = EditableSyntax.from_json(
3724       json.enum_attribute_spec, position, source);
3725     position += attribute_spec.width;
3726     let keyword = EditableSyntax.from_json(
3727       json.enum_keyword, position, source);
3728     position += keyword.width;
3729     let name = EditableSyntax.from_json(
3730       json.enum_name, position, source);
3731     position += name.width;
3732     let colon = EditableSyntax.from_json(
3733       json.enum_colon, position, source);
3734     position += colon.width;
3735     let base = EditableSyntax.from_json(
3736       json.enum_base, position, source);
3737     position += base.width;
3738     let type = EditableSyntax.from_json(
3739       json.enum_type, position, source);
3740     position += type.width;
3741     let left_brace = EditableSyntax.from_json(
3742       json.enum_left_brace, position, source);
3743     position += left_brace.width;
3744     let enumerators = EditableSyntax.from_json(
3745       json.enum_enumerators, position, source);
3746     position += enumerators.width;
3747     let right_brace = EditableSyntax.from_json(
3748       json.enum_right_brace, position, source);
3749     position += right_brace.width;
3750     return new EnumDeclaration(
3751         attribute_spec,
3752         keyword,
3753         name,
3754         colon,
3755         base,
3756         type,
3757         left_brace,
3758         enumerators,
3759         right_brace);
3760   }
3761   get children_keys()
3762   {
3763     if (EnumDeclaration._children_keys == null)
3764       EnumDeclaration._children_keys = [
3765         'attribute_spec',
3766         'keyword',
3767         'name',
3768         'colon',
3769         'base',
3770         'type',
3771         'left_brace',
3772         'enumerators',
3773         'right_brace'];
3774     return EnumDeclaration._children_keys;
3775   }
3776 }
3777 class Enumerator extends EditableSyntax
3778 {
3779   constructor(
3780     name,
3781     equal,
3782     value,
3783     semicolon)
3784   {
3785     super('enumerator', {
3786       name: name,
3787       equal: equal,
3788       value: value,
3789       semicolon: semicolon });
3790   }
3791   get name() { return this.children.name; }
3792   get equal() { return this.children.equal; }
3793   get value() { return this.children.value; }
3794   get semicolon() { return this.children.semicolon; }
3795   with_name(name){
3796     return new Enumerator(
3797       name,
3798       this.equal,
3799       this.value,
3800       this.semicolon);
3801   }
3802   with_equal(equal){
3803     return new Enumerator(
3804       this.name,
3805       equal,
3806       this.value,
3807       this.semicolon);
3808   }
3809   with_value(value){
3810     return new Enumerator(
3811       this.name,
3812       this.equal,
3813       value,
3814       this.semicolon);
3815   }
3816   with_semicolon(semicolon){
3817     return new Enumerator(
3818       this.name,
3819       this.equal,
3820       this.value,
3821       semicolon);
3822   }
3823   rewrite(rewriter, parents)
3824   {
3825     if (parents == undefined)
3826       parents = [];
3827     let new_parents = parents.slice();
3828     new_parents.push(this);
3829     var name = this.name.rewrite(rewriter, new_parents);
3830     var equal = this.equal.rewrite(rewriter, new_parents);
3831     var value = this.value.rewrite(rewriter, new_parents);
3832     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
3833     if (
3834       name === this.name &&
3835       equal === this.equal &&
3836       value === this.value &&
3837       semicolon === this.semicolon)
3838     {
3839       return rewriter(this, parents);
3840     }
3841     else
3842     {
3843       return rewriter(new Enumerator(
3844         name,
3845         equal,
3846         value,
3847         semicolon), parents);
3848     }
3849   }
3850   static from_json(json, position, source)
3851   {
3852     let name = EditableSyntax.from_json(
3853       json.enumerator_name, position, source);
3854     position += name.width;
3855     let equal = EditableSyntax.from_json(
3856       json.enumerator_equal, position, source);
3857     position += equal.width;
3858     let value = EditableSyntax.from_json(
3859       json.enumerator_value, position, source);
3860     position += value.width;
3861     let semicolon = EditableSyntax.from_json(
3862       json.enumerator_semicolon, position, source);
3863     position += semicolon.width;
3864     return new Enumerator(
3865         name,
3866         equal,
3867         value,
3868         semicolon);
3869   }
3870   get children_keys()
3871   {
3872     if (Enumerator._children_keys == null)
3873       Enumerator._children_keys = [
3874         'name',
3875         'equal',
3876         'value',
3877         'semicolon'];
3878     return Enumerator._children_keys;
3879   }
3880 }
3881 class AliasDeclaration extends EditableSyntax
3882 {
3883   constructor(
3884     attribute_spec,
3885     keyword,
3886     name,
3887     generic_parameter,
3888     constraint,
3889     equal,
3890     type,
3891     semicolon)
3892   {
3893     super('alias_declaration', {
3894       attribute_spec: attribute_spec,
3895       keyword: keyword,
3896       name: name,
3897       generic_parameter: generic_parameter,
3898       constraint: constraint,
3899       equal: equal,
3900       type: type,
3901       semicolon: semicolon });
3902   }
3903   get attribute_spec() { return this.children.attribute_spec; }
3904   get keyword() { return this.children.keyword; }
3905   get name() { return this.children.name; }
3906   get generic_parameter() { return this.children.generic_parameter; }
3907   get constraint() { return this.children.constraint; }
3908   get equal() { return this.children.equal; }
3909   get type() { return this.children.type; }
3910   get semicolon() { return this.children.semicolon; }
3911   with_attribute_spec(attribute_spec){
3912     return new AliasDeclaration(
3913       attribute_spec,
3914       this.keyword,
3915       this.name,
3916       this.generic_parameter,
3917       this.constraint,
3918       this.equal,
3919       this.type,
3920       this.semicolon);
3921   }
3922   with_keyword(keyword){
3923     return new AliasDeclaration(
3924       this.attribute_spec,
3925       keyword,
3926       this.name,
3927       this.generic_parameter,
3928       this.constraint,
3929       this.equal,
3930       this.type,
3931       this.semicolon);
3932   }
3933   with_name(name){
3934     return new AliasDeclaration(
3935       this.attribute_spec,
3936       this.keyword,
3937       name,
3938       this.generic_parameter,
3939       this.constraint,
3940       this.equal,
3941       this.type,
3942       this.semicolon);
3943   }
3944   with_generic_parameter(generic_parameter){
3945     return new AliasDeclaration(
3946       this.attribute_spec,
3947       this.keyword,
3948       this.name,
3949       generic_parameter,
3950       this.constraint,
3951       this.equal,
3952       this.type,
3953       this.semicolon);
3954   }
3955   with_constraint(constraint){
3956     return new AliasDeclaration(
3957       this.attribute_spec,
3958       this.keyword,
3959       this.name,
3960       this.generic_parameter,
3961       constraint,
3962       this.equal,
3963       this.type,
3964       this.semicolon);
3965   }
3966   with_equal(equal){
3967     return new AliasDeclaration(
3968       this.attribute_spec,
3969       this.keyword,
3970       this.name,
3971       this.generic_parameter,
3972       this.constraint,
3973       equal,
3974       this.type,
3975       this.semicolon);
3976   }
3977   with_type(type){
3978     return new AliasDeclaration(
3979       this.attribute_spec,
3980       this.keyword,
3981       this.name,
3982       this.generic_parameter,
3983       this.constraint,
3984       this.equal,
3985       type,
3986       this.semicolon);
3987   }
3988   with_semicolon(semicolon){
3989     return new AliasDeclaration(
3990       this.attribute_spec,
3991       this.keyword,
3992       this.name,
3993       this.generic_parameter,
3994       this.constraint,
3995       this.equal,
3996       this.type,
3997       semicolon);
3998   }
3999   rewrite(rewriter, parents)
4000   {
4001     if (parents == undefined)
4002       parents = [];
4003     let new_parents = parents.slice();
4004     new_parents.push(this);
4005     var attribute_spec = this.attribute_spec.rewrite(rewriter, new_parents);
4006     var keyword = this.keyword.rewrite(rewriter, new_parents);
4007     var name = this.name.rewrite(rewriter, new_parents);
4008     var generic_parameter = this.generic_parameter.rewrite(rewriter, new_parents);
4009     var constraint = this.constraint.rewrite(rewriter, new_parents);
4010     var equal = this.equal.rewrite(rewriter, new_parents);
4011     var type = this.type.rewrite(rewriter, new_parents);
4012     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
4013     if (
4014       attribute_spec === this.attribute_spec &&
4015       keyword === this.keyword &&
4016       name === this.name &&
4017       generic_parameter === this.generic_parameter &&
4018       constraint === this.constraint &&
4019       equal === this.equal &&
4020       type === this.type &&
4021       semicolon === this.semicolon)
4022     {
4023       return rewriter(this, parents);
4024     }
4025     else
4026     {
4027       return rewriter(new AliasDeclaration(
4028         attribute_spec,
4029         keyword,
4030         name,
4031         generic_parameter,
4032         constraint,
4033         equal,
4034         type,
4035         semicolon), parents);
4036     }
4037   }
4038   static from_json(json, position, source)
4039   {
4040     let attribute_spec = EditableSyntax.from_json(
4041       json.alias_attribute_spec, position, source);
4042     position += attribute_spec.width;
4043     let keyword = EditableSyntax.from_json(
4044       json.alias_keyword, position, source);
4045     position += keyword.width;
4046     let name = EditableSyntax.from_json(
4047       json.alias_name, position, source);
4048     position += name.width;
4049     let generic_parameter = EditableSyntax.from_json(
4050       json.alias_generic_parameter, position, source);
4051     position += generic_parameter.width;
4052     let constraint = EditableSyntax.from_json(
4053       json.alias_constraint, position, source);
4054     position += constraint.width;
4055     let equal = EditableSyntax.from_json(
4056       json.alias_equal, position, source);
4057     position += equal.width;
4058     let type = EditableSyntax.from_json(
4059       json.alias_type, position, source);
4060     position += type.width;
4061     let semicolon = EditableSyntax.from_json(
4062       json.alias_semicolon, position, source);
4063     position += semicolon.width;
4064     return new AliasDeclaration(
4065         attribute_spec,
4066         keyword,
4067         name,
4068         generic_parameter,
4069         constraint,
4070         equal,
4071         type,
4072         semicolon);
4073   }
4074   get children_keys()
4075   {
4076     if (AliasDeclaration._children_keys == null)
4077       AliasDeclaration._children_keys = [
4078         'attribute_spec',
4079         'keyword',
4080         'name',
4081         'generic_parameter',
4082         'constraint',
4083         'equal',
4084         'type',
4085         'semicolon'];
4086     return AliasDeclaration._children_keys;
4087   }
4088 }
4089 class PropertyDeclaration extends EditableSyntax
4090 {
4091   constructor(
4092     attribute_spec,
4093     modifiers,
4094     type,
4095     declarators,
4096     semicolon)
4097   {
4098     super('property_declaration', {
4099       attribute_spec: attribute_spec,
4100       modifiers: modifiers,
4101       type: type,
4102       declarators: declarators,
4103       semicolon: semicolon });
4104   }
4105   get attribute_spec() { return this.children.attribute_spec; }
4106   get modifiers() { return this.children.modifiers; }
4107   get type() { return this.children.type; }
4108   get declarators() { return this.children.declarators; }
4109   get semicolon() { return this.children.semicolon; }
4110   with_attribute_spec(attribute_spec){
4111     return new PropertyDeclaration(
4112       attribute_spec,
4113       this.modifiers,
4114       this.type,
4115       this.declarators,
4116       this.semicolon);
4117   }
4118   with_modifiers(modifiers){
4119     return new PropertyDeclaration(
4120       this.attribute_spec,
4121       modifiers,
4122       this.type,
4123       this.declarators,
4124       this.semicolon);
4125   }
4126   with_type(type){
4127     return new PropertyDeclaration(
4128       this.attribute_spec,
4129       this.modifiers,
4130       type,
4131       this.declarators,
4132       this.semicolon);
4133   }
4134   with_declarators(declarators){
4135     return new PropertyDeclaration(
4136       this.attribute_spec,
4137       this.modifiers,
4138       this.type,
4139       declarators,
4140       this.semicolon);
4141   }
4142   with_semicolon(semicolon){
4143     return new PropertyDeclaration(
4144       this.attribute_spec,
4145       this.modifiers,
4146       this.type,
4147       this.declarators,
4148       semicolon);
4149   }
4150   rewrite(rewriter, parents)
4151   {
4152     if (parents == undefined)
4153       parents = [];
4154     let new_parents = parents.slice();
4155     new_parents.push(this);
4156     var attribute_spec = this.attribute_spec.rewrite(rewriter, new_parents);
4157     var modifiers = this.modifiers.rewrite(rewriter, new_parents);
4158     var type = this.type.rewrite(rewriter, new_parents);
4159     var declarators = this.declarators.rewrite(rewriter, new_parents);
4160     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
4161     if (
4162       attribute_spec === this.attribute_spec &&
4163       modifiers === this.modifiers &&
4164       type === this.type &&
4165       declarators === this.declarators &&
4166       semicolon === this.semicolon)
4167     {
4168       return rewriter(this, parents);
4169     }
4170     else
4171     {
4172       return rewriter(new PropertyDeclaration(
4173         attribute_spec,
4174         modifiers,
4175         type,
4176         declarators,
4177         semicolon), parents);
4178     }
4179   }
4180   static from_json(json, position, source)
4181   {
4182     let attribute_spec = EditableSyntax.from_json(
4183       json.property_attribute_spec, position, source);
4184     position += attribute_spec.width;
4185     let modifiers = EditableSyntax.from_json(
4186       json.property_modifiers, position, source);
4187     position += modifiers.width;
4188     let type = EditableSyntax.from_json(
4189       json.property_type, position, source);
4190     position += type.width;
4191     let declarators = EditableSyntax.from_json(
4192       json.property_declarators, position, source);
4193     position += declarators.width;
4194     let semicolon = EditableSyntax.from_json(
4195       json.property_semicolon, position, source);
4196     position += semicolon.width;
4197     return new PropertyDeclaration(
4198         attribute_spec,
4199         modifiers,
4200         type,
4201         declarators,
4202         semicolon);
4203   }
4204   get children_keys()
4205   {
4206     if (PropertyDeclaration._children_keys == null)
4207       PropertyDeclaration._children_keys = [
4208         'attribute_spec',
4209         'modifiers',
4210         'type',
4211         'declarators',
4212         'semicolon'];
4213     return PropertyDeclaration._children_keys;
4214   }
4215 }
4216 class PropertyDeclarator extends EditableSyntax
4217 {
4218   constructor(
4219     name,
4220     initializer)
4221   {
4222     super('property_declarator', {
4223       name: name,
4224       initializer: initializer });
4225   }
4226   get name() { return this.children.name; }
4227   get initializer() { return this.children.initializer; }
4228   with_name(name){
4229     return new PropertyDeclarator(
4230       name,
4231       this.initializer);
4232   }
4233   with_initializer(initializer){
4234     return new PropertyDeclarator(
4235       this.name,
4236       initializer);
4237   }
4238   rewrite(rewriter, parents)
4239   {
4240     if (parents == undefined)
4241       parents = [];
4242     let new_parents = parents.slice();
4243     new_parents.push(this);
4244     var name = this.name.rewrite(rewriter, new_parents);
4245     var initializer = this.initializer.rewrite(rewriter, new_parents);
4246     if (
4247       name === this.name &&
4248       initializer === this.initializer)
4249     {
4250       return rewriter(this, parents);
4251     }
4252     else
4253     {
4254       return rewriter(new PropertyDeclarator(
4255         name,
4256         initializer), parents);
4257     }
4258   }
4259   static from_json(json, position, source)
4260   {
4261     let name = EditableSyntax.from_json(
4262       json.property_name, position, source);
4263     position += name.width;
4264     let initializer = EditableSyntax.from_json(
4265       json.property_initializer, position, source);
4266     position += initializer.width;
4267     return new PropertyDeclarator(
4268         name,
4269         initializer);
4270   }
4271   get children_keys()
4272   {
4273     if (PropertyDeclarator._children_keys == null)
4274       PropertyDeclarator._children_keys = [
4275         'name',
4276         'initializer'];
4277     return PropertyDeclarator._children_keys;
4278   }
4279 }
4280 class NamespaceDeclaration extends EditableSyntax
4281 {
4282   constructor(
4283     keyword,
4284     name,
4285     body)
4286   {
4287     super('namespace_declaration', {
4288       keyword: keyword,
4289       name: name,
4290       body: body });
4291   }
4292   get keyword() { return this.children.keyword; }
4293   get name() { return this.children.name; }
4294   get body() { return this.children.body; }
4295   with_keyword(keyword){
4296     return new NamespaceDeclaration(
4297       keyword,
4298       this.name,
4299       this.body);
4300   }
4301   with_name(name){
4302     return new NamespaceDeclaration(
4303       this.keyword,
4304       name,
4305       this.body);
4306   }
4307   with_body(body){
4308     return new NamespaceDeclaration(
4309       this.keyword,
4310       this.name,
4311       body);
4312   }
4313   rewrite(rewriter, parents)
4314   {
4315     if (parents == undefined)
4316       parents = [];
4317     let new_parents = parents.slice();
4318     new_parents.push(this);
4319     var keyword = this.keyword.rewrite(rewriter, new_parents);
4320     var name = this.name.rewrite(rewriter, new_parents);
4321     var body = this.body.rewrite(rewriter, new_parents);
4322     if (
4323       keyword === this.keyword &&
4324       name === this.name &&
4325       body === this.body)
4326     {
4327       return rewriter(this, parents);
4328     }
4329     else
4330     {
4331       return rewriter(new NamespaceDeclaration(
4332         keyword,
4333         name,
4334         body), parents);
4335     }
4336   }
4337   static from_json(json, position, source)
4338   {
4339     let keyword = EditableSyntax.from_json(
4340       json.namespace_keyword, position, source);
4341     position += keyword.width;
4342     let name = EditableSyntax.from_json(
4343       json.namespace_name, position, source);
4344     position += name.width;
4345     let body = EditableSyntax.from_json(
4346       json.namespace_body, position, source);
4347     position += body.width;
4348     return new NamespaceDeclaration(
4349         keyword,
4350         name,
4351         body);
4352   }
4353   get children_keys()
4354   {
4355     if (NamespaceDeclaration._children_keys == null)
4356       NamespaceDeclaration._children_keys = [
4357         'keyword',
4358         'name',
4359         'body'];
4360     return NamespaceDeclaration._children_keys;
4361   }
4362 }
4363 class NamespaceBody extends EditableSyntax
4364 {
4365   constructor(
4366     left_brace,
4367     declarations,
4368     right_brace)
4369   {
4370     super('namespace_body', {
4371       left_brace: left_brace,
4372       declarations: declarations,
4373       right_brace: right_brace });
4374   }
4375   get left_brace() { return this.children.left_brace; }
4376   get declarations() { return this.children.declarations; }
4377   get right_brace() { return this.children.right_brace; }
4378   with_left_brace(left_brace){
4379     return new NamespaceBody(
4380       left_brace,
4381       this.declarations,
4382       this.right_brace);
4383   }
4384   with_declarations(declarations){
4385     return new NamespaceBody(
4386       this.left_brace,
4387       declarations,
4388       this.right_brace);
4389   }
4390   with_right_brace(right_brace){
4391     return new NamespaceBody(
4392       this.left_brace,
4393       this.declarations,
4394       right_brace);
4395   }
4396   rewrite(rewriter, parents)
4397   {
4398     if (parents == undefined)
4399       parents = [];
4400     let new_parents = parents.slice();
4401     new_parents.push(this);
4402     var left_brace = this.left_brace.rewrite(rewriter, new_parents);
4403     var declarations = this.declarations.rewrite(rewriter, new_parents);
4404     var right_brace = this.right_brace.rewrite(rewriter, new_parents);
4405     if (
4406       left_brace === this.left_brace &&
4407       declarations === this.declarations &&
4408       right_brace === this.right_brace)
4409     {
4410       return rewriter(this, parents);
4411     }
4412     else
4413     {
4414       return rewriter(new NamespaceBody(
4415         left_brace,
4416         declarations,
4417         right_brace), parents);
4418     }
4419   }
4420   static from_json(json, position, source)
4421   {
4422     let left_brace = EditableSyntax.from_json(
4423       json.namespace_left_brace, position, source);
4424     position += left_brace.width;
4425     let declarations = EditableSyntax.from_json(
4426       json.namespace_declarations, position, source);
4427     position += declarations.width;
4428     let right_brace = EditableSyntax.from_json(
4429       json.namespace_right_brace, position, source);
4430     position += right_brace.width;
4431     return new NamespaceBody(
4432         left_brace,
4433         declarations,
4434         right_brace);
4435   }
4436   get children_keys()
4437   {
4438     if (NamespaceBody._children_keys == null)
4439       NamespaceBody._children_keys = [
4440         'left_brace',
4441         'declarations',
4442         'right_brace'];
4443     return NamespaceBody._children_keys;
4444   }
4445 }
4446 class NamespaceEmptyBody extends EditableSyntax
4447 {
4448   constructor(
4449     semicolon)
4450   {
4451     super('namespace_empty_body', {
4452       semicolon: semicolon });
4453   }
4454   get semicolon() { return this.children.semicolon; }
4455   with_semicolon(semicolon){
4456     return new NamespaceEmptyBody(
4457       semicolon);
4458   }
4459   rewrite(rewriter, parents)
4460   {
4461     if (parents == undefined)
4462       parents = [];
4463     let new_parents = parents.slice();
4464     new_parents.push(this);
4465     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
4466     if (
4467       semicolon === this.semicolon)
4468     {
4469       return rewriter(this, parents);
4470     }
4471     else
4472     {
4473       return rewriter(new NamespaceEmptyBody(
4474         semicolon), parents);
4475     }
4476   }
4477   static from_json(json, position, source)
4478   {
4479     let semicolon = EditableSyntax.from_json(
4480       json.namespace_semicolon, position, source);
4481     position += semicolon.width;
4482     return new NamespaceEmptyBody(
4483         semicolon);
4484   }
4485   get children_keys()
4486   {
4487     if (NamespaceEmptyBody._children_keys == null)
4488       NamespaceEmptyBody._children_keys = [
4489         'semicolon'];
4490     return NamespaceEmptyBody._children_keys;
4491   }
4492 }
4493 class NamespaceUseDeclaration extends EditableSyntax
4494 {
4495   constructor(
4496     keyword,
4497     kind,
4498     clauses,
4499     semicolon)
4500   {
4501     super('namespace_use_declaration', {
4502       keyword: keyword,
4503       kind: kind,
4504       clauses: clauses,
4505       semicolon: semicolon });
4506   }
4507   get keyword() { return this.children.keyword; }
4508   get kind() { return this.children.kind; }
4509   get clauses() { return this.children.clauses; }
4510   get semicolon() { return this.children.semicolon; }
4511   with_keyword(keyword){
4512     return new NamespaceUseDeclaration(
4513       keyword,
4514       this.kind,
4515       this.clauses,
4516       this.semicolon);
4517   }
4518   with_kind(kind){
4519     return new NamespaceUseDeclaration(
4520       this.keyword,
4521       kind,
4522       this.clauses,
4523       this.semicolon);
4524   }
4525   with_clauses(clauses){
4526     return new NamespaceUseDeclaration(
4527       this.keyword,
4528       this.kind,
4529       clauses,
4530       this.semicolon);
4531   }
4532   with_semicolon(semicolon){
4533     return new NamespaceUseDeclaration(
4534       this.keyword,
4535       this.kind,
4536       this.clauses,
4537       semicolon);
4538   }
4539   rewrite(rewriter, parents)
4540   {
4541     if (parents == undefined)
4542       parents = [];
4543     let new_parents = parents.slice();
4544     new_parents.push(this);
4545     var keyword = this.keyword.rewrite(rewriter, new_parents);
4546     var kind = this.kind.rewrite(rewriter, new_parents);
4547     var clauses = this.clauses.rewrite(rewriter, new_parents);
4548     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
4549     if (
4550       keyword === this.keyword &&
4551       kind === this.kind &&
4552       clauses === this.clauses &&
4553       semicolon === this.semicolon)
4554     {
4555       return rewriter(this, parents);
4556     }
4557     else
4558     {
4559       return rewriter(new NamespaceUseDeclaration(
4560         keyword,
4561         kind,
4562         clauses,
4563         semicolon), parents);
4564     }
4565   }
4566   static from_json(json, position, source)
4567   {
4568     let keyword = EditableSyntax.from_json(
4569       json.namespace_use_keyword, position, source);
4570     position += keyword.width;
4571     let kind = EditableSyntax.from_json(
4572       json.namespace_use_kind, position, source);
4573     position += kind.width;
4574     let clauses = EditableSyntax.from_json(
4575       json.namespace_use_clauses, position, source);
4576     position += clauses.width;
4577     let semicolon = EditableSyntax.from_json(
4578       json.namespace_use_semicolon, position, source);
4579     position += semicolon.width;
4580     return new NamespaceUseDeclaration(
4581         keyword,
4582         kind,
4583         clauses,
4584         semicolon);
4585   }
4586   get children_keys()
4587   {
4588     if (NamespaceUseDeclaration._children_keys == null)
4589       NamespaceUseDeclaration._children_keys = [
4590         'keyword',
4591         'kind',
4592         'clauses',
4593         'semicolon'];
4594     return NamespaceUseDeclaration._children_keys;
4595   }
4596 }
4597 class NamespaceGroupUseDeclaration extends EditableSyntax
4598 {
4599   constructor(
4600     keyword,
4601     kind,
4602     prefix,
4603     left_brace,
4604     clauses,
4605     right_brace,
4606     semicolon)
4607   {
4608     super('namespace_group_use_declaration', {
4609       keyword: keyword,
4610       kind: kind,
4611       prefix: prefix,
4612       left_brace: left_brace,
4613       clauses: clauses,
4614       right_brace: right_brace,
4615       semicolon: semicolon });
4616   }
4617   get keyword() { return this.children.keyword; }
4618   get kind() { return this.children.kind; }
4619   get prefix() { return this.children.prefix; }
4620   get left_brace() { return this.children.left_brace; }
4621   get clauses() { return this.children.clauses; }
4622   get right_brace() { return this.children.right_brace; }
4623   get semicolon() { return this.children.semicolon; }
4624   with_keyword(keyword){
4625     return new NamespaceGroupUseDeclaration(
4626       keyword,
4627       this.kind,
4628       this.prefix,
4629       this.left_brace,
4630       this.clauses,
4631       this.right_brace,
4632       this.semicolon);
4633   }
4634   with_kind(kind){
4635     return new NamespaceGroupUseDeclaration(
4636       this.keyword,
4637       kind,
4638       this.prefix,
4639       this.left_brace,
4640       this.clauses,
4641       this.right_brace,
4642       this.semicolon);
4643   }
4644   with_prefix(prefix){
4645     return new NamespaceGroupUseDeclaration(
4646       this.keyword,
4647       this.kind,
4648       prefix,
4649       this.left_brace,
4650       this.clauses,
4651       this.right_brace,
4652       this.semicolon);
4653   }
4654   with_left_brace(left_brace){
4655     return new NamespaceGroupUseDeclaration(
4656       this.keyword,
4657       this.kind,
4658       this.prefix,
4659       left_brace,
4660       this.clauses,
4661       this.right_brace,
4662       this.semicolon);
4663   }
4664   with_clauses(clauses){
4665     return new NamespaceGroupUseDeclaration(
4666       this.keyword,
4667       this.kind,
4668       this.prefix,
4669       this.left_brace,
4670       clauses,
4671       this.right_brace,
4672       this.semicolon);
4673   }
4674   with_right_brace(right_brace){
4675     return new NamespaceGroupUseDeclaration(
4676       this.keyword,
4677       this.kind,
4678       this.prefix,
4679       this.left_brace,
4680       this.clauses,
4681       right_brace,
4682       this.semicolon);
4683   }
4684   with_semicolon(semicolon){
4685     return new NamespaceGroupUseDeclaration(
4686       this.keyword,
4687       this.kind,
4688       this.prefix,
4689       this.left_brace,
4690       this.clauses,
4691       this.right_brace,
4692       semicolon);
4693   }
4694   rewrite(rewriter, parents)
4695   {
4696     if (parents == undefined)
4697       parents = [];
4698     let new_parents = parents.slice();
4699     new_parents.push(this);
4700     var keyword = this.keyword.rewrite(rewriter, new_parents);
4701     var kind = this.kind.rewrite(rewriter, new_parents);
4702     var prefix = this.prefix.rewrite(rewriter, new_parents);
4703     var left_brace = this.left_brace.rewrite(rewriter, new_parents);
4704     var clauses = this.clauses.rewrite(rewriter, new_parents);
4705     var right_brace = this.right_brace.rewrite(rewriter, new_parents);
4706     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
4707     if (
4708       keyword === this.keyword &&
4709       kind === this.kind &&
4710       prefix === this.prefix &&
4711       left_brace === this.left_brace &&
4712       clauses === this.clauses &&
4713       right_brace === this.right_brace &&
4714       semicolon === this.semicolon)
4715     {
4716       return rewriter(this, parents);
4717     }
4718     else
4719     {
4720       return rewriter(new NamespaceGroupUseDeclaration(
4721         keyword,
4722         kind,
4723         prefix,
4724         left_brace,
4725         clauses,
4726         right_brace,
4727         semicolon), parents);
4728     }
4729   }
4730   static from_json(json, position, source)
4731   {
4732     let keyword = EditableSyntax.from_json(
4733       json.namespace_group_use_keyword, position, source);
4734     position += keyword.width;
4735     let kind = EditableSyntax.from_json(
4736       json.namespace_group_use_kind, position, source);
4737     position += kind.width;
4738     let prefix = EditableSyntax.from_json(
4739       json.namespace_group_use_prefix, position, source);
4740     position += prefix.width;
4741     let left_brace = EditableSyntax.from_json(
4742       json.namespace_group_use_left_brace, position, source);
4743     position += left_brace.width;
4744     let clauses = EditableSyntax.from_json(
4745       json.namespace_group_use_clauses, position, source);
4746     position += clauses.width;
4747     let right_brace = EditableSyntax.from_json(
4748       json.namespace_group_use_right_brace, position, source);
4749     position += right_brace.width;
4750     let semicolon = EditableSyntax.from_json(
4751       json.namespace_group_use_semicolon, position, source);
4752     position += semicolon.width;
4753     return new NamespaceGroupUseDeclaration(
4754         keyword,
4755         kind,
4756         prefix,
4757         left_brace,
4758         clauses,
4759         right_brace,
4760         semicolon);
4761   }
4762   get children_keys()
4763   {
4764     if (NamespaceGroupUseDeclaration._children_keys == null)
4765       NamespaceGroupUseDeclaration._children_keys = [
4766         'keyword',
4767         'kind',
4768         'prefix',
4769         'left_brace',
4770         'clauses',
4771         'right_brace',
4772         'semicolon'];
4773     return NamespaceGroupUseDeclaration._children_keys;
4774   }
4775 }
4776 class NamespaceUseClause extends EditableSyntax
4777 {
4778   constructor(
4779     clause_kind,
4780     name,
4781     as,
4782     alias)
4783   {
4784     super('namespace_use_clause', {
4785       clause_kind: clause_kind,
4786       name: name,
4787       as: as,
4788       alias: alias });
4789   }
4790   get clause_kind() { return this.children.clause_kind; }
4791   get name() { return this.children.name; }
4792   get as() { return this.children.as; }
4793   get alias() { return this.children.alias; }
4794   with_clause_kind(clause_kind){
4795     return new NamespaceUseClause(
4796       clause_kind,
4797       this.name,
4798       this.as,
4799       this.alias);
4800   }
4801   with_name(name){
4802     return new NamespaceUseClause(
4803       this.clause_kind,
4804       name,
4805       this.as,
4806       this.alias);
4807   }
4808   with_as(as){
4809     return new NamespaceUseClause(
4810       this.clause_kind,
4811       this.name,
4812       as,
4813       this.alias);
4814   }
4815   with_alias(alias){
4816     return new NamespaceUseClause(
4817       this.clause_kind,
4818       this.name,
4819       this.as,
4820       alias);
4821   }
4822   rewrite(rewriter, parents)
4823   {
4824     if (parents == undefined)
4825       parents = [];
4826     let new_parents = parents.slice();
4827     new_parents.push(this);
4828     var clause_kind = this.clause_kind.rewrite(rewriter, new_parents);
4829     var name = this.name.rewrite(rewriter, new_parents);
4830     var as = this.as.rewrite(rewriter, new_parents);
4831     var alias = this.alias.rewrite(rewriter, new_parents);
4832     if (
4833       clause_kind === this.clause_kind &&
4834       name === this.name &&
4835       as === this.as &&
4836       alias === this.alias)
4837     {
4838       return rewriter(this, parents);
4839     }
4840     else
4841     {
4842       return rewriter(new NamespaceUseClause(
4843         clause_kind,
4844         name,
4845         as,
4846         alias), parents);
4847     }
4848   }
4849   static from_json(json, position, source)
4850   {
4851     let clause_kind = EditableSyntax.from_json(
4852       json.namespace_use_clause_kind, position, source);
4853     position += clause_kind.width;
4854     let name = EditableSyntax.from_json(
4855       json.namespace_use_name, position, source);
4856     position += name.width;
4857     let as = EditableSyntax.from_json(
4858       json.namespace_use_as, position, source);
4859     position += as.width;
4860     let alias = EditableSyntax.from_json(
4861       json.namespace_use_alias, position, source);
4862     position += alias.width;
4863     return new NamespaceUseClause(
4864         clause_kind,
4865         name,
4866         as,
4867         alias);
4868   }
4869   get children_keys()
4870   {
4871     if (NamespaceUseClause._children_keys == null)
4872       NamespaceUseClause._children_keys = [
4873         'clause_kind',
4874         'name',
4875         'as',
4876         'alias'];
4877     return NamespaceUseClause._children_keys;
4878   }
4879 }
4880 class FunctionDeclaration extends EditableSyntax
4881 {
4882   constructor(
4883     attribute_spec,
4884     declaration_header,
4885     body)
4886   {
4887     super('function_declaration', {
4888       attribute_spec: attribute_spec,
4889       declaration_header: declaration_header,
4890       body: body });
4891   }
4892   get attribute_spec() { return this.children.attribute_spec; }
4893   get declaration_header() { return this.children.declaration_header; }
4894   get body() { return this.children.body; }
4895   with_attribute_spec(attribute_spec){
4896     return new FunctionDeclaration(
4897       attribute_spec,
4898       this.declaration_header,
4899       this.body);
4900   }
4901   with_declaration_header(declaration_header){
4902     return new FunctionDeclaration(
4903       this.attribute_spec,
4904       declaration_header,
4905       this.body);
4906   }
4907   with_body(body){
4908     return new FunctionDeclaration(
4909       this.attribute_spec,
4910       this.declaration_header,
4911       body);
4912   }
4913   rewrite(rewriter, parents)
4914   {
4915     if (parents == undefined)
4916       parents = [];
4917     let new_parents = parents.slice();
4918     new_parents.push(this);
4919     var attribute_spec = this.attribute_spec.rewrite(rewriter, new_parents);
4920     var declaration_header = this.declaration_header.rewrite(rewriter, new_parents);
4921     var body = this.body.rewrite(rewriter, new_parents);
4922     if (
4923       attribute_spec === this.attribute_spec &&
4924       declaration_header === this.declaration_header &&
4925       body === this.body)
4926     {
4927       return rewriter(this, parents);
4928     }
4929     else
4930     {
4931       return rewriter(new FunctionDeclaration(
4932         attribute_spec,
4933         declaration_header,
4934         body), parents);
4935     }
4936   }
4937   static from_json(json, position, source)
4938   {
4939     let attribute_spec = EditableSyntax.from_json(
4940       json.function_attribute_spec, position, source);
4941     position += attribute_spec.width;
4942     let declaration_header = EditableSyntax.from_json(
4943       json.function_declaration_header, position, source);
4944     position += declaration_header.width;
4945     let body = EditableSyntax.from_json(
4946       json.function_body, position, source);
4947     position += body.width;
4948     return new FunctionDeclaration(
4949         attribute_spec,
4950         declaration_header,
4951         body);
4952   }
4953   get children_keys()
4954   {
4955     if (FunctionDeclaration._children_keys == null)
4956       FunctionDeclaration._children_keys = [
4957         'attribute_spec',
4958         'declaration_header',
4959         'body'];
4960     return FunctionDeclaration._children_keys;
4961   }
4962 }
4963 class FunctionDeclarationHeader extends EditableSyntax
4964 {
4965   constructor(
4966     modifiers,
4967     keyword,
4968     name,
4969     type_parameter_list,
4970     left_paren,
4971     parameter_list,
4972     right_paren,
4973     colon,
4974     type,
4975     where_clause)
4976   {
4977     super('function_declaration_header', {
4978       modifiers: modifiers,
4979       keyword: keyword,
4980       name: name,
4981       type_parameter_list: type_parameter_list,
4982       left_paren: left_paren,
4983       parameter_list: parameter_list,
4984       right_paren: right_paren,
4985       colon: colon,
4986       type: type,
4987       where_clause: where_clause });
4988   }
4989   get modifiers() { return this.children.modifiers; }
4990   get keyword() { return this.children.keyword; }
4991   get name() { return this.children.name; }
4992   get type_parameter_list() { return this.children.type_parameter_list; }
4993   get left_paren() { return this.children.left_paren; }
4994   get parameter_list() { return this.children.parameter_list; }
4995   get right_paren() { return this.children.right_paren; }
4996   get colon() { return this.children.colon; }
4997   get type() { return this.children.type; }
4998   get where_clause() { return this.children.where_clause; }
4999   with_modifiers(modifiers){
5000     return new FunctionDeclarationHeader(
5001       modifiers,
5002       this.keyword,
5003       this.name,
5004       this.type_parameter_list,
5005       this.left_paren,
5006       this.parameter_list,
5007       this.right_paren,
5008       this.colon,
5009       this.type,
5010       this.where_clause);
5011   }
5012   with_keyword(keyword){
5013     return new FunctionDeclarationHeader(
5014       this.modifiers,
5015       keyword,
5016       this.name,
5017       this.type_parameter_list,
5018       this.left_paren,
5019       this.parameter_list,
5020       this.right_paren,
5021       this.colon,
5022       this.type,
5023       this.where_clause);
5024   }
5025   with_name(name){
5026     return new FunctionDeclarationHeader(
5027       this.modifiers,
5028       this.keyword,
5029       name,
5030       this.type_parameter_list,
5031       this.left_paren,
5032       this.parameter_list,
5033       this.right_paren,
5034       this.colon,
5035       this.type,
5036       this.where_clause);
5037   }
5038   with_type_parameter_list(type_parameter_list){
5039     return new FunctionDeclarationHeader(
5040       this.modifiers,
5041       this.keyword,
5042       this.name,
5043       type_parameter_list,
5044       this.left_paren,
5045       this.parameter_list,
5046       this.right_paren,
5047       this.colon,
5048       this.type,
5049       this.where_clause);
5050   }
5051   with_left_paren(left_paren){
5052     return new FunctionDeclarationHeader(
5053       this.modifiers,
5054       this.keyword,
5055       this.name,
5056       this.type_parameter_list,
5057       left_paren,
5058       this.parameter_list,
5059       this.right_paren,
5060       this.colon,
5061       this.type,
5062       this.where_clause);
5063   }
5064   with_parameter_list(parameter_list){
5065     return new FunctionDeclarationHeader(
5066       this.modifiers,
5067       this.keyword,
5068       this.name,
5069       this.type_parameter_list,
5070       this.left_paren,
5071       parameter_list,
5072       this.right_paren,
5073       this.colon,
5074       this.type,
5075       this.where_clause);
5076   }
5077   with_right_paren(right_paren){
5078     return new FunctionDeclarationHeader(
5079       this.modifiers,
5080       this.keyword,
5081       this.name,
5082       this.type_parameter_list,
5083       this.left_paren,
5084       this.parameter_list,
5085       right_paren,
5086       this.colon,
5087       this.type,
5088       this.where_clause);
5089   }
5090   with_colon(colon){
5091     return new FunctionDeclarationHeader(
5092       this.modifiers,
5093       this.keyword,
5094       this.name,
5095       this.type_parameter_list,
5096       this.left_paren,
5097       this.parameter_list,
5098       this.right_paren,
5099       colon,
5100       this.type,
5101       this.where_clause);
5102   }
5103   with_type(type){
5104     return new FunctionDeclarationHeader(
5105       this.modifiers,
5106       this.keyword,
5107       this.name,
5108       this.type_parameter_list,
5109       this.left_paren,
5110       this.parameter_list,
5111       this.right_paren,
5112       this.colon,
5113       type,
5114       this.where_clause);
5115   }
5116   with_where_clause(where_clause){
5117     return new FunctionDeclarationHeader(
5118       this.modifiers,
5119       this.keyword,
5120       this.name,
5121       this.type_parameter_list,
5122       this.left_paren,
5123       this.parameter_list,
5124       this.right_paren,
5125       this.colon,
5126       this.type,
5127       where_clause);
5128   }
5129   rewrite(rewriter, parents)
5130   {
5131     if (parents == undefined)
5132       parents = [];
5133     let new_parents = parents.slice();
5134     new_parents.push(this);
5135     var modifiers = this.modifiers.rewrite(rewriter, new_parents);
5136     var keyword = this.keyword.rewrite(rewriter, new_parents);
5137     var name = this.name.rewrite(rewriter, new_parents);
5138     var type_parameter_list = this.type_parameter_list.rewrite(rewriter, new_parents);
5139     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
5140     var parameter_list = this.parameter_list.rewrite(rewriter, new_parents);
5141     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
5142     var colon = this.colon.rewrite(rewriter, new_parents);
5143     var type = this.type.rewrite(rewriter, new_parents);
5144     var where_clause = this.where_clause.rewrite(rewriter, new_parents);
5145     if (
5146       modifiers === this.modifiers &&
5147       keyword === this.keyword &&
5148       name === this.name &&
5149       type_parameter_list === this.type_parameter_list &&
5150       left_paren === this.left_paren &&
5151       parameter_list === this.parameter_list &&
5152       right_paren === this.right_paren &&
5153       colon === this.colon &&
5154       type === this.type &&
5155       where_clause === this.where_clause)
5156     {
5157       return rewriter(this, parents);
5158     }
5159     else
5160     {
5161       return rewriter(new FunctionDeclarationHeader(
5162         modifiers,
5163         keyword,
5164         name,
5165         type_parameter_list,
5166         left_paren,
5167         parameter_list,
5168         right_paren,
5169         colon,
5170         type,
5171         where_clause), parents);
5172     }
5173   }
5174   static from_json(json, position, source)
5175   {
5176     let modifiers = EditableSyntax.from_json(
5177       json.function_modifiers, position, source);
5178     position += modifiers.width;
5179     let keyword = EditableSyntax.from_json(
5180       json.function_keyword, position, source);
5181     position += keyword.width;
5182     let name = EditableSyntax.from_json(
5183       json.function_name, position, source);
5184     position += name.width;
5185     let type_parameter_list = EditableSyntax.from_json(
5186       json.function_type_parameter_list, position, source);
5187     position += type_parameter_list.width;
5188     let left_paren = EditableSyntax.from_json(
5189       json.function_left_paren, position, source);
5190     position += left_paren.width;
5191     let parameter_list = EditableSyntax.from_json(
5192       json.function_parameter_list, position, source);
5193     position += parameter_list.width;
5194     let right_paren = EditableSyntax.from_json(
5195       json.function_right_paren, position, source);
5196     position += right_paren.width;
5197     let colon = EditableSyntax.from_json(
5198       json.function_colon, position, source);
5199     position += colon.width;
5200     let type = EditableSyntax.from_json(
5201       json.function_type, position, source);
5202     position += type.width;
5203     let where_clause = EditableSyntax.from_json(
5204       json.function_where_clause, position, source);
5205     position += where_clause.width;
5206     return new FunctionDeclarationHeader(
5207         modifiers,
5208         keyword,
5209         name,
5210         type_parameter_list,
5211         left_paren,
5212         parameter_list,
5213         right_paren,
5214         colon,
5215         type,
5216         where_clause);
5217   }
5218   get children_keys()
5219   {
5220     if (FunctionDeclarationHeader._children_keys == null)
5221       FunctionDeclarationHeader._children_keys = [
5222         'modifiers',
5223         'keyword',
5224         'name',
5225         'type_parameter_list',
5226         'left_paren',
5227         'parameter_list',
5228         'right_paren',
5229         'colon',
5230         'type',
5231         'where_clause'];
5232     return FunctionDeclarationHeader._children_keys;
5233   }
5234 }
5235 class WhereClause extends EditableSyntax
5236 {
5237   constructor(
5238     keyword,
5239     constraints)
5240   {
5241     super('where_clause', {
5242       keyword: keyword,
5243       constraints: constraints });
5244   }
5245   get keyword() { return this.children.keyword; }
5246   get constraints() { return this.children.constraints; }
5247   with_keyword(keyword){
5248     return new WhereClause(
5249       keyword,
5250       this.constraints);
5251   }
5252   with_constraints(constraints){
5253     return new WhereClause(
5254       this.keyword,
5255       constraints);
5256   }
5257   rewrite(rewriter, parents)
5258   {
5259     if (parents == undefined)
5260       parents = [];
5261     let new_parents = parents.slice();
5262     new_parents.push(this);
5263     var keyword = this.keyword.rewrite(rewriter, new_parents);
5264     var constraints = this.constraints.rewrite(rewriter, new_parents);
5265     if (
5266       keyword === this.keyword &&
5267       constraints === this.constraints)
5268     {
5269       return rewriter(this, parents);
5270     }
5271     else
5272     {
5273       return rewriter(new WhereClause(
5274         keyword,
5275         constraints), parents);
5276     }
5277   }
5278   static from_json(json, position, source)
5279   {
5280     let keyword = EditableSyntax.from_json(
5281       json.where_clause_keyword, position, source);
5282     position += keyword.width;
5283     let constraints = EditableSyntax.from_json(
5284       json.where_clause_constraints, position, source);
5285     position += constraints.width;
5286     return new WhereClause(
5287         keyword,
5288         constraints);
5289   }
5290   get children_keys()
5291   {
5292     if (WhereClause._children_keys == null)
5293       WhereClause._children_keys = [
5294         'keyword',
5295         'constraints'];
5296     return WhereClause._children_keys;
5297   }
5298 }
5299 class WhereConstraint extends EditableSyntax
5300 {
5301   constructor(
5302     left_type,
5303     operator,
5304     right_type)
5305   {
5306     super('where_constraint', {
5307       left_type: left_type,
5308       operator: operator,
5309       right_type: right_type });
5310   }
5311   get left_type() { return this.children.left_type; }
5312   get operator() { return this.children.operator; }
5313   get right_type() { return this.children.right_type; }
5314   with_left_type(left_type){
5315     return new WhereConstraint(
5316       left_type,
5317       this.operator,
5318       this.right_type);
5319   }
5320   with_operator(operator){
5321     return new WhereConstraint(
5322       this.left_type,
5323       operator,
5324       this.right_type);
5325   }
5326   with_right_type(right_type){
5327     return new WhereConstraint(
5328       this.left_type,
5329       this.operator,
5330       right_type);
5331   }
5332   rewrite(rewriter, parents)
5333   {
5334     if (parents == undefined)
5335       parents = [];
5336     let new_parents = parents.slice();
5337     new_parents.push(this);
5338     var left_type = this.left_type.rewrite(rewriter, new_parents);
5339     var operator = this.operator.rewrite(rewriter, new_parents);
5340     var right_type = this.right_type.rewrite(rewriter, new_parents);
5341     if (
5342       left_type === this.left_type &&
5343       operator === this.operator &&
5344       right_type === this.right_type)
5345     {
5346       return rewriter(this, parents);
5347     }
5348     else
5349     {
5350       return rewriter(new WhereConstraint(
5351         left_type,
5352         operator,
5353         right_type), parents);
5354     }
5355   }
5356   static from_json(json, position, source)
5357   {
5358     let left_type = EditableSyntax.from_json(
5359       json.where_constraint_left_type, position, source);
5360     position += left_type.width;
5361     let operator = EditableSyntax.from_json(
5362       json.where_constraint_operator, position, source);
5363     position += operator.width;
5364     let right_type = EditableSyntax.from_json(
5365       json.where_constraint_right_type, position, source);
5366     position += right_type.width;
5367     return new WhereConstraint(
5368         left_type,
5369         operator,
5370         right_type);
5371   }
5372   get children_keys()
5373   {
5374     if (WhereConstraint._children_keys == null)
5375       WhereConstraint._children_keys = [
5376         'left_type',
5377         'operator',
5378         'right_type'];
5379     return WhereConstraint._children_keys;
5380   }
5381 }
5382 class MethodishDeclaration extends EditableSyntax
5383 {
5384   constructor(
5385     attribute,
5386     function_decl_header,
5387     function_body,
5388     semicolon)
5389   {
5390     super('methodish_declaration', {
5391       attribute: attribute,
5392       function_decl_header: function_decl_header,
5393       function_body: function_body,
5394       semicolon: semicolon });
5395   }
5396   get attribute() { return this.children.attribute; }
5397   get function_decl_header() { return this.children.function_decl_header; }
5398   get function_body() { return this.children.function_body; }
5399   get semicolon() { return this.children.semicolon; }
5400   with_attribute(attribute){
5401     return new MethodishDeclaration(
5402       attribute,
5403       this.function_decl_header,
5404       this.function_body,
5405       this.semicolon);
5406   }
5407   with_function_decl_header(function_decl_header){
5408     return new MethodishDeclaration(
5409       this.attribute,
5410       function_decl_header,
5411       this.function_body,
5412       this.semicolon);
5413   }
5414   with_function_body(function_body){
5415     return new MethodishDeclaration(
5416       this.attribute,
5417       this.function_decl_header,
5418       function_body,
5419       this.semicolon);
5420   }
5421   with_semicolon(semicolon){
5422     return new MethodishDeclaration(
5423       this.attribute,
5424       this.function_decl_header,
5425       this.function_body,
5426       semicolon);
5427   }
5428   rewrite(rewriter, parents)
5429   {
5430     if (parents == undefined)
5431       parents = [];
5432     let new_parents = parents.slice();
5433     new_parents.push(this);
5434     var attribute = this.attribute.rewrite(rewriter, new_parents);
5435     var function_decl_header = this.function_decl_header.rewrite(rewriter, new_parents);
5436     var function_body = this.function_body.rewrite(rewriter, new_parents);
5437     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
5438     if (
5439       attribute === this.attribute &&
5440       function_decl_header === this.function_decl_header &&
5441       function_body === this.function_body &&
5442       semicolon === this.semicolon)
5443     {
5444       return rewriter(this, parents);
5445     }
5446     else
5447     {
5448       return rewriter(new MethodishDeclaration(
5449         attribute,
5450         function_decl_header,
5451         function_body,
5452         semicolon), parents);
5453     }
5454   }
5455   static from_json(json, position, source)
5456   {
5457     let attribute = EditableSyntax.from_json(
5458       json.methodish_attribute, position, source);
5459     position += attribute.width;
5460     let function_decl_header = EditableSyntax.from_json(
5461       json.methodish_function_decl_header, position, source);
5462     position += function_decl_header.width;
5463     let function_body = EditableSyntax.from_json(
5464       json.methodish_function_body, position, source);
5465     position += function_body.width;
5466     let semicolon = EditableSyntax.from_json(
5467       json.methodish_semicolon, position, source);
5468     position += semicolon.width;
5469     return new MethodishDeclaration(
5470         attribute,
5471         function_decl_header,
5472         function_body,
5473         semicolon);
5474   }
5475   get children_keys()
5476   {
5477     if (MethodishDeclaration._children_keys == null)
5478       MethodishDeclaration._children_keys = [
5479         'attribute',
5480         'function_decl_header',
5481         'function_body',
5482         'semicolon'];
5483     return MethodishDeclaration._children_keys;
5484   }
5485 }
5486 class MethodishTraitResolution extends EditableSyntax
5487 {
5488   constructor(
5489     attribute,
5490     function_decl_header,
5491     equal,
5492     name,
5493     semicolon)
5494   {
5495     super('methodish_trait_resolution', {
5496       attribute: attribute,
5497       function_decl_header: function_decl_header,
5498       equal: equal,
5499       name: name,
5500       semicolon: semicolon });
5501   }
5502   get attribute() { return this.children.attribute; }
5503   get function_decl_header() { return this.children.function_decl_header; }
5504   get equal() { return this.children.equal; }
5505   get name() { return this.children.name; }
5506   get semicolon() { return this.children.semicolon; }
5507   with_attribute(attribute){
5508     return new MethodishTraitResolution(
5509       attribute,
5510       this.function_decl_header,
5511       this.equal,
5512       this.name,
5513       this.semicolon);
5514   }
5515   with_function_decl_header(function_decl_header){
5516     return new MethodishTraitResolution(
5517       this.attribute,
5518       function_decl_header,
5519       this.equal,
5520       this.name,
5521       this.semicolon);
5522   }
5523   with_equal(equal){
5524     return new MethodishTraitResolution(
5525       this.attribute,
5526       this.function_decl_header,
5527       equal,
5528       this.name,
5529       this.semicolon);
5530   }
5531   with_name(name){
5532     return new MethodishTraitResolution(
5533       this.attribute,
5534       this.function_decl_header,
5535       this.equal,
5536       name,
5537       this.semicolon);
5538   }
5539   with_semicolon(semicolon){
5540     return new MethodishTraitResolution(
5541       this.attribute,
5542       this.function_decl_header,
5543       this.equal,
5544       this.name,
5545       semicolon);
5546   }
5547   rewrite(rewriter, parents)
5548   {
5549     if (parents == undefined)
5550       parents = [];
5551     let new_parents = parents.slice();
5552     new_parents.push(this);
5553     var attribute = this.attribute.rewrite(rewriter, new_parents);
5554     var function_decl_header = this.function_decl_header.rewrite(rewriter, new_parents);
5555     var equal = this.equal.rewrite(rewriter, new_parents);
5556     var name = this.name.rewrite(rewriter, new_parents);
5557     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
5558     if (
5559       attribute === this.attribute &&
5560       function_decl_header === this.function_decl_header &&
5561       equal === this.equal &&
5562       name === this.name &&
5563       semicolon === this.semicolon)
5564     {
5565       return rewriter(this, parents);
5566     }
5567     else
5568     {
5569       return rewriter(new MethodishTraitResolution(
5570         attribute,
5571         function_decl_header,
5572         equal,
5573         name,
5574         semicolon), parents);
5575     }
5576   }
5577   static from_json(json, position, source)
5578   {
5579     let attribute = EditableSyntax.from_json(
5580       json.methodish_trait_attribute, position, source);
5581     position += attribute.width;
5582     let function_decl_header = EditableSyntax.from_json(
5583       json.methodish_trait_function_decl_header, position, source);
5584     position += function_decl_header.width;
5585     let equal = EditableSyntax.from_json(
5586       json.methodish_trait_equal, position, source);
5587     position += equal.width;
5588     let name = EditableSyntax.from_json(
5589       json.methodish_trait_name, position, source);
5590     position += name.width;
5591     let semicolon = EditableSyntax.from_json(
5592       json.methodish_trait_semicolon, position, source);
5593     position += semicolon.width;
5594     return new MethodishTraitResolution(
5595         attribute,
5596         function_decl_header,
5597         equal,
5598         name,
5599         semicolon);
5600   }
5601   get children_keys()
5602   {
5603     if (MethodishTraitResolution._children_keys == null)
5604       MethodishTraitResolution._children_keys = [
5605         'attribute',
5606         'function_decl_header',
5607         'equal',
5608         'name',
5609         'semicolon'];
5610     return MethodishTraitResolution._children_keys;
5611   }
5612 }
5613 class ClassishDeclaration extends EditableSyntax
5614 {
5615   constructor(
5616     attribute,
5617     modifiers,
5618     keyword,
5619     name,
5620     type_parameters,
5621     extends_keyword,
5622     extends_list,
5623     implements_keyword,
5624     implements_list,
5625     body)
5626   {
5627     super('classish_declaration', {
5628       attribute: attribute,
5629       modifiers: modifiers,
5630       keyword: keyword,
5631       name: name,
5632       type_parameters: type_parameters,
5633       extends_keyword: extends_keyword,
5634       extends_list: extends_list,
5635       implements_keyword: implements_keyword,
5636       implements_list: implements_list,
5637       body: body });
5638   }
5639   get attribute() { return this.children.attribute; }
5640   get modifiers() { return this.children.modifiers; }
5641   get keyword() { return this.children.keyword; }
5642   get name() { return this.children.name; }
5643   get type_parameters() { return this.children.type_parameters; }
5644   get extends_keyword() { return this.children.extends_keyword; }
5645   get extends_list() { return this.children.extends_list; }
5646   get implements_keyword() { return this.children.implements_keyword; }
5647   get implements_list() { return this.children.implements_list; }
5648   get body() { return this.children.body; }
5649   with_attribute(attribute){
5650     return new ClassishDeclaration(
5651       attribute,
5652       this.modifiers,
5653       this.keyword,
5654       this.name,
5655       this.type_parameters,
5656       this.extends_keyword,
5657       this.extends_list,
5658       this.implements_keyword,
5659       this.implements_list,
5660       this.body);
5661   }
5662   with_modifiers(modifiers){
5663     return new ClassishDeclaration(
5664       this.attribute,
5665       modifiers,
5666       this.keyword,
5667       this.name,
5668       this.type_parameters,
5669       this.extends_keyword,
5670       this.extends_list,
5671       this.implements_keyword,
5672       this.implements_list,
5673       this.body);
5674   }
5675   with_keyword(keyword){
5676     return new ClassishDeclaration(
5677       this.attribute,
5678       this.modifiers,
5679       keyword,
5680       this.name,
5681       this.type_parameters,
5682       this.extends_keyword,
5683       this.extends_list,
5684       this.implements_keyword,
5685       this.implements_list,
5686       this.body);
5687   }
5688   with_name(name){
5689     return new ClassishDeclaration(
5690       this.attribute,
5691       this.modifiers,
5692       this.keyword,
5693       name,
5694       this.type_parameters,
5695       this.extends_keyword,
5696       this.extends_list,
5697       this.implements_keyword,
5698       this.implements_list,
5699       this.body);
5700   }
5701   with_type_parameters(type_parameters){
5702     return new ClassishDeclaration(
5703       this.attribute,
5704       this.modifiers,
5705       this.keyword,
5706       this.name,
5707       type_parameters,
5708       this.extends_keyword,
5709       this.extends_list,
5710       this.implements_keyword,
5711       this.implements_list,
5712       this.body);
5713   }
5714   with_extends_keyword(extends_keyword){
5715     return new ClassishDeclaration(
5716       this.attribute,
5717       this.modifiers,
5718       this.keyword,
5719       this.name,
5720       this.type_parameters,
5721       extends_keyword,
5722       this.extends_list,
5723       this.implements_keyword,
5724       this.implements_list,
5725       this.body);
5726   }
5727   with_extends_list(extends_list){
5728     return new ClassishDeclaration(
5729       this.attribute,
5730       this.modifiers,
5731       this.keyword,
5732       this.name,
5733       this.type_parameters,
5734       this.extends_keyword,
5735       extends_list,
5736       this.implements_keyword,
5737       this.implements_list,
5738       this.body);
5739   }
5740   with_implements_keyword(implements_keyword){
5741     return new ClassishDeclaration(
5742       this.attribute,
5743       this.modifiers,
5744       this.keyword,
5745       this.name,
5746       this.type_parameters,
5747       this.extends_keyword,
5748       this.extends_list,
5749       implements_keyword,
5750       this.implements_list,
5751       this.body);
5752   }
5753   with_implements_list(implements_list){
5754     return new ClassishDeclaration(
5755       this.attribute,
5756       this.modifiers,
5757       this.keyword,
5758       this.name,
5759       this.type_parameters,
5760       this.extends_keyword,
5761       this.extends_list,
5762       this.implements_keyword,
5763       implements_list,
5764       this.body);
5765   }
5766   with_body(body){
5767     return new ClassishDeclaration(
5768       this.attribute,
5769       this.modifiers,
5770       this.keyword,
5771       this.name,
5772       this.type_parameters,
5773       this.extends_keyword,
5774       this.extends_list,
5775       this.implements_keyword,
5776       this.implements_list,
5777       body);
5778   }
5779   rewrite(rewriter, parents)
5780   {
5781     if (parents == undefined)
5782       parents = [];
5783     let new_parents = parents.slice();
5784     new_parents.push(this);
5785     var attribute = this.attribute.rewrite(rewriter, new_parents);
5786     var modifiers = this.modifiers.rewrite(rewriter, new_parents);
5787     var keyword = this.keyword.rewrite(rewriter, new_parents);
5788     var name = this.name.rewrite(rewriter, new_parents);
5789     var type_parameters = this.type_parameters.rewrite(rewriter, new_parents);
5790     var extends_keyword = this.extends_keyword.rewrite(rewriter, new_parents);
5791     var extends_list = this.extends_list.rewrite(rewriter, new_parents);
5792     var implements_keyword = this.implements_keyword.rewrite(rewriter, new_parents);
5793     var implements_list = this.implements_list.rewrite(rewriter, new_parents);
5794     var body = this.body.rewrite(rewriter, new_parents);
5795     if (
5796       attribute === this.attribute &&
5797       modifiers === this.modifiers &&
5798       keyword === this.keyword &&
5799       name === this.name &&
5800       type_parameters === this.type_parameters &&
5801       extends_keyword === this.extends_keyword &&
5802       extends_list === this.extends_list &&
5803       implements_keyword === this.implements_keyword &&
5804       implements_list === this.implements_list &&
5805       body === this.body)
5806     {
5807       return rewriter(this, parents);
5808     }
5809     else
5810     {
5811       return rewriter(new ClassishDeclaration(
5812         attribute,
5813         modifiers,
5814         keyword,
5815         name,
5816         type_parameters,
5817         extends_keyword,
5818         extends_list,
5819         implements_keyword,
5820         implements_list,
5821         body), parents);
5822     }
5823   }
5824   static from_json(json, position, source)
5825   {
5826     let attribute = EditableSyntax.from_json(
5827       json.classish_attribute, position, source);
5828     position += attribute.width;
5829     let modifiers = EditableSyntax.from_json(
5830       json.classish_modifiers, position, source);
5831     position += modifiers.width;
5832     let keyword = EditableSyntax.from_json(
5833       json.classish_keyword, position, source);
5834     position += keyword.width;
5835     let name = EditableSyntax.from_json(
5836       json.classish_name, position, source);
5837     position += name.width;
5838     let type_parameters = EditableSyntax.from_json(
5839       json.classish_type_parameters, position, source);
5840     position += type_parameters.width;
5841     let extends_keyword = EditableSyntax.from_json(
5842       json.classish_extends_keyword, position, source);
5843     position += extends_keyword.width;
5844     let extends_list = EditableSyntax.from_json(
5845       json.classish_extends_list, position, source);
5846     position += extends_list.width;
5847     let implements_keyword = EditableSyntax.from_json(
5848       json.classish_implements_keyword, position, source);
5849     position += implements_keyword.width;
5850     let implements_list = EditableSyntax.from_json(
5851       json.classish_implements_list, position, source);
5852     position += implements_list.width;
5853     let body = EditableSyntax.from_json(
5854       json.classish_body, position, source);
5855     position += body.width;
5856     return new ClassishDeclaration(
5857         attribute,
5858         modifiers,
5859         keyword,
5860         name,
5861         type_parameters,
5862         extends_keyword,
5863         extends_list,
5864         implements_keyword,
5865         implements_list,
5866         body);
5867   }
5868   get children_keys()
5869   {
5870     if (ClassishDeclaration._children_keys == null)
5871       ClassishDeclaration._children_keys = [
5872         'attribute',
5873         'modifiers',
5874         'keyword',
5875         'name',
5876         'type_parameters',
5877         'extends_keyword',
5878         'extends_list',
5879         'implements_keyword',
5880         'implements_list',
5881         'body'];
5882     return ClassishDeclaration._children_keys;
5883   }
5884 }
5885 class ClassishBody extends EditableSyntax
5886 {
5887   constructor(
5888     left_brace,
5889     elements,
5890     right_brace)
5891   {
5892     super('classish_body', {
5893       left_brace: left_brace,
5894       elements: elements,
5895       right_brace: right_brace });
5896   }
5897   get left_brace() { return this.children.left_brace; }
5898   get elements() { return this.children.elements; }
5899   get right_brace() { return this.children.right_brace; }
5900   with_left_brace(left_brace){
5901     return new ClassishBody(
5902       left_brace,
5903       this.elements,
5904       this.right_brace);
5905   }
5906   with_elements(elements){
5907     return new ClassishBody(
5908       this.left_brace,
5909       elements,
5910       this.right_brace);
5911   }
5912   with_right_brace(right_brace){
5913     return new ClassishBody(
5914       this.left_brace,
5915       this.elements,
5916       right_brace);
5917   }
5918   rewrite(rewriter, parents)
5919   {
5920     if (parents == undefined)
5921       parents = [];
5922     let new_parents = parents.slice();
5923     new_parents.push(this);
5924     var left_brace = this.left_brace.rewrite(rewriter, new_parents);
5925     var elements = this.elements.rewrite(rewriter, new_parents);
5926     var right_brace = this.right_brace.rewrite(rewriter, new_parents);
5927     if (
5928       left_brace === this.left_brace &&
5929       elements === this.elements &&
5930       right_brace === this.right_brace)
5931     {
5932       return rewriter(this, parents);
5933     }
5934     else
5935     {
5936       return rewriter(new ClassishBody(
5937         left_brace,
5938         elements,
5939         right_brace), parents);
5940     }
5941   }
5942   static from_json(json, position, source)
5943   {
5944     let left_brace = EditableSyntax.from_json(
5945       json.classish_body_left_brace, position, source);
5946     position += left_brace.width;
5947     let elements = EditableSyntax.from_json(
5948       json.classish_body_elements, position, source);
5949     position += elements.width;
5950     let right_brace = EditableSyntax.from_json(
5951       json.classish_body_right_brace, position, source);
5952     position += right_brace.width;
5953     return new ClassishBody(
5954         left_brace,
5955         elements,
5956         right_brace);
5957   }
5958   get children_keys()
5959   {
5960     if (ClassishBody._children_keys == null)
5961       ClassishBody._children_keys = [
5962         'left_brace',
5963         'elements',
5964         'right_brace'];
5965     return ClassishBody._children_keys;
5966   }
5967 }
5968 class TraitUsePrecedenceItem extends EditableSyntax
5969 {
5970   constructor(
5971     name,
5972     keyword,
5973     removed_names)
5974   {
5975     super('trait_use_precedence_item', {
5976       name: name,
5977       keyword: keyword,
5978       removed_names: removed_names });
5979   }
5980   get name() { return this.children.name; }
5981   get keyword() { return this.children.keyword; }
5982   get removed_names() { return this.children.removed_names; }
5983   with_name(name){
5984     return new TraitUsePrecedenceItem(
5985       name,
5986       this.keyword,
5987       this.removed_names);
5988   }
5989   with_keyword(keyword){
5990     return new TraitUsePrecedenceItem(
5991       this.name,
5992       keyword,
5993       this.removed_names);
5994   }
5995   with_removed_names(removed_names){
5996     return new TraitUsePrecedenceItem(
5997       this.name,
5998       this.keyword,
5999       removed_names);
6000   }
6001   rewrite(rewriter, parents)
6002   {
6003     if (parents == undefined)
6004       parents = [];
6005     let new_parents = parents.slice();
6006     new_parents.push(this);
6007     var name = this.name.rewrite(rewriter, new_parents);
6008     var keyword = this.keyword.rewrite(rewriter, new_parents);
6009     var removed_names = this.removed_names.rewrite(rewriter, new_parents);
6010     if (
6011       name === this.name &&
6012       keyword === this.keyword &&
6013       removed_names === this.removed_names)
6014     {
6015       return rewriter(this, parents);
6016     }
6017     else
6018     {
6019       return rewriter(new TraitUsePrecedenceItem(
6020         name,
6021         keyword,
6022         removed_names), parents);
6023     }
6024   }
6025   static from_json(json, position, source)
6026   {
6027     let name = EditableSyntax.from_json(
6028       json.trait_use_precedence_item_name, position, source);
6029     position += name.width;
6030     let keyword = EditableSyntax.from_json(
6031       json.trait_use_precedence_item_keyword, position, source);
6032     position += keyword.width;
6033     let removed_names = EditableSyntax.from_json(
6034       json.trait_use_precedence_item_removed_names, position, source);
6035     position += removed_names.width;
6036     return new TraitUsePrecedenceItem(
6037         name,
6038         keyword,
6039         removed_names);
6040   }
6041   get children_keys()
6042   {
6043     if (TraitUsePrecedenceItem._children_keys == null)
6044       TraitUsePrecedenceItem._children_keys = [
6045         'name',
6046         'keyword',
6047         'removed_names'];
6048     return TraitUsePrecedenceItem._children_keys;
6049   }
6050 }
6051 class TraitUseAliasItem extends EditableSyntax
6052 {
6053   constructor(
6054     aliasing_name,
6055     keyword,
6056     modifiers,
6057     aliased_name)
6058   {
6059     super('trait_use_alias_item', {
6060       aliasing_name: aliasing_name,
6061       keyword: keyword,
6062       modifiers: modifiers,
6063       aliased_name: aliased_name });
6064   }
6065   get aliasing_name() { return this.children.aliasing_name; }
6066   get keyword() { return this.children.keyword; }
6067   get modifiers() { return this.children.modifiers; }
6068   get aliased_name() { return this.children.aliased_name; }
6069   with_aliasing_name(aliasing_name){
6070     return new TraitUseAliasItem(
6071       aliasing_name,
6072       this.keyword,
6073       this.modifiers,
6074       this.aliased_name);
6075   }
6076   with_keyword(keyword){
6077     return new TraitUseAliasItem(
6078       this.aliasing_name,
6079       keyword,
6080       this.modifiers,
6081       this.aliased_name);
6082   }
6083   with_modifiers(modifiers){
6084     return new TraitUseAliasItem(
6085       this.aliasing_name,
6086       this.keyword,
6087       modifiers,
6088       this.aliased_name);
6089   }
6090   with_aliased_name(aliased_name){
6091     return new TraitUseAliasItem(
6092       this.aliasing_name,
6093       this.keyword,
6094       this.modifiers,
6095       aliased_name);
6096   }
6097   rewrite(rewriter, parents)
6098   {
6099     if (parents == undefined)
6100       parents = [];
6101     let new_parents = parents.slice();
6102     new_parents.push(this);
6103     var aliasing_name = this.aliasing_name.rewrite(rewriter, new_parents);
6104     var keyword = this.keyword.rewrite(rewriter, new_parents);
6105     var modifiers = this.modifiers.rewrite(rewriter, new_parents);
6106     var aliased_name = this.aliased_name.rewrite(rewriter, new_parents);
6107     if (
6108       aliasing_name === this.aliasing_name &&
6109       keyword === this.keyword &&
6110       modifiers === this.modifiers &&
6111       aliased_name === this.aliased_name)
6112     {
6113       return rewriter(this, parents);
6114     }
6115     else
6116     {
6117       return rewriter(new TraitUseAliasItem(
6118         aliasing_name,
6119         keyword,
6120         modifiers,
6121         aliased_name), parents);
6122     }
6123   }
6124   static from_json(json, position, source)
6125   {
6126     let aliasing_name = EditableSyntax.from_json(
6127       json.trait_use_alias_item_aliasing_name, position, source);
6128     position += aliasing_name.width;
6129     let keyword = EditableSyntax.from_json(
6130       json.trait_use_alias_item_keyword, position, source);
6131     position += keyword.width;
6132     let modifiers = EditableSyntax.from_json(
6133       json.trait_use_alias_item_modifiers, position, source);
6134     position += modifiers.width;
6135     let aliased_name = EditableSyntax.from_json(
6136       json.trait_use_alias_item_aliased_name, position, source);
6137     position += aliased_name.width;
6138     return new TraitUseAliasItem(
6139         aliasing_name,
6140         keyword,
6141         modifiers,
6142         aliased_name);
6143   }
6144   get children_keys()
6145   {
6146     if (TraitUseAliasItem._children_keys == null)
6147       TraitUseAliasItem._children_keys = [
6148         'aliasing_name',
6149         'keyword',
6150         'modifiers',
6151         'aliased_name'];
6152     return TraitUseAliasItem._children_keys;
6153   }
6154 }
6155 class TraitUseConflictResolution extends EditableSyntax
6156 {
6157   constructor(
6158     keyword,
6159     names,
6160     left_brace,
6161     clauses,
6162     right_brace)
6163   {
6164     super('trait_use_conflict_resolution', {
6165       keyword: keyword,
6166       names: names,
6167       left_brace: left_brace,
6168       clauses: clauses,
6169       right_brace: right_brace });
6170   }
6171   get keyword() { return this.children.keyword; }
6172   get names() { return this.children.names; }
6173   get left_brace() { return this.children.left_brace; }
6174   get clauses() { return this.children.clauses; }
6175   get right_brace() { return this.children.right_brace; }
6176   with_keyword(keyword){
6177     return new TraitUseConflictResolution(
6178       keyword,
6179       this.names,
6180       this.left_brace,
6181       this.clauses,
6182       this.right_brace);
6183   }
6184   with_names(names){
6185     return new TraitUseConflictResolution(
6186       this.keyword,
6187       names,
6188       this.left_brace,
6189       this.clauses,
6190       this.right_brace);
6191   }
6192   with_left_brace(left_brace){
6193     return new TraitUseConflictResolution(
6194       this.keyword,
6195       this.names,
6196       left_brace,
6197       this.clauses,
6198       this.right_brace);
6199   }
6200   with_clauses(clauses){
6201     return new TraitUseConflictResolution(
6202       this.keyword,
6203       this.names,
6204       this.left_brace,
6205       clauses,
6206       this.right_brace);
6207   }
6208   with_right_brace(right_brace){
6209     return new TraitUseConflictResolution(
6210       this.keyword,
6211       this.names,
6212       this.left_brace,
6213       this.clauses,
6214       right_brace);
6215   }
6216   rewrite(rewriter, parents)
6217   {
6218     if (parents == undefined)
6219       parents = [];
6220     let new_parents = parents.slice();
6221     new_parents.push(this);
6222     var keyword = this.keyword.rewrite(rewriter, new_parents);
6223     var names = this.names.rewrite(rewriter, new_parents);
6224     var left_brace = this.left_brace.rewrite(rewriter, new_parents);
6225     var clauses = this.clauses.rewrite(rewriter, new_parents);
6226     var right_brace = this.right_brace.rewrite(rewriter, new_parents);
6227     if (
6228       keyword === this.keyword &&
6229       names === this.names &&
6230       left_brace === this.left_brace &&
6231       clauses === this.clauses &&
6232       right_brace === this.right_brace)
6233     {
6234       return rewriter(this, parents);
6235     }
6236     else
6237     {
6238       return rewriter(new TraitUseConflictResolution(
6239         keyword,
6240         names,
6241         left_brace,
6242         clauses,
6243         right_brace), parents);
6244     }
6245   }
6246   static from_json(json, position, source)
6247   {
6248     let keyword = EditableSyntax.from_json(
6249       json.trait_use_conflict_resolution_keyword, position, source);
6250     position += keyword.width;
6251     let names = EditableSyntax.from_json(
6252       json.trait_use_conflict_resolution_names, position, source);
6253     position += names.width;
6254     let left_brace = EditableSyntax.from_json(
6255       json.trait_use_conflict_resolution_left_brace, position, source);
6256     position += left_brace.width;
6257     let clauses = EditableSyntax.from_json(
6258       json.trait_use_conflict_resolution_clauses, position, source);
6259     position += clauses.width;
6260     let right_brace = EditableSyntax.from_json(
6261       json.trait_use_conflict_resolution_right_brace, position, source);
6262     position += right_brace.width;
6263     return new TraitUseConflictResolution(
6264         keyword,
6265         names,
6266         left_brace,
6267         clauses,
6268         right_brace);
6269   }
6270   get children_keys()
6271   {
6272     if (TraitUseConflictResolution._children_keys == null)
6273       TraitUseConflictResolution._children_keys = [
6274         'keyword',
6275         'names',
6276         'left_brace',
6277         'clauses',
6278         'right_brace'];
6279     return TraitUseConflictResolution._children_keys;
6280   }
6281 }
6282 class TraitUse extends EditableSyntax
6283 {
6284   constructor(
6285     keyword,
6286     names,
6287     semicolon)
6288   {
6289     super('trait_use', {
6290       keyword: keyword,
6291       names: names,
6292       semicolon: semicolon });
6293   }
6294   get keyword() { return this.children.keyword; }
6295   get names() { return this.children.names; }
6296   get semicolon() { return this.children.semicolon; }
6297   with_keyword(keyword){
6298     return new TraitUse(
6299       keyword,
6300       this.names,
6301       this.semicolon);
6302   }
6303   with_names(names){
6304     return new TraitUse(
6305       this.keyword,
6306       names,
6307       this.semicolon);
6308   }
6309   with_semicolon(semicolon){
6310     return new TraitUse(
6311       this.keyword,
6312       this.names,
6313       semicolon);
6314   }
6315   rewrite(rewriter, parents)
6316   {
6317     if (parents == undefined)
6318       parents = [];
6319     let new_parents = parents.slice();
6320     new_parents.push(this);
6321     var keyword = this.keyword.rewrite(rewriter, new_parents);
6322     var names = this.names.rewrite(rewriter, new_parents);
6323     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
6324     if (
6325       keyword === this.keyword &&
6326       names === this.names &&
6327       semicolon === this.semicolon)
6328     {
6329       return rewriter(this, parents);
6330     }
6331     else
6332     {
6333       return rewriter(new TraitUse(
6334         keyword,
6335         names,
6336         semicolon), parents);
6337     }
6338   }
6339   static from_json(json, position, source)
6340   {
6341     let keyword = EditableSyntax.from_json(
6342       json.trait_use_keyword, position, source);
6343     position += keyword.width;
6344     let names = EditableSyntax.from_json(
6345       json.trait_use_names, position, source);
6346     position += names.width;
6347     let semicolon = EditableSyntax.from_json(
6348       json.trait_use_semicolon, position, source);
6349     position += semicolon.width;
6350     return new TraitUse(
6351         keyword,
6352         names,
6353         semicolon);
6354   }
6355   get children_keys()
6356   {
6357     if (TraitUse._children_keys == null)
6358       TraitUse._children_keys = [
6359         'keyword',
6360         'names',
6361         'semicolon'];
6362     return TraitUse._children_keys;
6363   }
6364 }
6365 class RequireClause extends EditableSyntax
6366 {
6367   constructor(
6368     keyword,
6369     kind,
6370     name,
6371     semicolon)
6372   {
6373     super('require_clause', {
6374       keyword: keyword,
6375       kind: kind,
6376       name: name,
6377       semicolon: semicolon });
6378   }
6379   get keyword() { return this.children.keyword; }
6380   get kind() { return this.children.kind; }
6381   get name() { return this.children.name; }
6382   get semicolon() { return this.children.semicolon; }
6383   with_keyword(keyword){
6384     return new RequireClause(
6385       keyword,
6386       this.kind,
6387       this.name,
6388       this.semicolon);
6389   }
6390   with_kind(kind){
6391     return new RequireClause(
6392       this.keyword,
6393       kind,
6394       this.name,
6395       this.semicolon);
6396   }
6397   with_name(name){
6398     return new RequireClause(
6399       this.keyword,
6400       this.kind,
6401       name,
6402       this.semicolon);
6403   }
6404   with_semicolon(semicolon){
6405     return new RequireClause(
6406       this.keyword,
6407       this.kind,
6408       this.name,
6409       semicolon);
6410   }
6411   rewrite(rewriter, parents)
6412   {
6413     if (parents == undefined)
6414       parents = [];
6415     let new_parents = parents.slice();
6416     new_parents.push(this);
6417     var keyword = this.keyword.rewrite(rewriter, new_parents);
6418     var kind = this.kind.rewrite(rewriter, new_parents);
6419     var name = this.name.rewrite(rewriter, new_parents);
6420     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
6421     if (
6422       keyword === this.keyword &&
6423       kind === this.kind &&
6424       name === this.name &&
6425       semicolon === this.semicolon)
6426     {
6427       return rewriter(this, parents);
6428     }
6429     else
6430     {
6431       return rewriter(new RequireClause(
6432         keyword,
6433         kind,
6434         name,
6435         semicolon), parents);
6436     }
6437   }
6438   static from_json(json, position, source)
6439   {
6440     let keyword = EditableSyntax.from_json(
6441       json.require_keyword, position, source);
6442     position += keyword.width;
6443     let kind = EditableSyntax.from_json(
6444       json.require_kind, position, source);
6445     position += kind.width;
6446     let name = EditableSyntax.from_json(
6447       json.require_name, position, source);
6448     position += name.width;
6449     let semicolon = EditableSyntax.from_json(
6450       json.require_semicolon, position, source);
6451     position += semicolon.width;
6452     return new RequireClause(
6453         keyword,
6454         kind,
6455         name,
6456         semicolon);
6457   }
6458   get children_keys()
6459   {
6460     if (RequireClause._children_keys == null)
6461       RequireClause._children_keys = [
6462         'keyword',
6463         'kind',
6464         'name',
6465         'semicolon'];
6466     return RequireClause._children_keys;
6467   }
6468 }
6469 class ConstDeclaration extends EditableSyntax
6470 {
6471   constructor(
6472     visibility,
6473     abstract,
6474     keyword,
6475     type_specifier,
6476     declarators,
6477     semicolon)
6478   {
6479     super('const_declaration', {
6480       visibility: visibility,
6481       abstract: abstract,
6482       keyword: keyword,
6483       type_specifier: type_specifier,
6484       declarators: declarators,
6485       semicolon: semicolon });
6486   }
6487   get visibility() { return this.children.visibility; }
6488   get abstract() { return this.children.abstract; }
6489   get keyword() { return this.children.keyword; }
6490   get type_specifier() { return this.children.type_specifier; }
6491   get declarators() { return this.children.declarators; }
6492   get semicolon() { return this.children.semicolon; }
6493   with_visibility(visibility){
6494     return new ConstDeclaration(
6495       visibility,
6496       this.abstract,
6497       this.keyword,
6498       this.type_specifier,
6499       this.declarators,
6500       this.semicolon);
6501   }
6502   with_abstract(abstract){
6503     return new ConstDeclaration(
6504       this.visibility,
6505       abstract,
6506       this.keyword,
6507       this.type_specifier,
6508       this.declarators,
6509       this.semicolon);
6510   }
6511   with_keyword(keyword){
6512     return new ConstDeclaration(
6513       this.visibility,
6514       this.abstract,
6515       keyword,
6516       this.type_specifier,
6517       this.declarators,
6518       this.semicolon);
6519   }
6520   with_type_specifier(type_specifier){
6521     return new ConstDeclaration(
6522       this.visibility,
6523       this.abstract,
6524       this.keyword,
6525       type_specifier,
6526       this.declarators,
6527       this.semicolon);
6528   }
6529   with_declarators(declarators){
6530     return new ConstDeclaration(
6531       this.visibility,
6532       this.abstract,
6533       this.keyword,
6534       this.type_specifier,
6535       declarators,
6536       this.semicolon);
6537   }
6538   with_semicolon(semicolon){
6539     return new ConstDeclaration(
6540       this.visibility,
6541       this.abstract,
6542       this.keyword,
6543       this.type_specifier,
6544       this.declarators,
6545       semicolon);
6546   }
6547   rewrite(rewriter, parents)
6548   {
6549     if (parents == undefined)
6550       parents = [];
6551     let new_parents = parents.slice();
6552     new_parents.push(this);
6553     var visibility = this.visibility.rewrite(rewriter, new_parents);
6554     var abstract = this.abstract.rewrite(rewriter, new_parents);
6555     var keyword = this.keyword.rewrite(rewriter, new_parents);
6556     var type_specifier = this.type_specifier.rewrite(rewriter, new_parents);
6557     var declarators = this.declarators.rewrite(rewriter, new_parents);
6558     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
6559     if (
6560       visibility === this.visibility &&
6561       abstract === this.abstract &&
6562       keyword === this.keyword &&
6563       type_specifier === this.type_specifier &&
6564       declarators === this.declarators &&
6565       semicolon === this.semicolon)
6566     {
6567       return rewriter(this, parents);
6568     }
6569     else
6570     {
6571       return rewriter(new ConstDeclaration(
6572         visibility,
6573         abstract,
6574         keyword,
6575         type_specifier,
6576         declarators,
6577         semicolon), parents);
6578     }
6579   }
6580   static from_json(json, position, source)
6581   {
6582     let visibility = EditableSyntax.from_json(
6583       json.const_visibility, position, source);
6584     position += visibility.width;
6585     let abstract = EditableSyntax.from_json(
6586       json.const_abstract, position, source);
6587     position += abstract.width;
6588     let keyword = EditableSyntax.from_json(
6589       json.const_keyword, position, source);
6590     position += keyword.width;
6591     let type_specifier = EditableSyntax.from_json(
6592       json.const_type_specifier, position, source);
6593     position += type_specifier.width;
6594     let declarators = EditableSyntax.from_json(
6595       json.const_declarators, position, source);
6596     position += declarators.width;
6597     let semicolon = EditableSyntax.from_json(
6598       json.const_semicolon, position, source);
6599     position += semicolon.width;
6600     return new ConstDeclaration(
6601         visibility,
6602         abstract,
6603         keyword,
6604         type_specifier,
6605         declarators,
6606         semicolon);
6607   }
6608   get children_keys()
6609   {
6610     if (ConstDeclaration._children_keys == null)
6611       ConstDeclaration._children_keys = [
6612         'visibility',
6613         'abstract',
6614         'keyword',
6615         'type_specifier',
6616         'declarators',
6617         'semicolon'];
6618     return ConstDeclaration._children_keys;
6619   }
6620 }
6621 class ConstantDeclarator extends EditableSyntax
6622 {
6623   constructor(
6624     name,
6625     initializer)
6626   {
6627     super('constant_declarator', {
6628       name: name,
6629       initializer: initializer });
6630   }
6631   get name() { return this.children.name; }
6632   get initializer() { return this.children.initializer; }
6633   with_name(name){
6634     return new ConstantDeclarator(
6635       name,
6636       this.initializer);
6637   }
6638   with_initializer(initializer){
6639     return new ConstantDeclarator(
6640       this.name,
6641       initializer);
6642   }
6643   rewrite(rewriter, parents)
6644   {
6645     if (parents == undefined)
6646       parents = [];
6647     let new_parents = parents.slice();
6648     new_parents.push(this);
6649     var name = this.name.rewrite(rewriter, new_parents);
6650     var initializer = this.initializer.rewrite(rewriter, new_parents);
6651     if (
6652       name === this.name &&
6653       initializer === this.initializer)
6654     {
6655       return rewriter(this, parents);
6656     }
6657     else
6658     {
6659       return rewriter(new ConstantDeclarator(
6660         name,
6661         initializer), parents);
6662     }
6663   }
6664   static from_json(json, position, source)
6665   {
6666     let name = EditableSyntax.from_json(
6667       json.constant_declarator_name, position, source);
6668     position += name.width;
6669     let initializer = EditableSyntax.from_json(
6670       json.constant_declarator_initializer, position, source);
6671     position += initializer.width;
6672     return new ConstantDeclarator(
6673         name,
6674         initializer);
6675   }
6676   get children_keys()
6677   {
6678     if (ConstantDeclarator._children_keys == null)
6679       ConstantDeclarator._children_keys = [
6680         'name',
6681         'initializer'];
6682     return ConstantDeclarator._children_keys;
6683   }
6684 }
6685 class TypeConstDeclaration extends EditableSyntax
6686 {
6687   constructor(
6688     attribute_spec,
6689     abstract,
6690     keyword,
6691     type_keyword,
6692     name,
6693     type_parameters,
6694     type_constraint,
6695     equal,
6696     type_specifier,
6697     semicolon)
6698   {
6699     super('type_const_declaration', {
6700       attribute_spec: attribute_spec,
6701       abstract: abstract,
6702       keyword: keyword,
6703       type_keyword: type_keyword,
6704       name: name,
6705       type_parameters: type_parameters,
6706       type_constraint: type_constraint,
6707       equal: equal,
6708       type_specifier: type_specifier,
6709       semicolon: semicolon });
6710   }
6711   get attribute_spec() { return this.children.attribute_spec; }
6712   get abstract() { return this.children.abstract; }
6713   get keyword() { return this.children.keyword; }
6714   get type_keyword() { return this.children.type_keyword; }
6715   get name() { return this.children.name; }
6716   get type_parameters() { return this.children.type_parameters; }
6717   get type_constraint() { return this.children.type_constraint; }
6718   get equal() { return this.children.equal; }
6719   get type_specifier() { return this.children.type_specifier; }
6720   get semicolon() { return this.children.semicolon; }
6721   with_attribute_spec(attribute_spec){
6722     return new TypeConstDeclaration(
6723       attribute_spec,
6724       this.abstract,
6725       this.keyword,
6726       this.type_keyword,
6727       this.name,
6728       this.type_parameters,
6729       this.type_constraint,
6730       this.equal,
6731       this.type_specifier,
6732       this.semicolon);
6733   }
6734   with_abstract(abstract){
6735     return new TypeConstDeclaration(
6736       this.attribute_spec,
6737       abstract,
6738       this.keyword,
6739       this.type_keyword,
6740       this.name,
6741       this.type_parameters,
6742       this.type_constraint,
6743       this.equal,
6744       this.type_specifier,
6745       this.semicolon);
6746   }
6747   with_keyword(keyword){
6748     return new TypeConstDeclaration(
6749       this.attribute_spec,
6750       this.abstract,
6751       keyword,
6752       this.type_keyword,
6753       this.name,
6754       this.type_parameters,
6755       this.type_constraint,
6756       this.equal,
6757       this.type_specifier,
6758       this.semicolon);
6759   }
6760   with_type_keyword(type_keyword){
6761     return new TypeConstDeclaration(
6762       this.attribute_spec,
6763       this.abstract,
6764       this.keyword,
6765       type_keyword,
6766       this.name,
6767       this.type_parameters,
6768       this.type_constraint,
6769       this.equal,
6770       this.type_specifier,
6771       this.semicolon);
6772   }
6773   with_name(name){
6774     return new TypeConstDeclaration(
6775       this.attribute_spec,
6776       this.abstract,
6777       this.keyword,
6778       this.type_keyword,
6779       name,
6780       this.type_parameters,
6781       this.type_constraint,
6782       this.equal,
6783       this.type_specifier,
6784       this.semicolon);
6785   }
6786   with_type_parameters(type_parameters){
6787     return new TypeConstDeclaration(
6788       this.attribute_spec,
6789       this.abstract,
6790       this.keyword,
6791       this.type_keyword,
6792       this.name,
6793       type_parameters,
6794       this.type_constraint,
6795       this.equal,
6796       this.type_specifier,
6797       this.semicolon);
6798   }
6799   with_type_constraint(type_constraint){
6800     return new TypeConstDeclaration(
6801       this.attribute_spec,
6802       this.abstract,
6803       this.keyword,
6804       this.type_keyword,
6805       this.name,
6806       this.type_parameters,
6807       type_constraint,
6808       this.equal,
6809       this.type_specifier,
6810       this.semicolon);
6811   }
6812   with_equal(equal){
6813     return new TypeConstDeclaration(
6814       this.attribute_spec,
6815       this.abstract,
6816       this.keyword,
6817       this.type_keyword,
6818       this.name,
6819       this.type_parameters,
6820       this.type_constraint,
6821       equal,
6822       this.type_specifier,
6823       this.semicolon);
6824   }
6825   with_type_specifier(type_specifier){
6826     return new TypeConstDeclaration(
6827       this.attribute_spec,
6828       this.abstract,
6829       this.keyword,
6830       this.type_keyword,
6831       this.name,
6832       this.type_parameters,
6833       this.type_constraint,
6834       this.equal,
6835       type_specifier,
6836       this.semicolon);
6837   }
6838   with_semicolon(semicolon){
6839     return new TypeConstDeclaration(
6840       this.attribute_spec,
6841       this.abstract,
6842       this.keyword,
6843       this.type_keyword,
6844       this.name,
6845       this.type_parameters,
6846       this.type_constraint,
6847       this.equal,
6848       this.type_specifier,
6849       semicolon);
6850   }
6851   rewrite(rewriter, parents)
6852   {
6853     if (parents == undefined)
6854       parents = [];
6855     let new_parents = parents.slice();
6856     new_parents.push(this);
6857     var attribute_spec = this.attribute_spec.rewrite(rewriter, new_parents);
6858     var abstract = this.abstract.rewrite(rewriter, new_parents);
6859     var keyword = this.keyword.rewrite(rewriter, new_parents);
6860     var type_keyword = this.type_keyword.rewrite(rewriter, new_parents);
6861     var name = this.name.rewrite(rewriter, new_parents);
6862     var type_parameters = this.type_parameters.rewrite(rewriter, new_parents);
6863     var type_constraint = this.type_constraint.rewrite(rewriter, new_parents);
6864     var equal = this.equal.rewrite(rewriter, new_parents);
6865     var type_specifier = this.type_specifier.rewrite(rewriter, new_parents);
6866     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
6867     if (
6868       attribute_spec === this.attribute_spec &&
6869       abstract === this.abstract &&
6870       keyword === this.keyword &&
6871       type_keyword === this.type_keyword &&
6872       name === this.name &&
6873       type_parameters === this.type_parameters &&
6874       type_constraint === this.type_constraint &&
6875       equal === this.equal &&
6876       type_specifier === this.type_specifier &&
6877       semicolon === this.semicolon)
6878     {
6879       return rewriter(this, parents);
6880     }
6881     else
6882     {
6883       return rewriter(new TypeConstDeclaration(
6884         attribute_spec,
6885         abstract,
6886         keyword,
6887         type_keyword,
6888         name,
6889         type_parameters,
6890         type_constraint,
6891         equal,
6892         type_specifier,
6893         semicolon), parents);
6894     }
6895   }
6896   static from_json(json, position, source)
6897   {
6898     let attribute_spec = EditableSyntax.from_json(
6899       json.type_const_attribute_spec, position, source);
6900     position += attribute_spec.width;
6901     let abstract = EditableSyntax.from_json(
6902       json.type_const_abstract, position, source);
6903     position += abstract.width;
6904     let keyword = EditableSyntax.from_json(
6905       json.type_const_keyword, position, source);
6906     position += keyword.width;
6907     let type_keyword = EditableSyntax.from_json(
6908       json.type_const_type_keyword, position, source);
6909     position += type_keyword.width;
6910     let name = EditableSyntax.from_json(
6911       json.type_const_name, position, source);
6912     position += name.width;
6913     let type_parameters = EditableSyntax.from_json(
6914       json.type_const_type_parameters, position, source);
6915     position += type_parameters.width;
6916     let type_constraint = EditableSyntax.from_json(
6917       json.type_const_type_constraint, position, source);
6918     position += type_constraint.width;
6919     let equal = EditableSyntax.from_json(
6920       json.type_const_equal, position, source);
6921     position += equal.width;
6922     let type_specifier = EditableSyntax.from_json(
6923       json.type_const_type_specifier, position, source);
6924     position += type_specifier.width;
6925     let semicolon = EditableSyntax.from_json(
6926       json.type_const_semicolon, position, source);
6927     position += semicolon.width;
6928     return new TypeConstDeclaration(
6929         attribute_spec,
6930         abstract,
6931         keyword,
6932         type_keyword,
6933         name,
6934         type_parameters,
6935         type_constraint,
6936         equal,
6937         type_specifier,
6938         semicolon);
6939   }
6940   get children_keys()
6941   {
6942     if (TypeConstDeclaration._children_keys == null)
6943       TypeConstDeclaration._children_keys = [
6944         'attribute_spec',
6945         'abstract',
6946         'keyword',
6947         'type_keyword',
6948         'name',
6949         'type_parameters',
6950         'type_constraint',
6951         'equal',
6952         'type_specifier',
6953         'semicolon'];
6954     return TypeConstDeclaration._children_keys;
6955   }
6956 }
6957 class DecoratedExpression extends EditableSyntax
6958 {
6959   constructor(
6960     decorator,
6961     expression)
6962   {
6963     super('decorated_expression', {
6964       decorator: decorator,
6965       expression: expression });
6966   }
6967   get decorator() { return this.children.decorator; }
6968   get expression() { return this.children.expression; }
6969   with_decorator(decorator){
6970     return new DecoratedExpression(
6971       decorator,
6972       this.expression);
6973   }
6974   with_expression(expression){
6975     return new DecoratedExpression(
6976       this.decorator,
6977       expression);
6978   }
6979   rewrite(rewriter, parents)
6980   {
6981     if (parents == undefined)
6982       parents = [];
6983     let new_parents = parents.slice();
6984     new_parents.push(this);
6985     var decorator = this.decorator.rewrite(rewriter, new_parents);
6986     var expression = this.expression.rewrite(rewriter, new_parents);
6987     if (
6988       decorator === this.decorator &&
6989       expression === this.expression)
6990     {
6991       return rewriter(this, parents);
6992     }
6993     else
6994     {
6995       return rewriter(new DecoratedExpression(
6996         decorator,
6997         expression), parents);
6998     }
6999   }
7000   static from_json(json, position, source)
7001   {
7002     let decorator = EditableSyntax.from_json(
7003       json.decorated_expression_decorator, position, source);
7004     position += decorator.width;
7005     let expression = EditableSyntax.from_json(
7006       json.decorated_expression_expression, position, source);
7007     position += expression.width;
7008     return new DecoratedExpression(
7009         decorator,
7010         expression);
7011   }
7012   get children_keys()
7013   {
7014     if (DecoratedExpression._children_keys == null)
7015       DecoratedExpression._children_keys = [
7016         'decorator',
7017         'expression'];
7018     return DecoratedExpression._children_keys;
7019   }
7020 }
7021 class ParameterDeclaration extends EditableSyntax
7022 {
7023   constructor(
7024     attribute,
7025     visibility,
7026     call_convention,
7027     type,
7028     name,
7029     default_value)
7030   {
7031     super('parameter_declaration', {
7032       attribute: attribute,
7033       visibility: visibility,
7034       call_convention: call_convention,
7035       type: type,
7036       name: name,
7037       default_value: default_value });
7038   }
7039   get attribute() { return this.children.attribute; }
7040   get visibility() { return this.children.visibility; }
7041   get call_convention() { return this.children.call_convention; }
7042   get type() { return this.children.type; }
7043   get name() { return this.children.name; }
7044   get default_value() { return this.children.default_value; }
7045   with_attribute(attribute){
7046     return new ParameterDeclaration(
7047       attribute,
7048       this.visibility,
7049       this.call_convention,
7050       this.type,
7051       this.name,
7052       this.default_value);
7053   }
7054   with_visibility(visibility){
7055     return new ParameterDeclaration(
7056       this.attribute,
7057       visibility,
7058       this.call_convention,
7059       this.type,
7060       this.name,
7061       this.default_value);
7062   }
7063   with_call_convention(call_convention){
7064     return new ParameterDeclaration(
7065       this.attribute,
7066       this.visibility,
7067       call_convention,
7068       this.type,
7069       this.name,
7070       this.default_value);
7071   }
7072   with_type(type){
7073     return new ParameterDeclaration(
7074       this.attribute,
7075       this.visibility,
7076       this.call_convention,
7077       type,
7078       this.name,
7079       this.default_value);
7080   }
7081   with_name(name){
7082     return new ParameterDeclaration(
7083       this.attribute,
7084       this.visibility,
7085       this.call_convention,
7086       this.type,
7087       name,
7088       this.default_value);
7089   }
7090   with_default_value(default_value){
7091     return new ParameterDeclaration(
7092       this.attribute,
7093       this.visibility,
7094       this.call_convention,
7095       this.type,
7096       this.name,
7097       default_value);
7098   }
7099   rewrite(rewriter, parents)
7100   {
7101     if (parents == undefined)
7102       parents = [];
7103     let new_parents = parents.slice();
7104     new_parents.push(this);
7105     var attribute = this.attribute.rewrite(rewriter, new_parents);
7106     var visibility = this.visibility.rewrite(rewriter, new_parents);
7107     var call_convention = this.call_convention.rewrite(rewriter, new_parents);
7108     var type = this.type.rewrite(rewriter, new_parents);
7109     var name = this.name.rewrite(rewriter, new_parents);
7110     var default_value = this.default_value.rewrite(rewriter, new_parents);
7111     if (
7112       attribute === this.attribute &&
7113       visibility === this.visibility &&
7114       call_convention === this.call_convention &&
7115       type === this.type &&
7116       name === this.name &&
7117       default_value === this.default_value)
7118     {
7119       return rewriter(this, parents);
7120     }
7121     else
7122     {
7123       return rewriter(new ParameterDeclaration(
7124         attribute,
7125         visibility,
7126         call_convention,
7127         type,
7128         name,
7129         default_value), parents);
7130     }
7131   }
7132   static from_json(json, position, source)
7133   {
7134     let attribute = EditableSyntax.from_json(
7135       json.parameter_attribute, position, source);
7136     position += attribute.width;
7137     let visibility = EditableSyntax.from_json(
7138       json.parameter_visibility, position, source);
7139     position += visibility.width;
7140     let call_convention = EditableSyntax.from_json(
7141       json.parameter_call_convention, position, source);
7142     position += call_convention.width;
7143     let type = EditableSyntax.from_json(
7144       json.parameter_type, position, source);
7145     position += type.width;
7146     let name = EditableSyntax.from_json(
7147       json.parameter_name, position, source);
7148     position += name.width;
7149     let default_value = EditableSyntax.from_json(
7150       json.parameter_default_value, position, source);
7151     position += default_value.width;
7152     return new ParameterDeclaration(
7153         attribute,
7154         visibility,
7155         call_convention,
7156         type,
7157         name,
7158         default_value);
7159   }
7160   get children_keys()
7161   {
7162     if (ParameterDeclaration._children_keys == null)
7163       ParameterDeclaration._children_keys = [
7164         'attribute',
7165         'visibility',
7166         'call_convention',
7167         'type',
7168         'name',
7169         'default_value'];
7170     return ParameterDeclaration._children_keys;
7171   }
7172 }
7173 class VariadicParameter extends EditableSyntax
7174 {
7175   constructor(
7176     call_convention,
7177     type,
7178     ellipsis)
7179   {
7180     super('variadic_parameter', {
7181       call_convention: call_convention,
7182       type: type,
7183       ellipsis: ellipsis });
7184   }
7185   get call_convention() { return this.children.call_convention; }
7186   get type() { return this.children.type; }
7187   get ellipsis() { return this.children.ellipsis; }
7188   with_call_convention(call_convention){
7189     return new VariadicParameter(
7190       call_convention,
7191       this.type,
7192       this.ellipsis);
7193   }
7194   with_type(type){
7195     return new VariadicParameter(
7196       this.call_convention,
7197       type,
7198       this.ellipsis);
7199   }
7200   with_ellipsis(ellipsis){
7201     return new VariadicParameter(
7202       this.call_convention,
7203       this.type,
7204       ellipsis);
7205   }
7206   rewrite(rewriter, parents)
7207   {
7208     if (parents == undefined)
7209       parents = [];
7210     let new_parents = parents.slice();
7211     new_parents.push(this);
7212     var call_convention = this.call_convention.rewrite(rewriter, new_parents);
7213     var type = this.type.rewrite(rewriter, new_parents);
7214     var ellipsis = this.ellipsis.rewrite(rewriter, new_parents);
7215     if (
7216       call_convention === this.call_convention &&
7217       type === this.type &&
7218       ellipsis === this.ellipsis)
7219     {
7220       return rewriter(this, parents);
7221     }
7222     else
7223     {
7224       return rewriter(new VariadicParameter(
7225         call_convention,
7226         type,
7227         ellipsis), parents);
7228     }
7229   }
7230   static from_json(json, position, source)
7231   {
7232     let call_convention = EditableSyntax.from_json(
7233       json.variadic_parameter_call_convention, position, source);
7234     position += call_convention.width;
7235     let type = EditableSyntax.from_json(
7236       json.variadic_parameter_type, position, source);
7237     position += type.width;
7238     let ellipsis = EditableSyntax.from_json(
7239       json.variadic_parameter_ellipsis, position, source);
7240     position += ellipsis.width;
7241     return new VariadicParameter(
7242         call_convention,
7243         type,
7244         ellipsis);
7245   }
7246   get children_keys()
7247   {
7248     if (VariadicParameter._children_keys == null)
7249       VariadicParameter._children_keys = [
7250         'call_convention',
7251         'type',
7252         'ellipsis'];
7253     return VariadicParameter._children_keys;
7254   }
7255 }
7256 class AttributeSpecification extends EditableSyntax
7257 {
7258   constructor(
7259     left_double_angle,
7260     attributes,
7261     right_double_angle)
7262   {
7263     super('attribute_specification', {
7264       left_double_angle: left_double_angle,
7265       attributes: attributes,
7266       right_double_angle: right_double_angle });
7267   }
7268   get left_double_angle() { return this.children.left_double_angle; }
7269   get attributes() { return this.children.attributes; }
7270   get right_double_angle() { return this.children.right_double_angle; }
7271   with_left_double_angle(left_double_angle){
7272     return new AttributeSpecification(
7273       left_double_angle,
7274       this.attributes,
7275       this.right_double_angle);
7276   }
7277   with_attributes(attributes){
7278     return new AttributeSpecification(
7279       this.left_double_angle,
7280       attributes,
7281       this.right_double_angle);
7282   }
7283   with_right_double_angle(right_double_angle){
7284     return new AttributeSpecification(
7285       this.left_double_angle,
7286       this.attributes,
7287       right_double_angle);
7288   }
7289   rewrite(rewriter, parents)
7290   {
7291     if (parents == undefined)
7292       parents = [];
7293     let new_parents = parents.slice();
7294     new_parents.push(this);
7295     var left_double_angle = this.left_double_angle.rewrite(rewriter, new_parents);
7296     var attributes = this.attributes.rewrite(rewriter, new_parents);
7297     var right_double_angle = this.right_double_angle.rewrite(rewriter, new_parents);
7298     if (
7299       left_double_angle === this.left_double_angle &&
7300       attributes === this.attributes &&
7301       right_double_angle === this.right_double_angle)
7302     {
7303       return rewriter(this, parents);
7304     }
7305     else
7306     {
7307       return rewriter(new AttributeSpecification(
7308         left_double_angle,
7309         attributes,
7310         right_double_angle), parents);
7311     }
7312   }
7313   static from_json(json, position, source)
7314   {
7315     let left_double_angle = EditableSyntax.from_json(
7316       json.attribute_specification_left_double_angle, position, source);
7317     position += left_double_angle.width;
7318     let attributes = EditableSyntax.from_json(
7319       json.attribute_specification_attributes, position, source);
7320     position += attributes.width;
7321     let right_double_angle = EditableSyntax.from_json(
7322       json.attribute_specification_right_double_angle, position, source);
7323     position += right_double_angle.width;
7324     return new AttributeSpecification(
7325         left_double_angle,
7326         attributes,
7327         right_double_angle);
7328   }
7329   get children_keys()
7330   {
7331     if (AttributeSpecification._children_keys == null)
7332       AttributeSpecification._children_keys = [
7333         'left_double_angle',
7334         'attributes',
7335         'right_double_angle'];
7336     return AttributeSpecification._children_keys;
7337   }
7338 }
7339 class InclusionExpression extends EditableSyntax
7340 {
7341   constructor(
7342     require,
7343     filename)
7344   {
7345     super('inclusion_expression', {
7346       require: require,
7347       filename: filename });
7348   }
7349   get require() { return this.children.require; }
7350   get filename() { return this.children.filename; }
7351   with_require(require){
7352     return new InclusionExpression(
7353       require,
7354       this.filename);
7355   }
7356   with_filename(filename){
7357     return new InclusionExpression(
7358       this.require,
7359       filename);
7360   }
7361   rewrite(rewriter, parents)
7362   {
7363     if (parents == undefined)
7364       parents = [];
7365     let new_parents = parents.slice();
7366     new_parents.push(this);
7367     var require = this.require.rewrite(rewriter, new_parents);
7368     var filename = this.filename.rewrite(rewriter, new_parents);
7369     if (
7370       require === this.require &&
7371       filename === this.filename)
7372     {
7373       return rewriter(this, parents);
7374     }
7375     else
7376     {
7377       return rewriter(new InclusionExpression(
7378         require,
7379         filename), parents);
7380     }
7381   }
7382   static from_json(json, position, source)
7383   {
7384     let require = EditableSyntax.from_json(
7385       json.inclusion_require, position, source);
7386     position += require.width;
7387     let filename = EditableSyntax.from_json(
7388       json.inclusion_filename, position, source);
7389     position += filename.width;
7390     return new InclusionExpression(
7391         require,
7392         filename);
7393   }
7394   get children_keys()
7395   {
7396     if (InclusionExpression._children_keys == null)
7397       InclusionExpression._children_keys = [
7398         'require',
7399         'filename'];
7400     return InclusionExpression._children_keys;
7401   }
7402 }
7403 class InclusionDirective extends EditableSyntax
7404 {
7405   constructor(
7406     expression,
7407     semicolon)
7408   {
7409     super('inclusion_directive', {
7410       expression: expression,
7411       semicolon: semicolon });
7412   }
7413   get expression() { return this.children.expression; }
7414   get semicolon() { return this.children.semicolon; }
7415   with_expression(expression){
7416     return new InclusionDirective(
7417       expression,
7418       this.semicolon);
7419   }
7420   with_semicolon(semicolon){
7421     return new InclusionDirective(
7422       this.expression,
7423       semicolon);
7424   }
7425   rewrite(rewriter, parents)
7426   {
7427     if (parents == undefined)
7428       parents = [];
7429     let new_parents = parents.slice();
7430     new_parents.push(this);
7431     var expression = this.expression.rewrite(rewriter, new_parents);
7432     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
7433     if (
7434       expression === this.expression &&
7435       semicolon === this.semicolon)
7436     {
7437       return rewriter(this, parents);
7438     }
7439     else
7440     {
7441       return rewriter(new InclusionDirective(
7442         expression,
7443         semicolon), parents);
7444     }
7445   }
7446   static from_json(json, position, source)
7447   {
7448     let expression = EditableSyntax.from_json(
7449       json.inclusion_expression, position, source);
7450     position += expression.width;
7451     let semicolon = EditableSyntax.from_json(
7452       json.inclusion_semicolon, position, source);
7453     position += semicolon.width;
7454     return new InclusionDirective(
7455         expression,
7456         semicolon);
7457   }
7458   get children_keys()
7459   {
7460     if (InclusionDirective._children_keys == null)
7461       InclusionDirective._children_keys = [
7462         'expression',
7463         'semicolon'];
7464     return InclusionDirective._children_keys;
7465   }
7466 }
7467 class CompoundStatement extends EditableSyntax
7468 {
7469   constructor(
7470     left_brace,
7471     statements,
7472     right_brace)
7473   {
7474     super('compound_statement', {
7475       left_brace: left_brace,
7476       statements: statements,
7477       right_brace: right_brace });
7478   }
7479   get left_brace() { return this.children.left_brace; }
7480   get statements() { return this.children.statements; }
7481   get right_brace() { return this.children.right_brace; }
7482   with_left_brace(left_brace){
7483     return new CompoundStatement(
7484       left_brace,
7485       this.statements,
7486       this.right_brace);
7487   }
7488   with_statements(statements){
7489     return new CompoundStatement(
7490       this.left_brace,
7491       statements,
7492       this.right_brace);
7493   }
7494   with_right_brace(right_brace){
7495     return new CompoundStatement(
7496       this.left_brace,
7497       this.statements,
7498       right_brace);
7499   }
7500   rewrite(rewriter, parents)
7501   {
7502     if (parents == undefined)
7503       parents = [];
7504     let new_parents = parents.slice();
7505     new_parents.push(this);
7506     var left_brace = this.left_brace.rewrite(rewriter, new_parents);
7507     var statements = this.statements.rewrite(rewriter, new_parents);
7508     var right_brace = this.right_brace.rewrite(rewriter, new_parents);
7509     if (
7510       left_brace === this.left_brace &&
7511       statements === this.statements &&
7512       right_brace === this.right_brace)
7513     {
7514       return rewriter(this, parents);
7515     }
7516     else
7517     {
7518       return rewriter(new CompoundStatement(
7519         left_brace,
7520         statements,
7521         right_brace), parents);
7522     }
7523   }
7524   static from_json(json, position, source)
7525   {
7526     let left_brace = EditableSyntax.from_json(
7527       json.compound_left_brace, position, source);
7528     position += left_brace.width;
7529     let statements = EditableSyntax.from_json(
7530       json.compound_statements, position, source);
7531     position += statements.width;
7532     let right_brace = EditableSyntax.from_json(
7533       json.compound_right_brace, position, source);
7534     position += right_brace.width;
7535     return new CompoundStatement(
7536         left_brace,
7537         statements,
7538         right_brace);
7539   }
7540   get children_keys()
7541   {
7542     if (CompoundStatement._children_keys == null)
7543       CompoundStatement._children_keys = [
7544         'left_brace',
7545         'statements',
7546         'right_brace'];
7547     return CompoundStatement._children_keys;
7548   }
7549 }
7550 class AlternateLoopStatement extends EditableSyntax
7551 {
7552   constructor(
7553     opening_colon,
7554     statements,
7555     closing_keyword,
7556     closing_semicolon)
7557   {
7558     super('alternate_loop_statement', {
7559       opening_colon: opening_colon,
7560       statements: statements,
7561       closing_keyword: closing_keyword,
7562       closing_semicolon: closing_semicolon });
7563   }
7564   get opening_colon() { return this.children.opening_colon; }
7565   get statements() { return this.children.statements; }
7566   get closing_keyword() { return this.children.closing_keyword; }
7567   get closing_semicolon() { return this.children.closing_semicolon; }
7568   with_opening_colon(opening_colon){
7569     return new AlternateLoopStatement(
7570       opening_colon,
7571       this.statements,
7572       this.closing_keyword,
7573       this.closing_semicolon);
7574   }
7575   with_statements(statements){
7576     return new AlternateLoopStatement(
7577       this.opening_colon,
7578       statements,
7579       this.closing_keyword,
7580       this.closing_semicolon);
7581   }
7582   with_closing_keyword(closing_keyword){
7583     return new AlternateLoopStatement(
7584       this.opening_colon,
7585       this.statements,
7586       closing_keyword,
7587       this.closing_semicolon);
7588   }
7589   with_closing_semicolon(closing_semicolon){
7590     return new AlternateLoopStatement(
7591       this.opening_colon,
7592       this.statements,
7593       this.closing_keyword,
7594       closing_semicolon);
7595   }
7596   rewrite(rewriter, parents)
7597   {
7598     if (parents == undefined)
7599       parents = [];
7600     let new_parents = parents.slice();
7601     new_parents.push(this);
7602     var opening_colon = this.opening_colon.rewrite(rewriter, new_parents);
7603     var statements = this.statements.rewrite(rewriter, new_parents);
7604     var closing_keyword = this.closing_keyword.rewrite(rewriter, new_parents);
7605     var closing_semicolon = this.closing_semicolon.rewrite(rewriter, new_parents);
7606     if (
7607       opening_colon === this.opening_colon &&
7608       statements === this.statements &&
7609       closing_keyword === this.closing_keyword &&
7610       closing_semicolon === this.closing_semicolon)
7611     {
7612       return rewriter(this, parents);
7613     }
7614     else
7615     {
7616       return rewriter(new AlternateLoopStatement(
7617         opening_colon,
7618         statements,
7619         closing_keyword,
7620         closing_semicolon), parents);
7621     }
7622   }
7623   static from_json(json, position, source)
7624   {
7625     let opening_colon = EditableSyntax.from_json(
7626       json.alternate_loop_opening_colon, position, source);
7627     position += opening_colon.width;
7628     let statements = EditableSyntax.from_json(
7629       json.alternate_loop_statements, position, source);
7630     position += statements.width;
7631     let closing_keyword = EditableSyntax.from_json(
7632       json.alternate_loop_closing_keyword, position, source);
7633     position += closing_keyword.width;
7634     let closing_semicolon = EditableSyntax.from_json(
7635       json.alternate_loop_closing_semicolon, position, source);
7636     position += closing_semicolon.width;
7637     return new AlternateLoopStatement(
7638         opening_colon,
7639         statements,
7640         closing_keyword,
7641         closing_semicolon);
7642   }
7643   get children_keys()
7644   {
7645     if (AlternateLoopStatement._children_keys == null)
7646       AlternateLoopStatement._children_keys = [
7647         'opening_colon',
7648         'statements',
7649         'closing_keyword',
7650         'closing_semicolon'];
7651     return AlternateLoopStatement._children_keys;
7652   }
7653 }
7654 class ExpressionStatement extends EditableSyntax
7655 {
7656   constructor(
7657     expression,
7658     semicolon)
7659   {
7660     super('expression_statement', {
7661       expression: expression,
7662       semicolon: semicolon });
7663   }
7664   get expression() { return this.children.expression; }
7665   get semicolon() { return this.children.semicolon; }
7666   with_expression(expression){
7667     return new ExpressionStatement(
7668       expression,
7669       this.semicolon);
7670   }
7671   with_semicolon(semicolon){
7672     return new ExpressionStatement(
7673       this.expression,
7674       semicolon);
7675   }
7676   rewrite(rewriter, parents)
7677   {
7678     if (parents == undefined)
7679       parents = [];
7680     let new_parents = parents.slice();
7681     new_parents.push(this);
7682     var expression = this.expression.rewrite(rewriter, new_parents);
7683     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
7684     if (
7685       expression === this.expression &&
7686       semicolon === this.semicolon)
7687     {
7688       return rewriter(this, parents);
7689     }
7690     else
7691     {
7692       return rewriter(new ExpressionStatement(
7693         expression,
7694         semicolon), parents);
7695     }
7696   }
7697   static from_json(json, position, source)
7698   {
7699     let expression = EditableSyntax.from_json(
7700       json.expression_statement_expression, position, source);
7701     position += expression.width;
7702     let semicolon = EditableSyntax.from_json(
7703       json.expression_statement_semicolon, position, source);
7704     position += semicolon.width;
7705     return new ExpressionStatement(
7706         expression,
7707         semicolon);
7708   }
7709   get children_keys()
7710   {
7711     if (ExpressionStatement._children_keys == null)
7712       ExpressionStatement._children_keys = [
7713         'expression',
7714         'semicolon'];
7715     return ExpressionStatement._children_keys;
7716   }
7717 }
7718 class MarkupSection extends EditableSyntax
7719 {
7720   constructor(
7721     prefix,
7722     text,
7723     suffix,
7724     expression)
7725   {
7726     super('markup_section', {
7727       prefix: prefix,
7728       text: text,
7729       suffix: suffix,
7730       expression: expression });
7731   }
7732   get prefix() { return this.children.prefix; }
7733   get text() { return this.children.text; }
7734   get suffix() { return this.children.suffix; }
7735   get expression() { return this.children.expression; }
7736   with_prefix(prefix){
7737     return new MarkupSection(
7738       prefix,
7739       this.text,
7740       this.suffix,
7741       this.expression);
7742   }
7743   with_text(text){
7744     return new MarkupSection(
7745       this.prefix,
7746       text,
7747       this.suffix,
7748       this.expression);
7749   }
7750   with_suffix(suffix){
7751     return new MarkupSection(
7752       this.prefix,
7753       this.text,
7754       suffix,
7755       this.expression);
7756   }
7757   with_expression(expression){
7758     return new MarkupSection(
7759       this.prefix,
7760       this.text,
7761       this.suffix,
7762       expression);
7763   }
7764   rewrite(rewriter, parents)
7765   {
7766     if (parents == undefined)
7767       parents = [];
7768     let new_parents = parents.slice();
7769     new_parents.push(this);
7770     var prefix = this.prefix.rewrite(rewriter, new_parents);
7771     var text = this.text.rewrite(rewriter, new_parents);
7772     var suffix = this.suffix.rewrite(rewriter, new_parents);
7773     var expression = this.expression.rewrite(rewriter, new_parents);
7774     if (
7775       prefix === this.prefix &&
7776       text === this.text &&
7777       suffix === this.suffix &&
7778       expression === this.expression)
7779     {
7780       return rewriter(this, parents);
7781     }
7782     else
7783     {
7784       return rewriter(new MarkupSection(
7785         prefix,
7786         text,
7787         suffix,
7788         expression), parents);
7789     }
7790   }
7791   static from_json(json, position, source)
7792   {
7793     let prefix = EditableSyntax.from_json(
7794       json.markup_prefix, position, source);
7795     position += prefix.width;
7796     let text = EditableSyntax.from_json(
7797       json.markup_text, position, source);
7798     position += text.width;
7799     let suffix = EditableSyntax.from_json(
7800       json.markup_suffix, position, source);
7801     position += suffix.width;
7802     let expression = EditableSyntax.from_json(
7803       json.markup_expression, position, source);
7804     position += expression.width;
7805     return new MarkupSection(
7806         prefix,
7807         text,
7808         suffix,
7809         expression);
7810   }
7811   get children_keys()
7812   {
7813     if (MarkupSection._children_keys == null)
7814       MarkupSection._children_keys = [
7815         'prefix',
7816         'text',
7817         'suffix',
7818         'expression'];
7819     return MarkupSection._children_keys;
7820   }
7821 }
7822 class MarkupSuffix extends EditableSyntax
7823 {
7824   constructor(
7825     less_than_question,
7826     name)
7827   {
7828     super('markup_suffix', {
7829       less_than_question: less_than_question,
7830       name: name });
7831   }
7832   get less_than_question() { return this.children.less_than_question; }
7833   get name() { return this.children.name; }
7834   with_less_than_question(less_than_question){
7835     return new MarkupSuffix(
7836       less_than_question,
7837       this.name);
7838   }
7839   with_name(name){
7840     return new MarkupSuffix(
7841       this.less_than_question,
7842       name);
7843   }
7844   rewrite(rewriter, parents)
7845   {
7846     if (parents == undefined)
7847       parents = [];
7848     let new_parents = parents.slice();
7849     new_parents.push(this);
7850     var less_than_question = this.less_than_question.rewrite(rewriter, new_parents);
7851     var name = this.name.rewrite(rewriter, new_parents);
7852     if (
7853       less_than_question === this.less_than_question &&
7854       name === this.name)
7855     {
7856       return rewriter(this, parents);
7857     }
7858     else
7859     {
7860       return rewriter(new MarkupSuffix(
7861         less_than_question,
7862         name), parents);
7863     }
7864   }
7865   static from_json(json, position, source)
7866   {
7867     let less_than_question = EditableSyntax.from_json(
7868       json.markup_suffix_less_than_question, position, source);
7869     position += less_than_question.width;
7870     let name = EditableSyntax.from_json(
7871       json.markup_suffix_name, position, source);
7872     position += name.width;
7873     return new MarkupSuffix(
7874         less_than_question,
7875         name);
7876   }
7877   get children_keys()
7878   {
7879     if (MarkupSuffix._children_keys == null)
7880       MarkupSuffix._children_keys = [
7881         'less_than_question',
7882         'name'];
7883     return MarkupSuffix._children_keys;
7884   }
7885 }
7886 class UnsetStatement extends EditableSyntax
7887 {
7888   constructor(
7889     keyword,
7890     left_paren,
7891     variables,
7892     right_paren,
7893     semicolon)
7894   {
7895     super('unset_statement', {
7896       keyword: keyword,
7897       left_paren: left_paren,
7898       variables: variables,
7899       right_paren: right_paren,
7900       semicolon: semicolon });
7901   }
7902   get keyword() { return this.children.keyword; }
7903   get left_paren() { return this.children.left_paren; }
7904   get variables() { return this.children.variables; }
7905   get right_paren() { return this.children.right_paren; }
7906   get semicolon() { return this.children.semicolon; }
7907   with_keyword(keyword){
7908     return new UnsetStatement(
7909       keyword,
7910       this.left_paren,
7911       this.variables,
7912       this.right_paren,
7913       this.semicolon);
7914   }
7915   with_left_paren(left_paren){
7916     return new UnsetStatement(
7917       this.keyword,
7918       left_paren,
7919       this.variables,
7920       this.right_paren,
7921       this.semicolon);
7922   }
7923   with_variables(variables){
7924     return new UnsetStatement(
7925       this.keyword,
7926       this.left_paren,
7927       variables,
7928       this.right_paren,
7929       this.semicolon);
7930   }
7931   with_right_paren(right_paren){
7932     return new UnsetStatement(
7933       this.keyword,
7934       this.left_paren,
7935       this.variables,
7936       right_paren,
7937       this.semicolon);
7938   }
7939   with_semicolon(semicolon){
7940     return new UnsetStatement(
7941       this.keyword,
7942       this.left_paren,
7943       this.variables,
7944       this.right_paren,
7945       semicolon);
7946   }
7947   rewrite(rewriter, parents)
7948   {
7949     if (parents == undefined)
7950       parents = [];
7951     let new_parents = parents.slice();
7952     new_parents.push(this);
7953     var keyword = this.keyword.rewrite(rewriter, new_parents);
7954     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
7955     var variables = this.variables.rewrite(rewriter, new_parents);
7956     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
7957     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
7958     if (
7959       keyword === this.keyword &&
7960       left_paren === this.left_paren &&
7961       variables === this.variables &&
7962       right_paren === this.right_paren &&
7963       semicolon === this.semicolon)
7964     {
7965       return rewriter(this, parents);
7966     }
7967     else
7968     {
7969       return rewriter(new UnsetStatement(
7970         keyword,
7971         left_paren,
7972         variables,
7973         right_paren,
7974         semicolon), parents);
7975     }
7976   }
7977   static from_json(json, position, source)
7978   {
7979     let keyword = EditableSyntax.from_json(
7980       json.unset_keyword, position, source);
7981     position += keyword.width;
7982     let left_paren = EditableSyntax.from_json(
7983       json.unset_left_paren, position, source);
7984     position += left_paren.width;
7985     let variables = EditableSyntax.from_json(
7986       json.unset_variables, position, source);
7987     position += variables.width;
7988     let right_paren = EditableSyntax.from_json(
7989       json.unset_right_paren, position, source);
7990     position += right_paren.width;
7991     let semicolon = EditableSyntax.from_json(
7992       json.unset_semicolon, position, source);
7993     position += semicolon.width;
7994     return new UnsetStatement(
7995         keyword,
7996         left_paren,
7997         variables,
7998         right_paren,
7999         semicolon);
8000   }
8001   get children_keys()
8002   {
8003     if (UnsetStatement._children_keys == null)
8004       UnsetStatement._children_keys = [
8005         'keyword',
8006         'left_paren',
8007         'variables',
8008         'right_paren',
8009         'semicolon'];
8010     return UnsetStatement._children_keys;
8011   }
8012 }
8013 class LetStatement extends EditableSyntax
8014 {
8015   constructor(
8016     keyword,
8017     name,
8018     colon,
8019     type,
8020     initializer,
8021     semicolon)
8022   {
8023     super('let_statement', {
8024       keyword: keyword,
8025       name: name,
8026       colon: colon,
8027       type: type,
8028       initializer: initializer,
8029       semicolon: semicolon });
8030   }
8031   get keyword() { return this.children.keyword; }
8032   get name() { return this.children.name; }
8033   get colon() { return this.children.colon; }
8034   get type() { return this.children.type; }
8035   get initializer() { return this.children.initializer; }
8036   get semicolon() { return this.children.semicolon; }
8037   with_keyword(keyword){
8038     return new LetStatement(
8039       keyword,
8040       this.name,
8041       this.colon,
8042       this.type,
8043       this.initializer,
8044       this.semicolon);
8045   }
8046   with_name(name){
8047     return new LetStatement(
8048       this.keyword,
8049       name,
8050       this.colon,
8051       this.type,
8052       this.initializer,
8053       this.semicolon);
8054   }
8055   with_colon(colon){
8056     return new LetStatement(
8057       this.keyword,
8058       this.name,
8059       colon,
8060       this.type,
8061       this.initializer,
8062       this.semicolon);
8063   }
8064   with_type(type){
8065     return new LetStatement(
8066       this.keyword,
8067       this.name,
8068       this.colon,
8069       type,
8070       this.initializer,
8071       this.semicolon);
8072   }
8073   with_initializer(initializer){
8074     return new LetStatement(
8075       this.keyword,
8076       this.name,
8077       this.colon,
8078       this.type,
8079       initializer,
8080       this.semicolon);
8081   }
8082   with_semicolon(semicolon){
8083     return new LetStatement(
8084       this.keyword,
8085       this.name,
8086       this.colon,
8087       this.type,
8088       this.initializer,
8089       semicolon);
8090   }
8091   rewrite(rewriter, parents)
8092   {
8093     if (parents == undefined)
8094       parents = [];
8095     let new_parents = parents.slice();
8096     new_parents.push(this);
8097     var keyword = this.keyword.rewrite(rewriter, new_parents);
8098     var name = this.name.rewrite(rewriter, new_parents);
8099     var colon = this.colon.rewrite(rewriter, new_parents);
8100     var type = this.type.rewrite(rewriter, new_parents);
8101     var initializer = this.initializer.rewrite(rewriter, new_parents);
8102     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
8103     if (
8104       keyword === this.keyword &&
8105       name === this.name &&
8106       colon === this.colon &&
8107       type === this.type &&
8108       initializer === this.initializer &&
8109       semicolon === this.semicolon)
8110     {
8111       return rewriter(this, parents);
8112     }
8113     else
8114     {
8115       return rewriter(new LetStatement(
8116         keyword,
8117         name,
8118         colon,
8119         type,
8120         initializer,
8121         semicolon), parents);
8122     }
8123   }
8124   static from_json(json, position, source)
8125   {
8126     let keyword = EditableSyntax.from_json(
8127       json.let_statement_keyword, position, source);
8128     position += keyword.width;
8129     let name = EditableSyntax.from_json(
8130       json.let_statement_name, position, source);
8131     position += name.width;
8132     let colon = EditableSyntax.from_json(
8133       json.let_statement_colon, position, source);
8134     position += colon.width;
8135     let type = EditableSyntax.from_json(
8136       json.let_statement_type, position, source);
8137     position += type.width;
8138     let initializer = EditableSyntax.from_json(
8139       json.let_statement_initializer, position, source);
8140     position += initializer.width;
8141     let semicolon = EditableSyntax.from_json(
8142       json.let_statement_semicolon, position, source);
8143     position += semicolon.width;
8144     return new LetStatement(
8145         keyword,
8146         name,
8147         colon,
8148         type,
8149         initializer,
8150         semicolon);
8151   }
8152   get children_keys()
8153   {
8154     if (LetStatement._children_keys == null)
8155       LetStatement._children_keys = [
8156         'keyword',
8157         'name',
8158         'colon',
8159         'type',
8160         'initializer',
8161         'semicolon'];
8162     return LetStatement._children_keys;
8163   }
8164 }
8165 class UsingStatementBlockScoped extends EditableSyntax
8166 {
8167   constructor(
8168     await_keyword,
8169     using_keyword,
8170     left_paren,
8171     expressions,
8172     right_paren,
8173     body)
8174   {
8175     super('using_statement_block_scoped', {
8176       await_keyword: await_keyword,
8177       using_keyword: using_keyword,
8178       left_paren: left_paren,
8179       expressions: expressions,
8180       right_paren: right_paren,
8181       body: body });
8182   }
8183   get await_keyword() { return this.children.await_keyword; }
8184   get using_keyword() { return this.children.using_keyword; }
8185   get left_paren() { return this.children.left_paren; }
8186   get expressions() { return this.children.expressions; }
8187   get right_paren() { return this.children.right_paren; }
8188   get body() { return this.children.body; }
8189   with_await_keyword(await_keyword){
8190     return new UsingStatementBlockScoped(
8191       await_keyword,
8192       this.using_keyword,
8193       this.left_paren,
8194       this.expressions,
8195       this.right_paren,
8196       this.body);
8197   }
8198   with_using_keyword(using_keyword){
8199     return new UsingStatementBlockScoped(
8200       this.await_keyword,
8201       using_keyword,
8202       this.left_paren,
8203       this.expressions,
8204       this.right_paren,
8205       this.body);
8206   }
8207   with_left_paren(left_paren){
8208     return new UsingStatementBlockScoped(
8209       this.await_keyword,
8210       this.using_keyword,
8211       left_paren,
8212       this.expressions,
8213       this.right_paren,
8214       this.body);
8215   }
8216   with_expressions(expressions){
8217     return new UsingStatementBlockScoped(
8218       this.await_keyword,
8219       this.using_keyword,
8220       this.left_paren,
8221       expressions,
8222       this.right_paren,
8223       this.body);
8224   }
8225   with_right_paren(right_paren){
8226     return new UsingStatementBlockScoped(
8227       this.await_keyword,
8228       this.using_keyword,
8229       this.left_paren,
8230       this.expressions,
8231       right_paren,
8232       this.body);
8233   }
8234   with_body(body){
8235     return new UsingStatementBlockScoped(
8236       this.await_keyword,
8237       this.using_keyword,
8238       this.left_paren,
8239       this.expressions,
8240       this.right_paren,
8241       body);
8242   }
8243   rewrite(rewriter, parents)
8244   {
8245     if (parents == undefined)
8246       parents = [];
8247     let new_parents = parents.slice();
8248     new_parents.push(this);
8249     var await_keyword = this.await_keyword.rewrite(rewriter, new_parents);
8250     var using_keyword = this.using_keyword.rewrite(rewriter, new_parents);
8251     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
8252     var expressions = this.expressions.rewrite(rewriter, new_parents);
8253     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
8254     var body = this.body.rewrite(rewriter, new_parents);
8255     if (
8256       await_keyword === this.await_keyword &&
8257       using_keyword === this.using_keyword &&
8258       left_paren === this.left_paren &&
8259       expressions === this.expressions &&
8260       right_paren === this.right_paren &&
8261       body === this.body)
8262     {
8263       return rewriter(this, parents);
8264     }
8265     else
8266     {
8267       return rewriter(new UsingStatementBlockScoped(
8268         await_keyword,
8269         using_keyword,
8270         left_paren,
8271         expressions,
8272         right_paren,
8273         body), parents);
8274     }
8275   }
8276   static from_json(json, position, source)
8277   {
8278     let await_keyword = EditableSyntax.from_json(
8279       json.using_block_await_keyword, position, source);
8280     position += await_keyword.width;
8281     let using_keyword = EditableSyntax.from_json(
8282       json.using_block_using_keyword, position, source);
8283     position += using_keyword.width;
8284     let left_paren = EditableSyntax.from_json(
8285       json.using_block_left_paren, position, source);
8286     position += left_paren.width;
8287     let expressions = EditableSyntax.from_json(
8288       json.using_block_expressions, position, source);
8289     position += expressions.width;
8290     let right_paren = EditableSyntax.from_json(
8291       json.using_block_right_paren, position, source);
8292     position += right_paren.width;
8293     let body = EditableSyntax.from_json(
8294       json.using_block_body, position, source);
8295     position += body.width;
8296     return new UsingStatementBlockScoped(
8297         await_keyword,
8298         using_keyword,
8299         left_paren,
8300         expressions,
8301         right_paren,
8302         body);
8303   }
8304   get children_keys()
8305   {
8306     if (UsingStatementBlockScoped._children_keys == null)
8307       UsingStatementBlockScoped._children_keys = [
8308         'await_keyword',
8309         'using_keyword',
8310         'left_paren',
8311         'expressions',
8312         'right_paren',
8313         'body'];
8314     return UsingStatementBlockScoped._children_keys;
8315   }
8316 }
8317 class UsingStatementFunctionScoped extends EditableSyntax
8318 {
8319   constructor(
8320     await_keyword,
8321     using_keyword,
8322     expression,
8323     semicolon)
8324   {
8325     super('using_statement_function_scoped', {
8326       await_keyword: await_keyword,
8327       using_keyword: using_keyword,
8328       expression: expression,
8329       semicolon: semicolon });
8330   }
8331   get await_keyword() { return this.children.await_keyword; }
8332   get using_keyword() { return this.children.using_keyword; }
8333   get expression() { return this.children.expression; }
8334   get semicolon() { return this.children.semicolon; }
8335   with_await_keyword(await_keyword){
8336     return new UsingStatementFunctionScoped(
8337       await_keyword,
8338       this.using_keyword,
8339       this.expression,
8340       this.semicolon);
8341   }
8342   with_using_keyword(using_keyword){
8343     return new UsingStatementFunctionScoped(
8344       this.await_keyword,
8345       using_keyword,
8346       this.expression,
8347       this.semicolon);
8348   }
8349   with_expression(expression){
8350     return new UsingStatementFunctionScoped(
8351       this.await_keyword,
8352       this.using_keyword,
8353       expression,
8354       this.semicolon);
8355   }
8356   with_semicolon(semicolon){
8357     return new UsingStatementFunctionScoped(
8358       this.await_keyword,
8359       this.using_keyword,
8360       this.expression,
8361       semicolon);
8362   }
8363   rewrite(rewriter, parents)
8364   {
8365     if (parents == undefined)
8366       parents = [];
8367     let new_parents = parents.slice();
8368     new_parents.push(this);
8369     var await_keyword = this.await_keyword.rewrite(rewriter, new_parents);
8370     var using_keyword = this.using_keyword.rewrite(rewriter, new_parents);
8371     var expression = this.expression.rewrite(rewriter, new_parents);
8372     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
8373     if (
8374       await_keyword === this.await_keyword &&
8375       using_keyword === this.using_keyword &&
8376       expression === this.expression &&
8377       semicolon === this.semicolon)
8378     {
8379       return rewriter(this, parents);
8380     }
8381     else
8382     {
8383       return rewriter(new UsingStatementFunctionScoped(
8384         await_keyword,
8385         using_keyword,
8386         expression,
8387         semicolon), parents);
8388     }
8389   }
8390   static from_json(json, position, source)
8391   {
8392     let await_keyword = EditableSyntax.from_json(
8393       json.using_function_await_keyword, position, source);
8394     position += await_keyword.width;
8395     let using_keyword = EditableSyntax.from_json(
8396       json.using_function_using_keyword, position, source);
8397     position += using_keyword.width;
8398     let expression = EditableSyntax.from_json(
8399       json.using_function_expression, position, source);
8400     position += expression.width;
8401     let semicolon = EditableSyntax.from_json(
8402       json.using_function_semicolon, position, source);
8403     position += semicolon.width;
8404     return new UsingStatementFunctionScoped(
8405         await_keyword,
8406         using_keyword,
8407         expression,
8408         semicolon);
8409   }
8410   get children_keys()
8411   {
8412     if (UsingStatementFunctionScoped._children_keys == null)
8413       UsingStatementFunctionScoped._children_keys = [
8414         'await_keyword',
8415         'using_keyword',
8416         'expression',
8417         'semicolon'];
8418     return UsingStatementFunctionScoped._children_keys;
8419   }
8420 }
8421 class DeclareDirectiveStatement extends EditableSyntax
8422 {
8423   constructor(
8424     keyword,
8425     left_paren,
8426     expression,
8427     right_paren,
8428     semicolon)
8429   {
8430     super('declare_directive_statement', {
8431       keyword: keyword,
8432       left_paren: left_paren,
8433       expression: expression,
8434       right_paren: right_paren,
8435       semicolon: semicolon });
8436   }
8437   get keyword() { return this.children.keyword; }
8438   get left_paren() { return this.children.left_paren; }
8439   get expression() { return this.children.expression; }
8440   get right_paren() { return this.children.right_paren; }
8441   get semicolon() { return this.children.semicolon; }
8442   with_keyword(keyword){
8443     return new DeclareDirectiveStatement(
8444       keyword,
8445       this.left_paren,
8446       this.expression,
8447       this.right_paren,
8448       this.semicolon);
8449   }
8450   with_left_paren(left_paren){
8451     return new DeclareDirectiveStatement(
8452       this.keyword,
8453       left_paren,
8454       this.expression,
8455       this.right_paren,
8456       this.semicolon);
8457   }
8458   with_expression(expression){
8459     return new DeclareDirectiveStatement(
8460       this.keyword,
8461       this.left_paren,
8462       expression,
8463       this.right_paren,
8464       this.semicolon);
8465   }
8466   with_right_paren(right_paren){
8467     return new DeclareDirectiveStatement(
8468       this.keyword,
8469       this.left_paren,
8470       this.expression,
8471       right_paren,
8472       this.semicolon);
8473   }
8474   with_semicolon(semicolon){
8475     return new DeclareDirectiveStatement(
8476       this.keyword,
8477       this.left_paren,
8478       this.expression,
8479       this.right_paren,
8480       semicolon);
8481   }
8482   rewrite(rewriter, parents)
8483   {
8484     if (parents == undefined)
8485       parents = [];
8486     let new_parents = parents.slice();
8487     new_parents.push(this);
8488     var keyword = this.keyword.rewrite(rewriter, new_parents);
8489     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
8490     var expression = this.expression.rewrite(rewriter, new_parents);
8491     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
8492     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
8493     if (
8494       keyword === this.keyword &&
8495       left_paren === this.left_paren &&
8496       expression === this.expression &&
8497       right_paren === this.right_paren &&
8498       semicolon === this.semicolon)
8499     {
8500       return rewriter(this, parents);
8501     }
8502     else
8503     {
8504       return rewriter(new DeclareDirectiveStatement(
8505         keyword,
8506         left_paren,
8507         expression,
8508         right_paren,
8509         semicolon), parents);
8510     }
8511   }
8512   static from_json(json, position, source)
8513   {
8514     let keyword = EditableSyntax.from_json(
8515       json.declare_directive_keyword, position, source);
8516     position += keyword.width;
8517     let left_paren = EditableSyntax.from_json(
8518       json.declare_directive_left_paren, position, source);
8519     position += left_paren.width;
8520     let expression = EditableSyntax.from_json(
8521       json.declare_directive_expression, position, source);
8522     position += expression.width;
8523     let right_paren = EditableSyntax.from_json(
8524       json.declare_directive_right_paren, position, source);
8525     position += right_paren.width;
8526     let semicolon = EditableSyntax.from_json(
8527       json.declare_directive_semicolon, position, source);
8528     position += semicolon.width;
8529     return new DeclareDirectiveStatement(
8530         keyword,
8531         left_paren,
8532         expression,
8533         right_paren,
8534         semicolon);
8535   }
8536   get children_keys()
8537   {
8538     if (DeclareDirectiveStatement._children_keys == null)
8539       DeclareDirectiveStatement._children_keys = [
8540         'keyword',
8541         'left_paren',
8542         'expression',
8543         'right_paren',
8544         'semicolon'];
8545     return DeclareDirectiveStatement._children_keys;
8546   }
8547 }
8548 class DeclareBlockStatement extends EditableSyntax
8549 {
8550   constructor(
8551     keyword,
8552     left_paren,
8553     expression,
8554     right_paren,
8555     body)
8556   {
8557     super('declare_block_statement', {
8558       keyword: keyword,
8559       left_paren: left_paren,
8560       expression: expression,
8561       right_paren: right_paren,
8562       body: body });
8563   }
8564   get keyword() { return this.children.keyword; }
8565   get left_paren() { return this.children.left_paren; }
8566   get expression() { return this.children.expression; }
8567   get right_paren() { return this.children.right_paren; }
8568   get body() { return this.children.body; }
8569   with_keyword(keyword){
8570     return new DeclareBlockStatement(
8571       keyword,
8572       this.left_paren,
8573       this.expression,
8574       this.right_paren,
8575       this.body);
8576   }
8577   with_left_paren(left_paren){
8578     return new DeclareBlockStatement(
8579       this.keyword,
8580       left_paren,
8581       this.expression,
8582       this.right_paren,
8583       this.body);
8584   }
8585   with_expression(expression){
8586     return new DeclareBlockStatement(
8587       this.keyword,
8588       this.left_paren,
8589       expression,
8590       this.right_paren,
8591       this.body);
8592   }
8593   with_right_paren(right_paren){
8594     return new DeclareBlockStatement(
8595       this.keyword,
8596       this.left_paren,
8597       this.expression,
8598       right_paren,
8599       this.body);
8600   }
8601   with_body(body){
8602     return new DeclareBlockStatement(
8603       this.keyword,
8604       this.left_paren,
8605       this.expression,
8606       this.right_paren,
8607       body);
8608   }
8609   rewrite(rewriter, parents)
8610   {
8611     if (parents == undefined)
8612       parents = [];
8613     let new_parents = parents.slice();
8614     new_parents.push(this);
8615     var keyword = this.keyword.rewrite(rewriter, new_parents);
8616     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
8617     var expression = this.expression.rewrite(rewriter, new_parents);
8618     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
8619     var body = this.body.rewrite(rewriter, new_parents);
8620     if (
8621       keyword === this.keyword &&
8622       left_paren === this.left_paren &&
8623       expression === this.expression &&
8624       right_paren === this.right_paren &&
8625       body === this.body)
8626     {
8627       return rewriter(this, parents);
8628     }
8629     else
8630     {
8631       return rewriter(new DeclareBlockStatement(
8632         keyword,
8633         left_paren,
8634         expression,
8635         right_paren,
8636         body), parents);
8637     }
8638   }
8639   static from_json(json, position, source)
8640   {
8641     let keyword = EditableSyntax.from_json(
8642       json.declare_block_keyword, position, source);
8643     position += keyword.width;
8644     let left_paren = EditableSyntax.from_json(
8645       json.declare_block_left_paren, position, source);
8646     position += left_paren.width;
8647     let expression = EditableSyntax.from_json(
8648       json.declare_block_expression, position, source);
8649     position += expression.width;
8650     let right_paren = EditableSyntax.from_json(
8651       json.declare_block_right_paren, position, source);
8652     position += right_paren.width;
8653     let body = EditableSyntax.from_json(
8654       json.declare_block_body, position, source);
8655     position += body.width;
8656     return new DeclareBlockStatement(
8657         keyword,
8658         left_paren,
8659         expression,
8660         right_paren,
8661         body);
8662   }
8663   get children_keys()
8664   {
8665     if (DeclareBlockStatement._children_keys == null)
8666       DeclareBlockStatement._children_keys = [
8667         'keyword',
8668         'left_paren',
8669         'expression',
8670         'right_paren',
8671         'body'];
8672     return DeclareBlockStatement._children_keys;
8673   }
8674 }
8675 class WhileStatement extends EditableSyntax
8676 {
8677   constructor(
8678     keyword,
8679     left_paren,
8680     condition,
8681     right_paren,
8682     body)
8683   {
8684     super('while_statement', {
8685       keyword: keyword,
8686       left_paren: left_paren,
8687       condition: condition,
8688       right_paren: right_paren,
8689       body: body });
8690   }
8691   get keyword() { return this.children.keyword; }
8692   get left_paren() { return this.children.left_paren; }
8693   get condition() { return this.children.condition; }
8694   get right_paren() { return this.children.right_paren; }
8695   get body() { return this.children.body; }
8696   with_keyword(keyword){
8697     return new WhileStatement(
8698       keyword,
8699       this.left_paren,
8700       this.condition,
8701       this.right_paren,
8702       this.body);
8703   }
8704   with_left_paren(left_paren){
8705     return new WhileStatement(
8706       this.keyword,
8707       left_paren,
8708       this.condition,
8709       this.right_paren,
8710       this.body);
8711   }
8712   with_condition(condition){
8713     return new WhileStatement(
8714       this.keyword,
8715       this.left_paren,
8716       condition,
8717       this.right_paren,
8718       this.body);
8719   }
8720   with_right_paren(right_paren){
8721     return new WhileStatement(
8722       this.keyword,
8723       this.left_paren,
8724       this.condition,
8725       right_paren,
8726       this.body);
8727   }
8728   with_body(body){
8729     return new WhileStatement(
8730       this.keyword,
8731       this.left_paren,
8732       this.condition,
8733       this.right_paren,
8734       body);
8735   }
8736   rewrite(rewriter, parents)
8737   {
8738     if (parents == undefined)
8739       parents = [];
8740     let new_parents = parents.slice();
8741     new_parents.push(this);
8742     var keyword = this.keyword.rewrite(rewriter, new_parents);
8743     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
8744     var condition = this.condition.rewrite(rewriter, new_parents);
8745     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
8746     var body = this.body.rewrite(rewriter, new_parents);
8747     if (
8748       keyword === this.keyword &&
8749       left_paren === this.left_paren &&
8750       condition === this.condition &&
8751       right_paren === this.right_paren &&
8752       body === this.body)
8753     {
8754       return rewriter(this, parents);
8755     }
8756     else
8757     {
8758       return rewriter(new WhileStatement(
8759         keyword,
8760         left_paren,
8761         condition,
8762         right_paren,
8763         body), parents);
8764     }
8765   }
8766   static from_json(json, position, source)
8767   {
8768     let keyword = EditableSyntax.from_json(
8769       json.while_keyword, position, source);
8770     position += keyword.width;
8771     let left_paren = EditableSyntax.from_json(
8772       json.while_left_paren, position, source);
8773     position += left_paren.width;
8774     let condition = EditableSyntax.from_json(
8775       json.while_condition, position, source);
8776     position += condition.width;
8777     let right_paren = EditableSyntax.from_json(
8778       json.while_right_paren, position, source);
8779     position += right_paren.width;
8780     let body = EditableSyntax.from_json(
8781       json.while_body, position, source);
8782     position += body.width;
8783     return new WhileStatement(
8784         keyword,
8785         left_paren,
8786         condition,
8787         right_paren,
8788         body);
8789   }
8790   get children_keys()
8791   {
8792     if (WhileStatement._children_keys == null)
8793       WhileStatement._children_keys = [
8794         'keyword',
8795         'left_paren',
8796         'condition',
8797         'right_paren',
8798         'body'];
8799     return WhileStatement._children_keys;
8800   }
8801 }
8802 class IfStatement extends EditableSyntax
8803 {
8804   constructor(
8805     keyword,
8806     left_paren,
8807     condition,
8808     right_paren,
8809     statement,
8810     elseif_clauses,
8811     else_clause)
8812   {
8813     super('if_statement', {
8814       keyword: keyword,
8815       left_paren: left_paren,
8816       condition: condition,
8817       right_paren: right_paren,
8818       statement: statement,
8819       elseif_clauses: elseif_clauses,
8820       else_clause: else_clause });
8821   }
8822   get keyword() { return this.children.keyword; }
8823   get left_paren() { return this.children.left_paren; }
8824   get condition() { return this.children.condition; }
8825   get right_paren() { return this.children.right_paren; }
8826   get statement() { return this.children.statement; }
8827   get elseif_clauses() { return this.children.elseif_clauses; }
8828   get else_clause() { return this.children.else_clause; }
8829   with_keyword(keyword){
8830     return new IfStatement(
8831       keyword,
8832       this.left_paren,
8833       this.condition,
8834       this.right_paren,
8835       this.statement,
8836       this.elseif_clauses,
8837       this.else_clause);
8838   }
8839   with_left_paren(left_paren){
8840     return new IfStatement(
8841       this.keyword,
8842       left_paren,
8843       this.condition,
8844       this.right_paren,
8845       this.statement,
8846       this.elseif_clauses,
8847       this.else_clause);
8848   }
8849   with_condition(condition){
8850     return new IfStatement(
8851       this.keyword,
8852       this.left_paren,
8853       condition,
8854       this.right_paren,
8855       this.statement,
8856       this.elseif_clauses,
8857       this.else_clause);
8858   }
8859   with_right_paren(right_paren){
8860     return new IfStatement(
8861       this.keyword,
8862       this.left_paren,
8863       this.condition,
8864       right_paren,
8865       this.statement,
8866       this.elseif_clauses,
8867       this.else_clause);
8868   }
8869   with_statement(statement){
8870     return new IfStatement(
8871       this.keyword,
8872       this.left_paren,
8873       this.condition,
8874       this.right_paren,
8875       statement,
8876       this.elseif_clauses,
8877       this.else_clause);
8878   }
8879   with_elseif_clauses(elseif_clauses){
8880     return new IfStatement(
8881       this.keyword,
8882       this.left_paren,
8883       this.condition,
8884       this.right_paren,
8885       this.statement,
8886       elseif_clauses,
8887       this.else_clause);
8888   }
8889   with_else_clause(else_clause){
8890     return new IfStatement(
8891       this.keyword,
8892       this.left_paren,
8893       this.condition,
8894       this.right_paren,
8895       this.statement,
8896       this.elseif_clauses,
8897       else_clause);
8898   }
8899   rewrite(rewriter, parents)
8900   {
8901     if (parents == undefined)
8902       parents = [];
8903     let new_parents = parents.slice();
8904     new_parents.push(this);
8905     var keyword = this.keyword.rewrite(rewriter, new_parents);
8906     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
8907     var condition = this.condition.rewrite(rewriter, new_parents);
8908     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
8909     var statement = this.statement.rewrite(rewriter, new_parents);
8910     var elseif_clauses = this.elseif_clauses.rewrite(rewriter, new_parents);
8911     var else_clause = this.else_clause.rewrite(rewriter, new_parents);
8912     if (
8913       keyword === this.keyword &&
8914       left_paren === this.left_paren &&
8915       condition === this.condition &&
8916       right_paren === this.right_paren &&
8917       statement === this.statement &&
8918       elseif_clauses === this.elseif_clauses &&
8919       else_clause === this.else_clause)
8920     {
8921       return rewriter(this, parents);
8922     }
8923     else
8924     {
8925       return rewriter(new IfStatement(
8926         keyword,
8927         left_paren,
8928         condition,
8929         right_paren,
8930         statement,
8931         elseif_clauses,
8932         else_clause), parents);
8933     }
8934   }
8935   static from_json(json, position, source)
8936   {
8937     let keyword = EditableSyntax.from_json(
8938       json.if_keyword, position, source);
8939     position += keyword.width;
8940     let left_paren = EditableSyntax.from_json(
8941       json.if_left_paren, position, source);
8942     position += left_paren.width;
8943     let condition = EditableSyntax.from_json(
8944       json.if_condition, position, source);
8945     position += condition.width;
8946     let right_paren = EditableSyntax.from_json(
8947       json.if_right_paren, position, source);
8948     position += right_paren.width;
8949     let statement = EditableSyntax.from_json(
8950       json.if_statement, position, source);
8951     position += statement.width;
8952     let elseif_clauses = EditableSyntax.from_json(
8953       json.if_elseif_clauses, position, source);
8954     position += elseif_clauses.width;
8955     let else_clause = EditableSyntax.from_json(
8956       json.if_else_clause, position, source);
8957     position += else_clause.width;
8958     return new IfStatement(
8959         keyword,
8960         left_paren,
8961         condition,
8962         right_paren,
8963         statement,
8964         elseif_clauses,
8965         else_clause);
8966   }
8967   get children_keys()
8968   {
8969     if (IfStatement._children_keys == null)
8970       IfStatement._children_keys = [
8971         'keyword',
8972         'left_paren',
8973         'condition',
8974         'right_paren',
8975         'statement',
8976         'elseif_clauses',
8977         'else_clause'];
8978     return IfStatement._children_keys;
8979   }
8980 }
8981 class ElseifClause extends EditableSyntax
8982 {
8983   constructor(
8984     keyword,
8985     left_paren,
8986     condition,
8987     right_paren,
8988     statement)
8989   {
8990     super('elseif_clause', {
8991       keyword: keyword,
8992       left_paren: left_paren,
8993       condition: condition,
8994       right_paren: right_paren,
8995       statement: statement });
8996   }
8997   get keyword() { return this.children.keyword; }
8998   get left_paren() { return this.children.left_paren; }
8999   get condition() { return this.children.condition; }
9000   get right_paren() { return this.children.right_paren; }
9001   get statement() { return this.children.statement; }
9002   with_keyword(keyword){
9003     return new ElseifClause(
9004       keyword,
9005       this.left_paren,
9006       this.condition,
9007       this.right_paren,
9008       this.statement);
9009   }
9010   with_left_paren(left_paren){
9011     return new ElseifClause(
9012       this.keyword,
9013       left_paren,
9014       this.condition,
9015       this.right_paren,
9016       this.statement);
9017   }
9018   with_condition(condition){
9019     return new ElseifClause(
9020       this.keyword,
9021       this.left_paren,
9022       condition,
9023       this.right_paren,
9024       this.statement);
9025   }
9026   with_right_paren(right_paren){
9027     return new ElseifClause(
9028       this.keyword,
9029       this.left_paren,
9030       this.condition,
9031       right_paren,
9032       this.statement);
9033   }
9034   with_statement(statement){
9035     return new ElseifClause(
9036       this.keyword,
9037       this.left_paren,
9038       this.condition,
9039       this.right_paren,
9040       statement);
9041   }
9042   rewrite(rewriter, parents)
9043   {
9044     if (parents == undefined)
9045       parents = [];
9046     let new_parents = parents.slice();
9047     new_parents.push(this);
9048     var keyword = this.keyword.rewrite(rewriter, new_parents);
9049     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
9050     var condition = this.condition.rewrite(rewriter, new_parents);
9051     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
9052     var statement = this.statement.rewrite(rewriter, new_parents);
9053     if (
9054       keyword === this.keyword &&
9055       left_paren === this.left_paren &&
9056       condition === this.condition &&
9057       right_paren === this.right_paren &&
9058       statement === this.statement)
9059     {
9060       return rewriter(this, parents);
9061     }
9062     else
9063     {
9064       return rewriter(new ElseifClause(
9065         keyword,
9066         left_paren,
9067         condition,
9068         right_paren,
9069         statement), parents);
9070     }
9071   }
9072   static from_json(json, position, source)
9073   {
9074     let keyword = EditableSyntax.from_json(
9075       json.elseif_keyword, position, source);
9076     position += keyword.width;
9077     let left_paren = EditableSyntax.from_json(
9078       json.elseif_left_paren, position, source);
9079     position += left_paren.width;
9080     let condition = EditableSyntax.from_json(
9081       json.elseif_condition, position, source);
9082     position += condition.width;
9083     let right_paren = EditableSyntax.from_json(
9084       json.elseif_right_paren, position, source);
9085     position += right_paren.width;
9086     let statement = EditableSyntax.from_json(
9087       json.elseif_statement, position, source);
9088     position += statement.width;
9089     return new ElseifClause(
9090         keyword,
9091         left_paren,
9092         condition,
9093         right_paren,
9094         statement);
9095   }
9096   get children_keys()
9097   {
9098     if (ElseifClause._children_keys == null)
9099       ElseifClause._children_keys = [
9100         'keyword',
9101         'left_paren',
9102         'condition',
9103         'right_paren',
9104         'statement'];
9105     return ElseifClause._children_keys;
9106   }
9107 }
9108 class ElseClause extends EditableSyntax
9109 {
9110   constructor(
9111     keyword,
9112     statement)
9113   {
9114     super('else_clause', {
9115       keyword: keyword,
9116       statement: statement });
9117   }
9118   get keyword() { return this.children.keyword; }
9119   get statement() { return this.children.statement; }
9120   with_keyword(keyword){
9121     return new ElseClause(
9122       keyword,
9123       this.statement);
9124   }
9125   with_statement(statement){
9126     return new ElseClause(
9127       this.keyword,
9128       statement);
9129   }
9130   rewrite(rewriter, parents)
9131   {
9132     if (parents == undefined)
9133       parents = [];
9134     let new_parents = parents.slice();
9135     new_parents.push(this);
9136     var keyword = this.keyword.rewrite(rewriter, new_parents);
9137     var statement = this.statement.rewrite(rewriter, new_parents);
9138     if (
9139       keyword === this.keyword &&
9140       statement === this.statement)
9141     {
9142       return rewriter(this, parents);
9143     }
9144     else
9145     {
9146       return rewriter(new ElseClause(
9147         keyword,
9148         statement), parents);
9149     }
9150   }
9151   static from_json(json, position, source)
9152   {
9153     let keyword = EditableSyntax.from_json(
9154       json.else_keyword, position, source);
9155     position += keyword.width;
9156     let statement = EditableSyntax.from_json(
9157       json.else_statement, position, source);
9158     position += statement.width;
9159     return new ElseClause(
9160         keyword,
9161         statement);
9162   }
9163   get children_keys()
9164   {
9165     if (ElseClause._children_keys == null)
9166       ElseClause._children_keys = [
9167         'keyword',
9168         'statement'];
9169     return ElseClause._children_keys;
9170   }
9171 }
9172 class AlternateIfStatement extends EditableSyntax
9173 {
9174   constructor(
9175     keyword,
9176     left_paren,
9177     condition,
9178     right_paren,
9179     colon,
9180     statement,
9181     elseif_clauses,
9182     else_clause,
9183     endif_keyword,
9184     semicolon)
9185   {
9186     super('alternate_if_statement', {
9187       keyword: keyword,
9188       left_paren: left_paren,
9189       condition: condition,
9190       right_paren: right_paren,
9191       colon: colon,
9192       statement: statement,
9193       elseif_clauses: elseif_clauses,
9194       else_clause: else_clause,
9195       endif_keyword: endif_keyword,
9196       semicolon: semicolon });
9197   }
9198   get keyword() { return this.children.keyword; }
9199   get left_paren() { return this.children.left_paren; }
9200   get condition() { return this.children.condition; }
9201   get right_paren() { return this.children.right_paren; }
9202   get colon() { return this.children.colon; }
9203   get statement() { return this.children.statement; }
9204   get elseif_clauses() { return this.children.elseif_clauses; }
9205   get else_clause() { return this.children.else_clause; }
9206   get endif_keyword() { return this.children.endif_keyword; }
9207   get semicolon() { return this.children.semicolon; }
9208   with_keyword(keyword){
9209     return new AlternateIfStatement(
9210       keyword,
9211       this.left_paren,
9212       this.condition,
9213       this.right_paren,
9214       this.colon,
9215       this.statement,
9216       this.elseif_clauses,
9217       this.else_clause,
9218       this.endif_keyword,
9219       this.semicolon);
9220   }
9221   with_left_paren(left_paren){
9222     return new AlternateIfStatement(
9223       this.keyword,
9224       left_paren,
9225       this.condition,
9226       this.right_paren,
9227       this.colon,
9228       this.statement,
9229       this.elseif_clauses,
9230       this.else_clause,
9231       this.endif_keyword,
9232       this.semicolon);
9233   }
9234   with_condition(condition){
9235     return new AlternateIfStatement(
9236       this.keyword,
9237       this.left_paren,
9238       condition,
9239       this.right_paren,
9240       this.colon,
9241       this.statement,
9242       this.elseif_clauses,
9243       this.else_clause,
9244       this.endif_keyword,
9245       this.semicolon);
9246   }
9247   with_right_paren(right_paren){
9248     return new AlternateIfStatement(
9249       this.keyword,
9250       this.left_paren,
9251       this.condition,
9252       right_paren,
9253       this.colon,
9254       this.statement,
9255       this.elseif_clauses,
9256       this.else_clause,
9257       this.endif_keyword,
9258       this.semicolon);
9259   }
9260   with_colon(colon){
9261     return new AlternateIfStatement(
9262       this.keyword,
9263       this.left_paren,
9264       this.condition,
9265       this.right_paren,
9266       colon,
9267       this.statement,
9268       this.elseif_clauses,
9269       this.else_clause,
9270       this.endif_keyword,
9271       this.semicolon);
9272   }
9273   with_statement(statement){
9274     return new AlternateIfStatement(
9275       this.keyword,
9276       this.left_paren,
9277       this.condition,
9278       this.right_paren,
9279       this.colon,
9280       statement,
9281       this.elseif_clauses,
9282       this.else_clause,
9283       this.endif_keyword,
9284       this.semicolon);
9285   }
9286   with_elseif_clauses(elseif_clauses){
9287     return new AlternateIfStatement(
9288       this.keyword,
9289       this.left_paren,
9290       this.condition,
9291       this.right_paren,
9292       this.colon,
9293       this.statement,
9294       elseif_clauses,
9295       this.else_clause,
9296       this.endif_keyword,
9297       this.semicolon);
9298   }
9299   with_else_clause(else_clause){
9300     return new AlternateIfStatement(
9301       this.keyword,
9302       this.left_paren,
9303       this.condition,
9304       this.right_paren,
9305       this.colon,
9306       this.statement,
9307       this.elseif_clauses,
9308       else_clause,
9309       this.endif_keyword,
9310       this.semicolon);
9311   }
9312   with_endif_keyword(endif_keyword){
9313     return new AlternateIfStatement(
9314       this.keyword,
9315       this.left_paren,
9316       this.condition,
9317       this.right_paren,
9318       this.colon,
9319       this.statement,
9320       this.elseif_clauses,
9321       this.else_clause,
9322       endif_keyword,
9323       this.semicolon);
9324   }
9325   with_semicolon(semicolon){
9326     return new AlternateIfStatement(
9327       this.keyword,
9328       this.left_paren,
9329       this.condition,
9330       this.right_paren,
9331       this.colon,
9332       this.statement,
9333       this.elseif_clauses,
9334       this.else_clause,
9335       this.endif_keyword,
9336       semicolon);
9337   }
9338   rewrite(rewriter, parents)
9339   {
9340     if (parents == undefined)
9341       parents = [];
9342     let new_parents = parents.slice();
9343     new_parents.push(this);
9344     var keyword = this.keyword.rewrite(rewriter, new_parents);
9345     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
9346     var condition = this.condition.rewrite(rewriter, new_parents);
9347     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
9348     var colon = this.colon.rewrite(rewriter, new_parents);
9349     var statement = this.statement.rewrite(rewriter, new_parents);
9350     var elseif_clauses = this.elseif_clauses.rewrite(rewriter, new_parents);
9351     var else_clause = this.else_clause.rewrite(rewriter, new_parents);
9352     var endif_keyword = this.endif_keyword.rewrite(rewriter, new_parents);
9353     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
9354     if (
9355       keyword === this.keyword &&
9356       left_paren === this.left_paren &&
9357       condition === this.condition &&
9358       right_paren === this.right_paren &&
9359       colon === this.colon &&
9360       statement === this.statement &&
9361       elseif_clauses === this.elseif_clauses &&
9362       else_clause === this.else_clause &&
9363       endif_keyword === this.endif_keyword &&
9364       semicolon === this.semicolon)
9365     {
9366       return rewriter(this, parents);
9367     }
9368     else
9369     {
9370       return rewriter(new AlternateIfStatement(
9371         keyword,
9372         left_paren,
9373         condition,
9374         right_paren,
9375         colon,
9376         statement,
9377         elseif_clauses,
9378         else_clause,
9379         endif_keyword,
9380         semicolon), parents);
9381     }
9382   }
9383   static from_json(json, position, source)
9384   {
9385     let keyword = EditableSyntax.from_json(
9386       json.alternate_if_keyword, position, source);
9387     position += keyword.width;
9388     let left_paren = EditableSyntax.from_json(
9389       json.alternate_if_left_paren, position, source);
9390     position += left_paren.width;
9391     let condition = EditableSyntax.from_json(
9392       json.alternate_if_condition, position, source);
9393     position += condition.width;
9394     let right_paren = EditableSyntax.from_json(
9395       json.alternate_if_right_paren, position, source);
9396     position += right_paren.width;
9397     let colon = EditableSyntax.from_json(
9398       json.alternate_if_colon, position, source);
9399     position += colon.width;
9400     let statement = EditableSyntax.from_json(
9401       json.alternate_if_statement, position, source);
9402     position += statement.width;
9403     let elseif_clauses = EditableSyntax.from_json(
9404       json.alternate_if_elseif_clauses, position, source);
9405     position += elseif_clauses.width;
9406     let else_clause = EditableSyntax.from_json(
9407       json.alternate_if_else_clause, position, source);
9408     position += else_clause.width;
9409     let endif_keyword = EditableSyntax.from_json(
9410       json.alternate_if_endif_keyword, position, source);
9411     position += endif_keyword.width;
9412     let semicolon = EditableSyntax.from_json(
9413       json.alternate_if_semicolon, position, source);
9414     position += semicolon.width;
9415     return new AlternateIfStatement(
9416         keyword,
9417         left_paren,
9418         condition,
9419         right_paren,
9420         colon,
9421         statement,
9422         elseif_clauses,
9423         else_clause,
9424         endif_keyword,
9425         semicolon);
9426   }
9427   get children_keys()
9428   {
9429     if (AlternateIfStatement._children_keys == null)
9430       AlternateIfStatement._children_keys = [
9431         'keyword',
9432         'left_paren',
9433         'condition',
9434         'right_paren',
9435         'colon',
9436         'statement',
9437         'elseif_clauses',
9438         'else_clause',
9439         'endif_keyword',
9440         'semicolon'];
9441     return AlternateIfStatement._children_keys;
9442   }
9443 }
9444 class AlternateElseifClause extends EditableSyntax
9445 {
9446   constructor(
9447     keyword,
9448     left_paren,
9449     condition,
9450     right_paren,
9451     colon,
9452     statement)
9453   {
9454     super('alternate_elseif_clause', {
9455       keyword: keyword,
9456       left_paren: left_paren,
9457       condition: condition,
9458       right_paren: right_paren,
9459       colon: colon,
9460       statement: statement });
9461   }
9462   get keyword() { return this.children.keyword; }
9463   get left_paren() { return this.children.left_paren; }
9464   get condition() { return this.children.condition; }
9465   get right_paren() { return this.children.right_paren; }
9466   get colon() { return this.children.colon; }
9467   get statement() { return this.children.statement; }
9468   with_keyword(keyword){
9469     return new AlternateElseifClause(
9470       keyword,
9471       this.left_paren,
9472       this.condition,
9473       this.right_paren,
9474       this.colon,
9475       this.statement);
9476   }
9477   with_left_paren(left_paren){
9478     return new AlternateElseifClause(
9479       this.keyword,
9480       left_paren,
9481       this.condition,
9482       this.right_paren,
9483       this.colon,
9484       this.statement);
9485   }
9486   with_condition(condition){
9487     return new AlternateElseifClause(
9488       this.keyword,
9489       this.left_paren,
9490       condition,
9491       this.right_paren,
9492       this.colon,
9493       this.statement);
9494   }
9495   with_right_paren(right_paren){
9496     return new AlternateElseifClause(
9497       this.keyword,
9498       this.left_paren,
9499       this.condition,
9500       right_paren,
9501       this.colon,
9502       this.statement);
9503   }
9504   with_colon(colon){
9505     return new AlternateElseifClause(
9506       this.keyword,
9507       this.left_paren,
9508       this.condition,
9509       this.right_paren,
9510       colon,
9511       this.statement);
9512   }
9513   with_statement(statement){
9514     return new AlternateElseifClause(
9515       this.keyword,
9516       this.left_paren,
9517       this.condition,
9518       this.right_paren,
9519       this.colon,
9520       statement);
9521   }
9522   rewrite(rewriter, parents)
9523   {
9524     if (parents == undefined)
9525       parents = [];
9526     let new_parents = parents.slice();
9527     new_parents.push(this);
9528     var keyword = this.keyword.rewrite(rewriter, new_parents);
9529     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
9530     var condition = this.condition.rewrite(rewriter, new_parents);
9531     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
9532     var colon = this.colon.rewrite(rewriter, new_parents);
9533     var statement = this.statement.rewrite(rewriter, new_parents);
9534     if (
9535       keyword === this.keyword &&
9536       left_paren === this.left_paren &&
9537       condition === this.condition &&
9538       right_paren === this.right_paren &&
9539       colon === this.colon &&
9540       statement === this.statement)
9541     {
9542       return rewriter(this, parents);
9543     }
9544     else
9545     {
9546       return rewriter(new AlternateElseifClause(
9547         keyword,
9548         left_paren,
9549         condition,
9550         right_paren,
9551         colon,
9552         statement), parents);
9553     }
9554   }
9555   static from_json(json, position, source)
9556   {
9557     let keyword = EditableSyntax.from_json(
9558       json.alternate_elseif_keyword, position, source);
9559     position += keyword.width;
9560     let left_paren = EditableSyntax.from_json(
9561       json.alternate_elseif_left_paren, position, source);
9562     position += left_paren.width;
9563     let condition = EditableSyntax.from_json(
9564       json.alternate_elseif_condition, position, source);
9565     position += condition.width;
9566     let right_paren = EditableSyntax.from_json(
9567       json.alternate_elseif_right_paren, position, source);
9568     position += right_paren.width;
9569     let colon = EditableSyntax.from_json(
9570       json.alternate_elseif_colon, position, source);
9571     position += colon.width;
9572     let statement = EditableSyntax.from_json(
9573       json.alternate_elseif_statement, position, source);
9574     position += statement.width;
9575     return new AlternateElseifClause(
9576         keyword,
9577         left_paren,
9578         condition,
9579         right_paren,
9580         colon,
9581         statement);
9582   }
9583   get children_keys()
9584   {
9585     if (AlternateElseifClause._children_keys == null)
9586       AlternateElseifClause._children_keys = [
9587         'keyword',
9588         'left_paren',
9589         'condition',
9590         'right_paren',
9591         'colon',
9592         'statement'];
9593     return AlternateElseifClause._children_keys;
9594   }
9595 }
9596 class AlternateElseClause extends EditableSyntax
9597 {
9598   constructor(
9599     keyword,
9600     colon,
9601     statement)
9602   {
9603     super('alternate_else_clause', {
9604       keyword: keyword,
9605       colon: colon,
9606       statement: statement });
9607   }
9608   get keyword() { return this.children.keyword; }
9609   get colon() { return this.children.colon; }
9610   get statement() { return this.children.statement; }
9611   with_keyword(keyword){
9612     return new AlternateElseClause(
9613       keyword,
9614       this.colon,
9615       this.statement);
9616   }
9617   with_colon(colon){
9618     return new AlternateElseClause(
9619       this.keyword,
9620       colon,
9621       this.statement);
9622   }
9623   with_statement(statement){
9624     return new AlternateElseClause(
9625       this.keyword,
9626       this.colon,
9627       statement);
9628   }
9629   rewrite(rewriter, parents)
9630   {
9631     if (parents == undefined)
9632       parents = [];
9633     let new_parents = parents.slice();
9634     new_parents.push(this);
9635     var keyword = this.keyword.rewrite(rewriter, new_parents);
9636     var colon = this.colon.rewrite(rewriter, new_parents);
9637     var statement = this.statement.rewrite(rewriter, new_parents);
9638     if (
9639       keyword === this.keyword &&
9640       colon === this.colon &&
9641       statement === this.statement)
9642     {
9643       return rewriter(this, parents);
9644     }
9645     else
9646     {
9647       return rewriter(new AlternateElseClause(
9648         keyword,
9649         colon,
9650         statement), parents);
9651     }
9652   }
9653   static from_json(json, position, source)
9654   {
9655     let keyword = EditableSyntax.from_json(
9656       json.alternate_else_keyword, position, source);
9657     position += keyword.width;
9658     let colon = EditableSyntax.from_json(
9659       json.alternate_else_colon, position, source);
9660     position += colon.width;
9661     let statement = EditableSyntax.from_json(
9662       json.alternate_else_statement, position, source);
9663     position += statement.width;
9664     return new AlternateElseClause(
9665         keyword,
9666         colon,
9667         statement);
9668   }
9669   get children_keys()
9670   {
9671     if (AlternateElseClause._children_keys == null)
9672       AlternateElseClause._children_keys = [
9673         'keyword',
9674         'colon',
9675         'statement'];
9676     return AlternateElseClause._children_keys;
9677   }
9678 }
9679 class TryStatement extends EditableSyntax
9680 {
9681   constructor(
9682     keyword,
9683     compound_statement,
9684     catch_clauses,
9685     finally_clause)
9686   {
9687     super('try_statement', {
9688       keyword: keyword,
9689       compound_statement: compound_statement,
9690       catch_clauses: catch_clauses,
9691       finally_clause: finally_clause });
9692   }
9693   get keyword() { return this.children.keyword; }
9694   get compound_statement() { return this.children.compound_statement; }
9695   get catch_clauses() { return this.children.catch_clauses; }
9696   get finally_clause() { return this.children.finally_clause; }
9697   with_keyword(keyword){
9698     return new TryStatement(
9699       keyword,
9700       this.compound_statement,
9701       this.catch_clauses,
9702       this.finally_clause);
9703   }
9704   with_compound_statement(compound_statement){
9705     return new TryStatement(
9706       this.keyword,
9707       compound_statement,
9708       this.catch_clauses,
9709       this.finally_clause);
9710   }
9711   with_catch_clauses(catch_clauses){
9712     return new TryStatement(
9713       this.keyword,
9714       this.compound_statement,
9715       catch_clauses,
9716       this.finally_clause);
9717   }
9718   with_finally_clause(finally_clause){
9719     return new TryStatement(
9720       this.keyword,
9721       this.compound_statement,
9722       this.catch_clauses,
9723       finally_clause);
9724   }
9725   rewrite(rewriter, parents)
9726   {
9727     if (parents == undefined)
9728       parents = [];
9729     let new_parents = parents.slice();
9730     new_parents.push(this);
9731     var keyword = this.keyword.rewrite(rewriter, new_parents);
9732     var compound_statement = this.compound_statement.rewrite(rewriter, new_parents);
9733     var catch_clauses = this.catch_clauses.rewrite(rewriter, new_parents);
9734     var finally_clause = this.finally_clause.rewrite(rewriter, new_parents);
9735     if (
9736       keyword === this.keyword &&
9737       compound_statement === this.compound_statement &&
9738       catch_clauses === this.catch_clauses &&
9739       finally_clause === this.finally_clause)
9740     {
9741       return rewriter(this, parents);
9742     }
9743     else
9744     {
9745       return rewriter(new TryStatement(
9746         keyword,
9747         compound_statement,
9748         catch_clauses,
9749         finally_clause), parents);
9750     }
9751   }
9752   static from_json(json, position, source)
9753   {
9754     let keyword = EditableSyntax.from_json(
9755       json.try_keyword, position, source);
9756     position += keyword.width;
9757     let compound_statement = EditableSyntax.from_json(
9758       json.try_compound_statement, position, source);
9759     position += compound_statement.width;
9760     let catch_clauses = EditableSyntax.from_json(
9761       json.try_catch_clauses, position, source);
9762     position += catch_clauses.width;
9763     let finally_clause = EditableSyntax.from_json(
9764       json.try_finally_clause, position, source);
9765     position += finally_clause.width;
9766     return new TryStatement(
9767         keyword,
9768         compound_statement,
9769         catch_clauses,
9770         finally_clause);
9771   }
9772   get children_keys()
9773   {
9774     if (TryStatement._children_keys == null)
9775       TryStatement._children_keys = [
9776         'keyword',
9777         'compound_statement',
9778         'catch_clauses',
9779         'finally_clause'];
9780     return TryStatement._children_keys;
9781   }
9782 }
9783 class CatchClause extends EditableSyntax
9784 {
9785   constructor(
9786     keyword,
9787     left_paren,
9788     type,
9789     variable,
9790     right_paren,
9791     body)
9792   {
9793     super('catch_clause', {
9794       keyword: keyword,
9795       left_paren: left_paren,
9796       type: type,
9797       variable: variable,
9798       right_paren: right_paren,
9799       body: body });
9800   }
9801   get keyword() { return this.children.keyword; }
9802   get left_paren() { return this.children.left_paren; }
9803   get type() { return this.children.type; }
9804   get variable() { return this.children.variable; }
9805   get right_paren() { return this.children.right_paren; }
9806   get body() { return this.children.body; }
9807   with_keyword(keyword){
9808     return new CatchClause(
9809       keyword,
9810       this.left_paren,
9811       this.type,
9812       this.variable,
9813       this.right_paren,
9814       this.body);
9815   }
9816   with_left_paren(left_paren){
9817     return new CatchClause(
9818       this.keyword,
9819       left_paren,
9820       this.type,
9821       this.variable,
9822       this.right_paren,
9823       this.body);
9824   }
9825   with_type(type){
9826     return new CatchClause(
9827       this.keyword,
9828       this.left_paren,
9829       type,
9830       this.variable,
9831       this.right_paren,
9832       this.body);
9833   }
9834   with_variable(variable){
9835     return new CatchClause(
9836       this.keyword,
9837       this.left_paren,
9838       this.type,
9839       variable,
9840       this.right_paren,
9841       this.body);
9842   }
9843   with_right_paren(right_paren){
9844     return new CatchClause(
9845       this.keyword,
9846       this.left_paren,
9847       this.type,
9848       this.variable,
9849       right_paren,
9850       this.body);
9851   }
9852   with_body(body){
9853     return new CatchClause(
9854       this.keyword,
9855       this.left_paren,
9856       this.type,
9857       this.variable,
9858       this.right_paren,
9859       body);
9860   }
9861   rewrite(rewriter, parents)
9862   {
9863     if (parents == undefined)
9864       parents = [];
9865     let new_parents = parents.slice();
9866     new_parents.push(this);
9867     var keyword = this.keyword.rewrite(rewriter, new_parents);
9868     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
9869     var type = this.type.rewrite(rewriter, new_parents);
9870     var variable = this.variable.rewrite(rewriter, new_parents);
9871     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
9872     var body = this.body.rewrite(rewriter, new_parents);
9873     if (
9874       keyword === this.keyword &&
9875       left_paren === this.left_paren &&
9876       type === this.type &&
9877       variable === this.variable &&
9878       right_paren === this.right_paren &&
9879       body === this.body)
9880     {
9881       return rewriter(this, parents);
9882     }
9883     else
9884     {
9885       return rewriter(new CatchClause(
9886         keyword,
9887         left_paren,
9888         type,
9889         variable,
9890         right_paren,
9891         body), parents);
9892     }
9893   }
9894   static from_json(json, position, source)
9895   {
9896     let keyword = EditableSyntax.from_json(
9897       json.catch_keyword, position, source);
9898     position += keyword.width;
9899     let left_paren = EditableSyntax.from_json(
9900       json.catch_left_paren, position, source);
9901     position += left_paren.width;
9902     let type = EditableSyntax.from_json(
9903       json.catch_type, position, source);
9904     position += type.width;
9905     let variable = EditableSyntax.from_json(
9906       json.catch_variable, position, source);
9907     position += variable.width;
9908     let right_paren = EditableSyntax.from_json(
9909       json.catch_right_paren, position, source);
9910     position += right_paren.width;
9911     let body = EditableSyntax.from_json(
9912       json.catch_body, position, source);
9913     position += body.width;
9914     return new CatchClause(
9915         keyword,
9916         left_paren,
9917         type,
9918         variable,
9919         right_paren,
9920         body);
9921   }
9922   get children_keys()
9923   {
9924     if (CatchClause._children_keys == null)
9925       CatchClause._children_keys = [
9926         'keyword',
9927         'left_paren',
9928         'type',
9929         'variable',
9930         'right_paren',
9931         'body'];
9932     return CatchClause._children_keys;
9933   }
9934 }
9935 class FinallyClause extends EditableSyntax
9936 {
9937   constructor(
9938     keyword,
9939     body)
9940   {
9941     super('finally_clause', {
9942       keyword: keyword,
9943       body: body });
9944   }
9945   get keyword() { return this.children.keyword; }
9946   get body() { return this.children.body; }
9947   with_keyword(keyword){
9948     return new FinallyClause(
9949       keyword,
9950       this.body);
9951   }
9952   with_body(body){
9953     return new FinallyClause(
9954       this.keyword,
9955       body);
9956   }
9957   rewrite(rewriter, parents)
9958   {
9959     if (parents == undefined)
9960       parents = [];
9961     let new_parents = parents.slice();
9962     new_parents.push(this);
9963     var keyword = this.keyword.rewrite(rewriter, new_parents);
9964     var body = this.body.rewrite(rewriter, new_parents);
9965     if (
9966       keyword === this.keyword &&
9967       body === this.body)
9968     {
9969       return rewriter(this, parents);
9970     }
9971     else
9972     {
9973       return rewriter(new FinallyClause(
9974         keyword,
9975         body), parents);
9976     }
9977   }
9978   static from_json(json, position, source)
9979   {
9980     let keyword = EditableSyntax.from_json(
9981       json.finally_keyword, position, source);
9982     position += keyword.width;
9983     let body = EditableSyntax.from_json(
9984       json.finally_body, position, source);
9985     position += body.width;
9986     return new FinallyClause(
9987         keyword,
9988         body);
9989   }
9990   get children_keys()
9991   {
9992     if (FinallyClause._children_keys == null)
9993       FinallyClause._children_keys = [
9994         'keyword',
9995         'body'];
9996     return FinallyClause._children_keys;
9997   }
9998 }
9999 class DoStatement extends EditableSyntax
10000 {
10001   constructor(
10002     keyword,
10003     body,
10004     while_keyword,
10005     left_paren,
10006     condition,
10007     right_paren,
10008     semicolon)
10009   {
10010     super('do_statement', {
10011       keyword: keyword,
10012       body: body,
10013       while_keyword: while_keyword,
10014       left_paren: left_paren,
10015       condition: condition,
10016       right_paren: right_paren,
10017       semicolon: semicolon });
10018   }
10019   get keyword() { return this.children.keyword; }
10020   get body() { return this.children.body; }
10021   get while_keyword() { return this.children.while_keyword; }
10022   get left_paren() { return this.children.left_paren; }
10023   get condition() { return this.children.condition; }
10024   get right_paren() { return this.children.right_paren; }
10025   get semicolon() { return this.children.semicolon; }
10026   with_keyword(keyword){
10027     return new DoStatement(
10028       keyword,
10029       this.body,
10030       this.while_keyword,
10031       this.left_paren,
10032       this.condition,
10033       this.right_paren,
10034       this.semicolon);
10035   }
10036   with_body(body){
10037     return new DoStatement(
10038       this.keyword,
10039       body,
10040       this.while_keyword,
10041       this.left_paren,
10042       this.condition,
10043       this.right_paren,
10044       this.semicolon);
10045   }
10046   with_while_keyword(while_keyword){
10047     return new DoStatement(
10048       this.keyword,
10049       this.body,
10050       while_keyword,
10051       this.left_paren,
10052       this.condition,
10053       this.right_paren,
10054       this.semicolon);
10055   }
10056   with_left_paren(left_paren){
10057     return new DoStatement(
10058       this.keyword,
10059       this.body,
10060       this.while_keyword,
10061       left_paren,
10062       this.condition,
10063       this.right_paren,
10064       this.semicolon);
10065   }
10066   with_condition(condition){
10067     return new DoStatement(
10068       this.keyword,
10069       this.body,
10070       this.while_keyword,
10071       this.left_paren,
10072       condition,
10073       this.right_paren,
10074       this.semicolon);
10075   }
10076   with_right_paren(right_paren){
10077     return new DoStatement(
10078       this.keyword,
10079       this.body,
10080       this.while_keyword,
10081       this.left_paren,
10082       this.condition,
10083       right_paren,
10084       this.semicolon);
10085   }
10086   with_semicolon(semicolon){
10087     return new DoStatement(
10088       this.keyword,
10089       this.body,
10090       this.while_keyword,
10091       this.left_paren,
10092       this.condition,
10093       this.right_paren,
10094       semicolon);
10095   }
10096   rewrite(rewriter, parents)
10097   {
10098     if (parents == undefined)
10099       parents = [];
10100     let new_parents = parents.slice();
10101     new_parents.push(this);
10102     var keyword = this.keyword.rewrite(rewriter, new_parents);
10103     var body = this.body.rewrite(rewriter, new_parents);
10104     var while_keyword = this.while_keyword.rewrite(rewriter, new_parents);
10105     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
10106     var condition = this.condition.rewrite(rewriter, new_parents);
10107     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
10108     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
10109     if (
10110       keyword === this.keyword &&
10111       body === this.body &&
10112       while_keyword === this.while_keyword &&
10113       left_paren === this.left_paren &&
10114       condition === this.condition &&
10115       right_paren === this.right_paren &&
10116       semicolon === this.semicolon)
10117     {
10118       return rewriter(this, parents);
10119     }
10120     else
10121     {
10122       return rewriter(new DoStatement(
10123         keyword,
10124         body,
10125         while_keyword,
10126         left_paren,
10127         condition,
10128         right_paren,
10129         semicolon), parents);
10130     }
10131   }
10132   static from_json(json, position, source)
10133   {
10134     let keyword = EditableSyntax.from_json(
10135       json.do_keyword, position, source);
10136     position += keyword.width;
10137     let body = EditableSyntax.from_json(
10138       json.do_body, position, source);
10139     position += body.width;
10140     let while_keyword = EditableSyntax.from_json(
10141       json.do_while_keyword, position, source);
10142     position += while_keyword.width;
10143     let left_paren = EditableSyntax.from_json(
10144       json.do_left_paren, position, source);
10145     position += left_paren.width;
10146     let condition = EditableSyntax.from_json(
10147       json.do_condition, position, source);
10148     position += condition.width;
10149     let right_paren = EditableSyntax.from_json(
10150       json.do_right_paren, position, source);
10151     position += right_paren.width;
10152     let semicolon = EditableSyntax.from_json(
10153       json.do_semicolon, position, source);
10154     position += semicolon.width;
10155     return new DoStatement(
10156         keyword,
10157         body,
10158         while_keyword,
10159         left_paren,
10160         condition,
10161         right_paren,
10162         semicolon);
10163   }
10164   get children_keys()
10165   {
10166     if (DoStatement._children_keys == null)
10167       DoStatement._children_keys = [
10168         'keyword',
10169         'body',
10170         'while_keyword',
10171         'left_paren',
10172         'condition',
10173         'right_paren',
10174         'semicolon'];
10175     return DoStatement._children_keys;
10176   }
10177 }
10178 class ForStatement extends EditableSyntax
10179 {
10180   constructor(
10181     keyword,
10182     left_paren,
10183     initializer,
10184     first_semicolon,
10185     control,
10186     second_semicolon,
10187     end_of_loop,
10188     right_paren,
10189     body)
10190   {
10191     super('for_statement', {
10192       keyword: keyword,
10193       left_paren: left_paren,
10194       initializer: initializer,
10195       first_semicolon: first_semicolon,
10196       control: control,
10197       second_semicolon: second_semicolon,
10198       end_of_loop: end_of_loop,
10199       right_paren: right_paren,
10200       body: body });
10201   }
10202   get keyword() { return this.children.keyword; }
10203   get left_paren() { return this.children.left_paren; }
10204   get initializer() { return this.children.initializer; }
10205   get first_semicolon() { return this.children.first_semicolon; }
10206   get control() { return this.children.control; }
10207   get second_semicolon() { return this.children.second_semicolon; }
10208   get end_of_loop() { return this.children.end_of_loop; }
10209   get right_paren() { return this.children.right_paren; }
10210   get body() { return this.children.body; }
10211   with_keyword(keyword){
10212     return new ForStatement(
10213       keyword,
10214       this.left_paren,
10215       this.initializer,
10216       this.first_semicolon,
10217       this.control,
10218       this.second_semicolon,
10219       this.end_of_loop,
10220       this.right_paren,
10221       this.body);
10222   }
10223   with_left_paren(left_paren){
10224     return new ForStatement(
10225       this.keyword,
10226       left_paren,
10227       this.initializer,
10228       this.first_semicolon,
10229       this.control,
10230       this.second_semicolon,
10231       this.end_of_loop,
10232       this.right_paren,
10233       this.body);
10234   }
10235   with_initializer(initializer){
10236     return new ForStatement(
10237       this.keyword,
10238       this.left_paren,
10239       initializer,
10240       this.first_semicolon,
10241       this.control,
10242       this.second_semicolon,
10243       this.end_of_loop,
10244       this.right_paren,
10245       this.body);
10246   }
10247   with_first_semicolon(first_semicolon){
10248     return new ForStatement(
10249       this.keyword,
10250       this.left_paren,
10251       this.initializer,
10252       first_semicolon,
10253       this.control,
10254       this.second_semicolon,
10255       this.end_of_loop,
10256       this.right_paren,
10257       this.body);
10258   }
10259   with_control(control){
10260     return new ForStatement(
10261       this.keyword,
10262       this.left_paren,
10263       this.initializer,
10264       this.first_semicolon,
10265       control,
10266       this.second_semicolon,
10267       this.end_of_loop,
10268       this.right_paren,
10269       this.body);
10270   }
10271   with_second_semicolon(second_semicolon){
10272     return new ForStatement(
10273       this.keyword,
10274       this.left_paren,
10275       this.initializer,
10276       this.first_semicolon,
10277       this.control,
10278       second_semicolon,
10279       this.end_of_loop,
10280       this.right_paren,
10281       this.body);
10282   }
10283   with_end_of_loop(end_of_loop){
10284     return new ForStatement(
10285       this.keyword,
10286       this.left_paren,
10287       this.initializer,
10288       this.first_semicolon,
10289       this.control,
10290       this.second_semicolon,
10291       end_of_loop,
10292       this.right_paren,
10293       this.body);
10294   }
10295   with_right_paren(right_paren){
10296     return new ForStatement(
10297       this.keyword,
10298       this.left_paren,
10299       this.initializer,
10300       this.first_semicolon,
10301       this.control,
10302       this.second_semicolon,
10303       this.end_of_loop,
10304       right_paren,
10305       this.body);
10306   }
10307   with_body(body){
10308     return new ForStatement(
10309       this.keyword,
10310       this.left_paren,
10311       this.initializer,
10312       this.first_semicolon,
10313       this.control,
10314       this.second_semicolon,
10315       this.end_of_loop,
10316       this.right_paren,
10317       body);
10318   }
10319   rewrite(rewriter, parents)
10320   {
10321     if (parents == undefined)
10322       parents = [];
10323     let new_parents = parents.slice();
10324     new_parents.push(this);
10325     var keyword = this.keyword.rewrite(rewriter, new_parents);
10326     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
10327     var initializer = this.initializer.rewrite(rewriter, new_parents);
10328     var first_semicolon = this.first_semicolon.rewrite(rewriter, new_parents);
10329     var control = this.control.rewrite(rewriter, new_parents);
10330     var second_semicolon = this.second_semicolon.rewrite(rewriter, new_parents);
10331     var end_of_loop = this.end_of_loop.rewrite(rewriter, new_parents);
10332     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
10333     var body = this.body.rewrite(rewriter, new_parents);
10334     if (
10335       keyword === this.keyword &&
10336       left_paren === this.left_paren &&
10337       initializer === this.initializer &&
10338       first_semicolon === this.first_semicolon &&
10339       control === this.control &&
10340       second_semicolon === this.second_semicolon &&
10341       end_of_loop === this.end_of_loop &&
10342       right_paren === this.right_paren &&
10343       body === this.body)
10344     {
10345       return rewriter(this, parents);
10346     }
10347     else
10348     {
10349       return rewriter(new ForStatement(
10350         keyword,
10351         left_paren,
10352         initializer,
10353         first_semicolon,
10354         control,
10355         second_semicolon,
10356         end_of_loop,
10357         right_paren,
10358         body), parents);
10359     }
10360   }
10361   static from_json(json, position, source)
10362   {
10363     let keyword = EditableSyntax.from_json(
10364       json.for_keyword, position, source);
10365     position += keyword.width;
10366     let left_paren = EditableSyntax.from_json(
10367       json.for_left_paren, position, source);
10368     position += left_paren.width;
10369     let initializer = EditableSyntax.from_json(
10370       json.for_initializer, position, source);
10371     position += initializer.width;
10372     let first_semicolon = EditableSyntax.from_json(
10373       json.for_first_semicolon, position, source);
10374     position += first_semicolon.width;
10375     let control = EditableSyntax.from_json(
10376       json.for_control, position, source);
10377     position += control.width;
10378     let second_semicolon = EditableSyntax.from_json(
10379       json.for_second_semicolon, position, source);
10380     position += second_semicolon.width;
10381     let end_of_loop = EditableSyntax.from_json(
10382       json.for_end_of_loop, position, source);
10383     position += end_of_loop.width;
10384     let right_paren = EditableSyntax.from_json(
10385       json.for_right_paren, position, source);
10386     position += right_paren.width;
10387     let body = EditableSyntax.from_json(
10388       json.for_body, position, source);
10389     position += body.width;
10390     return new ForStatement(
10391         keyword,
10392         left_paren,
10393         initializer,
10394         first_semicolon,
10395         control,
10396         second_semicolon,
10397         end_of_loop,
10398         right_paren,
10399         body);
10400   }
10401   get children_keys()
10402   {
10403     if (ForStatement._children_keys == null)
10404       ForStatement._children_keys = [
10405         'keyword',
10406         'left_paren',
10407         'initializer',
10408         'first_semicolon',
10409         'control',
10410         'second_semicolon',
10411         'end_of_loop',
10412         'right_paren',
10413         'body'];
10414     return ForStatement._children_keys;
10415   }
10416 }
10417 class ForeachStatement extends EditableSyntax
10418 {
10419   constructor(
10420     keyword,
10421     left_paren,
10422     collection,
10423     await_keyword,
10424     as,
10425     key,
10426     arrow,
10427     value,
10428     right_paren,
10429     body)
10430   {
10431     super('foreach_statement', {
10432       keyword: keyword,
10433       left_paren: left_paren,
10434       collection: collection,
10435       await_keyword: await_keyword,
10436       as: as,
10437       key: key,
10438       arrow: arrow,
10439       value: value,
10440       right_paren: right_paren,
10441       body: body });
10442   }
10443   get keyword() { return this.children.keyword; }
10444   get left_paren() { return this.children.left_paren; }
10445   get collection() { return this.children.collection; }
10446   get await_keyword() { return this.children.await_keyword; }
10447   get as() { return this.children.as; }
10448   get key() { return this.children.key; }
10449   get arrow() { return this.children.arrow; }
10450   get value() { return this.children.value; }
10451   get right_paren() { return this.children.right_paren; }
10452   get body() { return this.children.body; }
10453   with_keyword(keyword){
10454     return new ForeachStatement(
10455       keyword,
10456       this.left_paren,
10457       this.collection,
10458       this.await_keyword,
10459       this.as,
10460       this.key,
10461       this.arrow,
10462       this.value,
10463       this.right_paren,
10464       this.body);
10465   }
10466   with_left_paren(left_paren){
10467     return new ForeachStatement(
10468       this.keyword,
10469       left_paren,
10470       this.collection,
10471       this.await_keyword,
10472       this.as,
10473       this.key,
10474       this.arrow,
10475       this.value,
10476       this.right_paren,
10477       this.body);
10478   }
10479   with_collection(collection){
10480     return new ForeachStatement(
10481       this.keyword,
10482       this.left_paren,
10483       collection,
10484       this.await_keyword,
10485       this.as,
10486       this.key,
10487       this.arrow,
10488       this.value,
10489       this.right_paren,
10490       this.body);
10491   }
10492   with_await_keyword(await_keyword){
10493     return new ForeachStatement(
10494       this.keyword,
10495       this.left_paren,
10496       this.collection,
10497       await_keyword,
10498       this.as,
10499       this.key,
10500       this.arrow,
10501       this.value,
10502       this.right_paren,
10503       this.body);
10504   }
10505   with_as(as){
10506     return new ForeachStatement(
10507       this.keyword,
10508       this.left_paren,
10509       this.collection,
10510       this.await_keyword,
10511       as,
10512       this.key,
10513       this.arrow,
10514       this.value,
10515       this.right_paren,
10516       this.body);
10517   }
10518   with_key(key){
10519     return new ForeachStatement(
10520       this.keyword,
10521       this.left_paren,
10522       this.collection,
10523       this.await_keyword,
10524       this.as,
10525       key,
10526       this.arrow,
10527       this.value,
10528       this.right_paren,
10529       this.body);
10530   }
10531   with_arrow(arrow){
10532     return new ForeachStatement(
10533       this.keyword,
10534       this.left_paren,
10535       this.collection,
10536       this.await_keyword,
10537       this.as,
10538       this.key,
10539       arrow,
10540       this.value,
10541       this.right_paren,
10542       this.body);
10543   }
10544   with_value(value){
10545     return new ForeachStatement(
10546       this.keyword,
10547       this.left_paren,
10548       this.collection,
10549       this.await_keyword,
10550       this.as,
10551       this.key,
10552       this.arrow,
10553       value,
10554       this.right_paren,
10555       this.body);
10556   }
10557   with_right_paren(right_paren){
10558     return new ForeachStatement(
10559       this.keyword,
10560       this.left_paren,
10561       this.collection,
10562       this.await_keyword,
10563       this.as,
10564       this.key,
10565       this.arrow,
10566       this.value,
10567       right_paren,
10568       this.body);
10569   }
10570   with_body(body){
10571     return new ForeachStatement(
10572       this.keyword,
10573       this.left_paren,
10574       this.collection,
10575       this.await_keyword,
10576       this.as,
10577       this.key,
10578       this.arrow,
10579       this.value,
10580       this.right_paren,
10581       body);
10582   }
10583   rewrite(rewriter, parents)
10584   {
10585     if (parents == undefined)
10586       parents = [];
10587     let new_parents = parents.slice();
10588     new_parents.push(this);
10589     var keyword = this.keyword.rewrite(rewriter, new_parents);
10590     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
10591     var collection = this.collection.rewrite(rewriter, new_parents);
10592     var await_keyword = this.await_keyword.rewrite(rewriter, new_parents);
10593     var as = this.as.rewrite(rewriter, new_parents);
10594     var key = this.key.rewrite(rewriter, new_parents);
10595     var arrow = this.arrow.rewrite(rewriter, new_parents);
10596     var value = this.value.rewrite(rewriter, new_parents);
10597     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
10598     var body = this.body.rewrite(rewriter, new_parents);
10599     if (
10600       keyword === this.keyword &&
10601       left_paren === this.left_paren &&
10602       collection === this.collection &&
10603       await_keyword === this.await_keyword &&
10604       as === this.as &&
10605       key === this.key &&
10606       arrow === this.arrow &&
10607       value === this.value &&
10608       right_paren === this.right_paren &&
10609       body === this.body)
10610     {
10611       return rewriter(this, parents);
10612     }
10613     else
10614     {
10615       return rewriter(new ForeachStatement(
10616         keyword,
10617         left_paren,
10618         collection,
10619         await_keyword,
10620         as,
10621         key,
10622         arrow,
10623         value,
10624         right_paren,
10625         body), parents);
10626     }
10627   }
10628   static from_json(json, position, source)
10629   {
10630     let keyword = EditableSyntax.from_json(
10631       json.foreach_keyword, position, source);
10632     position += keyword.width;
10633     let left_paren = EditableSyntax.from_json(
10634       json.foreach_left_paren, position, source);
10635     position += left_paren.width;
10636     let collection = EditableSyntax.from_json(
10637       json.foreach_collection, position, source);
10638     position += collection.width;
10639     let await_keyword = EditableSyntax.from_json(
10640       json.foreach_await_keyword, position, source);
10641     position += await_keyword.width;
10642     let as = EditableSyntax.from_json(
10643       json.foreach_as, position, source);
10644     position += as.width;
10645     let key = EditableSyntax.from_json(
10646       json.foreach_key, position, source);
10647     position += key.width;
10648     let arrow = EditableSyntax.from_json(
10649       json.foreach_arrow, position, source);
10650     position += arrow.width;
10651     let value = EditableSyntax.from_json(
10652       json.foreach_value, position, source);
10653     position += value.width;
10654     let right_paren = EditableSyntax.from_json(
10655       json.foreach_right_paren, position, source);
10656     position += right_paren.width;
10657     let body = EditableSyntax.from_json(
10658       json.foreach_body, position, source);
10659     position += body.width;
10660     return new ForeachStatement(
10661         keyword,
10662         left_paren,
10663         collection,
10664         await_keyword,
10665         as,
10666         key,
10667         arrow,
10668         value,
10669         right_paren,
10670         body);
10671   }
10672   get children_keys()
10673   {
10674     if (ForeachStatement._children_keys == null)
10675       ForeachStatement._children_keys = [
10676         'keyword',
10677         'left_paren',
10678         'collection',
10679         'await_keyword',
10680         'as',
10681         'key',
10682         'arrow',
10683         'value',
10684         'right_paren',
10685         'body'];
10686     return ForeachStatement._children_keys;
10687   }
10688 }
10689 class SwitchStatement extends EditableSyntax
10690 {
10691   constructor(
10692     keyword,
10693     left_paren,
10694     expression,
10695     right_paren,
10696     left_brace,
10697     sections,
10698     right_brace)
10699   {
10700     super('switch_statement', {
10701       keyword: keyword,
10702       left_paren: left_paren,
10703       expression: expression,
10704       right_paren: right_paren,
10705       left_brace: left_brace,
10706       sections: sections,
10707       right_brace: right_brace });
10708   }
10709   get keyword() { return this.children.keyword; }
10710   get left_paren() { return this.children.left_paren; }
10711   get expression() { return this.children.expression; }
10712   get right_paren() { return this.children.right_paren; }
10713   get left_brace() { return this.children.left_brace; }
10714   get sections() { return this.children.sections; }
10715   get right_brace() { return this.children.right_brace; }
10716   with_keyword(keyword){
10717     return new SwitchStatement(
10718       keyword,
10719       this.left_paren,
10720       this.expression,
10721       this.right_paren,
10722       this.left_brace,
10723       this.sections,
10724       this.right_brace);
10725   }
10726   with_left_paren(left_paren){
10727     return new SwitchStatement(
10728       this.keyword,
10729       left_paren,
10730       this.expression,
10731       this.right_paren,
10732       this.left_brace,
10733       this.sections,
10734       this.right_brace);
10735   }
10736   with_expression(expression){
10737     return new SwitchStatement(
10738       this.keyword,
10739       this.left_paren,
10740       expression,
10741       this.right_paren,
10742       this.left_brace,
10743       this.sections,
10744       this.right_brace);
10745   }
10746   with_right_paren(right_paren){
10747     return new SwitchStatement(
10748       this.keyword,
10749       this.left_paren,
10750       this.expression,
10751       right_paren,
10752       this.left_brace,
10753       this.sections,
10754       this.right_brace);
10755   }
10756   with_left_brace(left_brace){
10757     return new SwitchStatement(
10758       this.keyword,
10759       this.left_paren,
10760       this.expression,
10761       this.right_paren,
10762       left_brace,
10763       this.sections,
10764       this.right_brace);
10765   }
10766   with_sections(sections){
10767     return new SwitchStatement(
10768       this.keyword,
10769       this.left_paren,
10770       this.expression,
10771       this.right_paren,
10772       this.left_brace,
10773       sections,
10774       this.right_brace);
10775   }
10776   with_right_brace(right_brace){
10777     return new SwitchStatement(
10778       this.keyword,
10779       this.left_paren,
10780       this.expression,
10781       this.right_paren,
10782       this.left_brace,
10783       this.sections,
10784       right_brace);
10785   }
10786   rewrite(rewriter, parents)
10787   {
10788     if (parents == undefined)
10789       parents = [];
10790     let new_parents = parents.slice();
10791     new_parents.push(this);
10792     var keyword = this.keyword.rewrite(rewriter, new_parents);
10793     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
10794     var expression = this.expression.rewrite(rewriter, new_parents);
10795     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
10796     var left_brace = this.left_brace.rewrite(rewriter, new_parents);
10797     var sections = this.sections.rewrite(rewriter, new_parents);
10798     var right_brace = this.right_brace.rewrite(rewriter, new_parents);
10799     if (
10800       keyword === this.keyword &&
10801       left_paren === this.left_paren &&
10802       expression === this.expression &&
10803       right_paren === this.right_paren &&
10804       left_brace === this.left_brace &&
10805       sections === this.sections &&
10806       right_brace === this.right_brace)
10807     {
10808       return rewriter(this, parents);
10809     }
10810     else
10811     {
10812       return rewriter(new SwitchStatement(
10813         keyword,
10814         left_paren,
10815         expression,
10816         right_paren,
10817         left_brace,
10818         sections,
10819         right_brace), parents);
10820     }
10821   }
10822   static from_json(json, position, source)
10823   {
10824     let keyword = EditableSyntax.from_json(
10825       json.switch_keyword, position, source);
10826     position += keyword.width;
10827     let left_paren = EditableSyntax.from_json(
10828       json.switch_left_paren, position, source);
10829     position += left_paren.width;
10830     let expression = EditableSyntax.from_json(
10831       json.switch_expression, position, source);
10832     position += expression.width;
10833     let right_paren = EditableSyntax.from_json(
10834       json.switch_right_paren, position, source);
10835     position += right_paren.width;
10836     let left_brace = EditableSyntax.from_json(
10837       json.switch_left_brace, position, source);
10838     position += left_brace.width;
10839     let sections = EditableSyntax.from_json(
10840       json.switch_sections, position, source);
10841     position += sections.width;
10842     let right_brace = EditableSyntax.from_json(
10843       json.switch_right_brace, position, source);
10844     position += right_brace.width;
10845     return new SwitchStatement(
10846         keyword,
10847         left_paren,
10848         expression,
10849         right_paren,
10850         left_brace,
10851         sections,
10852         right_brace);
10853   }
10854   get children_keys()
10855   {
10856     if (SwitchStatement._children_keys == null)
10857       SwitchStatement._children_keys = [
10858         'keyword',
10859         'left_paren',
10860         'expression',
10861         'right_paren',
10862         'left_brace',
10863         'sections',
10864         'right_brace'];
10865     return SwitchStatement._children_keys;
10866   }
10867 }
10868 class AlternateSwitchStatement extends EditableSyntax
10869 {
10870   constructor(
10871     keyword,
10872     left_paren,
10873     expression,
10874     right_paren,
10875     opening_colon,
10876     sections,
10877     closing_endswitch,
10878     closing_semicolon)
10879   {
10880     super('alternate_switch_statement', {
10881       keyword: keyword,
10882       left_paren: left_paren,
10883       expression: expression,
10884       right_paren: right_paren,
10885       opening_colon: opening_colon,
10886       sections: sections,
10887       closing_endswitch: closing_endswitch,
10888       closing_semicolon: closing_semicolon });
10889   }
10890   get keyword() { return this.children.keyword; }
10891   get left_paren() { return this.children.left_paren; }
10892   get expression() { return this.children.expression; }
10893   get right_paren() { return this.children.right_paren; }
10894   get opening_colon() { return this.children.opening_colon; }
10895   get sections() { return this.children.sections; }
10896   get closing_endswitch() { return this.children.closing_endswitch; }
10897   get closing_semicolon() { return this.children.closing_semicolon; }
10898   with_keyword(keyword){
10899     return new AlternateSwitchStatement(
10900       keyword,
10901       this.left_paren,
10902       this.expression,
10903       this.right_paren,
10904       this.opening_colon,
10905       this.sections,
10906       this.closing_endswitch,
10907       this.closing_semicolon);
10908   }
10909   with_left_paren(left_paren){
10910     return new AlternateSwitchStatement(
10911       this.keyword,
10912       left_paren,
10913       this.expression,
10914       this.right_paren,
10915       this.opening_colon,
10916       this.sections,
10917       this.closing_endswitch,
10918       this.closing_semicolon);
10919   }
10920   with_expression(expression){
10921     return new AlternateSwitchStatement(
10922       this.keyword,
10923       this.left_paren,
10924       expression,
10925       this.right_paren,
10926       this.opening_colon,
10927       this.sections,
10928       this.closing_endswitch,
10929       this.closing_semicolon);
10930   }
10931   with_right_paren(right_paren){
10932     return new AlternateSwitchStatement(
10933       this.keyword,
10934       this.left_paren,
10935       this.expression,
10936       right_paren,
10937       this.opening_colon,
10938       this.sections,
10939       this.closing_endswitch,
10940       this.closing_semicolon);
10941   }
10942   with_opening_colon(opening_colon){
10943     return new AlternateSwitchStatement(
10944       this.keyword,
10945       this.left_paren,
10946       this.expression,
10947       this.right_paren,
10948       opening_colon,
10949       this.sections,
10950       this.closing_endswitch,
10951       this.closing_semicolon);
10952   }
10953   with_sections(sections){
10954     return new AlternateSwitchStatement(
10955       this.keyword,
10956       this.left_paren,
10957       this.expression,
10958       this.right_paren,
10959       this.opening_colon,
10960       sections,
10961       this.closing_endswitch,
10962       this.closing_semicolon);
10963   }
10964   with_closing_endswitch(closing_endswitch){
10965     return new AlternateSwitchStatement(
10966       this.keyword,
10967       this.left_paren,
10968       this.expression,
10969       this.right_paren,
10970       this.opening_colon,
10971       this.sections,
10972       closing_endswitch,
10973       this.closing_semicolon);
10974   }
10975   with_closing_semicolon(closing_semicolon){
10976     return new AlternateSwitchStatement(
10977       this.keyword,
10978       this.left_paren,
10979       this.expression,
10980       this.right_paren,
10981       this.opening_colon,
10982       this.sections,
10983       this.closing_endswitch,
10984       closing_semicolon);
10985   }
10986   rewrite(rewriter, parents)
10987   {
10988     if (parents == undefined)
10989       parents = [];
10990     let new_parents = parents.slice();
10991     new_parents.push(this);
10992     var keyword = this.keyword.rewrite(rewriter, new_parents);
10993     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
10994     var expression = this.expression.rewrite(rewriter, new_parents);
10995     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
10996     var opening_colon = this.opening_colon.rewrite(rewriter, new_parents);
10997     var sections = this.sections.rewrite(rewriter, new_parents);
10998     var closing_endswitch = this.closing_endswitch.rewrite(rewriter, new_parents);
10999     var closing_semicolon = this.closing_semicolon.rewrite(rewriter, new_parents);
11000     if (
11001       keyword === this.keyword &&
11002       left_paren === this.left_paren &&
11003       expression === this.expression &&
11004       right_paren === this.right_paren &&
11005       opening_colon === this.opening_colon &&
11006       sections === this.sections &&
11007       closing_endswitch === this.closing_endswitch &&
11008       closing_semicolon === this.closing_semicolon)
11009     {
11010       return rewriter(this, parents);
11011     }
11012     else
11013     {
11014       return rewriter(new AlternateSwitchStatement(
11015         keyword,
11016         left_paren,
11017         expression,
11018         right_paren,
11019         opening_colon,
11020         sections,
11021         closing_endswitch,
11022         closing_semicolon), parents);
11023     }
11024   }
11025   static from_json(json, position, source)
11026   {
11027     let keyword = EditableSyntax.from_json(
11028       json.alternate_switch_keyword, position, source);
11029     position += keyword.width;
11030     let left_paren = EditableSyntax.from_json(
11031       json.alternate_switch_left_paren, position, source);
11032     position += left_paren.width;
11033     let expression = EditableSyntax.from_json(
11034       json.alternate_switch_expression, position, source);
11035     position += expression.width;
11036     let right_paren = EditableSyntax.from_json(
11037       json.alternate_switch_right_paren, position, source);
11038     position += right_paren.width;
11039     let opening_colon = EditableSyntax.from_json(
11040       json.alternate_switch_opening_colon, position, source);
11041     position += opening_colon.width;
11042     let sections = EditableSyntax.from_json(
11043       json.alternate_switch_sections, position, source);
11044     position += sections.width;
11045     let closing_endswitch = EditableSyntax.from_json(
11046       json.alternate_switch_closing_endswitch, position, source);
11047     position += closing_endswitch.width;
11048     let closing_semicolon = EditableSyntax.from_json(
11049       json.alternate_switch_closing_semicolon, position, source);
11050     position += closing_semicolon.width;
11051     return new AlternateSwitchStatement(
11052         keyword,
11053         left_paren,
11054         expression,
11055         right_paren,
11056         opening_colon,
11057         sections,
11058         closing_endswitch,
11059         closing_semicolon);
11060   }
11061   get children_keys()
11062   {
11063     if (AlternateSwitchStatement._children_keys == null)
11064       AlternateSwitchStatement._children_keys = [
11065         'keyword',
11066         'left_paren',
11067         'expression',
11068         'right_paren',
11069         'opening_colon',
11070         'sections',
11071         'closing_endswitch',
11072         'closing_semicolon'];
11073     return AlternateSwitchStatement._children_keys;
11074   }
11075 }
11076 class SwitchSection extends EditableSyntax
11077 {
11078   constructor(
11079     labels,
11080     statements,
11081     fallthrough)
11082   {
11083     super('switch_section', {
11084       labels: labels,
11085       statements: statements,
11086       fallthrough: fallthrough });
11087   }
11088   get labels() { return this.children.labels; }
11089   get statements() { return this.children.statements; }
11090   get fallthrough() { return this.children.fallthrough; }
11091   with_labels(labels){
11092     return new SwitchSection(
11093       labels,
11094       this.statements,
11095       this.fallthrough);
11096   }
11097   with_statements(statements){
11098     return new SwitchSection(
11099       this.labels,
11100       statements,
11101       this.fallthrough);
11102   }
11103   with_fallthrough(fallthrough){
11104     return new SwitchSection(
11105       this.labels,
11106       this.statements,
11107       fallthrough);
11108   }
11109   rewrite(rewriter, parents)
11110   {
11111     if (parents == undefined)
11112       parents = [];
11113     let new_parents = parents.slice();
11114     new_parents.push(this);
11115     var labels = this.labels.rewrite(rewriter, new_parents);
11116     var statements = this.statements.rewrite(rewriter, new_parents);
11117     var fallthrough = this.fallthrough.rewrite(rewriter, new_parents);
11118     if (
11119       labels === this.labels &&
11120       statements === this.statements &&
11121       fallthrough === this.fallthrough)
11122     {
11123       return rewriter(this, parents);
11124     }
11125     else
11126     {
11127       return rewriter(new SwitchSection(
11128         labels,
11129         statements,
11130         fallthrough), parents);
11131     }
11132   }
11133   static from_json(json, position, source)
11134   {
11135     let labels = EditableSyntax.from_json(
11136       json.switch_section_labels, position, source);
11137     position += labels.width;
11138     let statements = EditableSyntax.from_json(
11139       json.switch_section_statements, position, source);
11140     position += statements.width;
11141     let fallthrough = EditableSyntax.from_json(
11142       json.switch_section_fallthrough, position, source);
11143     position += fallthrough.width;
11144     return new SwitchSection(
11145         labels,
11146         statements,
11147         fallthrough);
11148   }
11149   get children_keys()
11150   {
11151     if (SwitchSection._children_keys == null)
11152       SwitchSection._children_keys = [
11153         'labels',
11154         'statements',
11155         'fallthrough'];
11156     return SwitchSection._children_keys;
11157   }
11158 }
11159 class SwitchFallthrough extends EditableSyntax
11160 {
11161   constructor(
11162     keyword,
11163     semicolon)
11164   {
11165     super('switch_fallthrough', {
11166       keyword: keyword,
11167       semicolon: semicolon });
11168   }
11169   get keyword() { return this.children.keyword; }
11170   get semicolon() { return this.children.semicolon; }
11171   with_keyword(keyword){
11172     return new SwitchFallthrough(
11173       keyword,
11174       this.semicolon);
11175   }
11176   with_semicolon(semicolon){
11177     return new SwitchFallthrough(
11178       this.keyword,
11179       semicolon);
11180   }
11181   rewrite(rewriter, parents)
11182   {
11183     if (parents == undefined)
11184       parents = [];
11185     let new_parents = parents.slice();
11186     new_parents.push(this);
11187     var keyword = this.keyword.rewrite(rewriter, new_parents);
11188     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
11189     if (
11190       keyword === this.keyword &&
11191       semicolon === this.semicolon)
11192     {
11193       return rewriter(this, parents);
11194     }
11195     else
11196     {
11197       return rewriter(new SwitchFallthrough(
11198         keyword,
11199         semicolon), parents);
11200     }
11201   }
11202   static from_json(json, position, source)
11203   {
11204     let keyword = EditableSyntax.from_json(
11205       json.fallthrough_keyword, position, source);
11206     position += keyword.width;
11207     let semicolon = EditableSyntax.from_json(
11208       json.fallthrough_semicolon, position, source);
11209     position += semicolon.width;
11210     return new SwitchFallthrough(
11211         keyword,
11212         semicolon);
11213   }
11214   get children_keys()
11215   {
11216     if (SwitchFallthrough._children_keys == null)
11217       SwitchFallthrough._children_keys = [
11218         'keyword',
11219         'semicolon'];
11220     return SwitchFallthrough._children_keys;
11221   }
11222 }
11223 class CaseLabel extends EditableSyntax
11224 {
11225   constructor(
11226     keyword,
11227     expression,
11228     colon)
11229   {
11230     super('case_label', {
11231       keyword: keyword,
11232       expression: expression,
11233       colon: colon });
11234   }
11235   get keyword() { return this.children.keyword; }
11236   get expression() { return this.children.expression; }
11237   get colon() { return this.children.colon; }
11238   with_keyword(keyword){
11239     return new CaseLabel(
11240       keyword,
11241       this.expression,
11242       this.colon);
11243   }
11244   with_expression(expression){
11245     return new CaseLabel(
11246       this.keyword,
11247       expression,
11248       this.colon);
11249   }
11250   with_colon(colon){
11251     return new CaseLabel(
11252       this.keyword,
11253       this.expression,
11254       colon);
11255   }
11256   rewrite(rewriter, parents)
11257   {
11258     if (parents == undefined)
11259       parents = [];
11260     let new_parents = parents.slice();
11261     new_parents.push(this);
11262     var keyword = this.keyword.rewrite(rewriter, new_parents);
11263     var expression = this.expression.rewrite(rewriter, new_parents);
11264     var colon = this.colon.rewrite(rewriter, new_parents);
11265     if (
11266       keyword === this.keyword &&
11267       expression === this.expression &&
11268       colon === this.colon)
11269     {
11270       return rewriter(this, parents);
11271     }
11272     else
11273     {
11274       return rewriter(new CaseLabel(
11275         keyword,
11276         expression,
11277         colon), parents);
11278     }
11279   }
11280   static from_json(json, position, source)
11281   {
11282     let keyword = EditableSyntax.from_json(
11283       json.case_keyword, position, source);
11284     position += keyword.width;
11285     let expression = EditableSyntax.from_json(
11286       json.case_expression, position, source);
11287     position += expression.width;
11288     let colon = EditableSyntax.from_json(
11289       json.case_colon, position, source);
11290     position += colon.width;
11291     return new CaseLabel(
11292         keyword,
11293         expression,
11294         colon);
11295   }
11296   get children_keys()
11297   {
11298     if (CaseLabel._children_keys == null)
11299       CaseLabel._children_keys = [
11300         'keyword',
11301         'expression',
11302         'colon'];
11303     return CaseLabel._children_keys;
11304   }
11305 }
11306 class DefaultLabel extends EditableSyntax
11307 {
11308   constructor(
11309     keyword,
11310     colon)
11311   {
11312     super('default_label', {
11313       keyword: keyword,
11314       colon: colon });
11315   }
11316   get keyword() { return this.children.keyword; }
11317   get colon() { return this.children.colon; }
11318   with_keyword(keyword){
11319     return new DefaultLabel(
11320       keyword,
11321       this.colon);
11322   }
11323   with_colon(colon){
11324     return new DefaultLabel(
11325       this.keyword,
11326       colon);
11327   }
11328   rewrite(rewriter, parents)
11329   {
11330     if (parents == undefined)
11331       parents = [];
11332     let new_parents = parents.slice();
11333     new_parents.push(this);
11334     var keyword = this.keyword.rewrite(rewriter, new_parents);
11335     var colon = this.colon.rewrite(rewriter, new_parents);
11336     if (
11337       keyword === this.keyword &&
11338       colon === this.colon)
11339     {
11340       return rewriter(this, parents);
11341     }
11342     else
11343     {
11344       return rewriter(new DefaultLabel(
11345         keyword,
11346         colon), parents);
11347     }
11348   }
11349   static from_json(json, position, source)
11350   {
11351     let keyword = EditableSyntax.from_json(
11352       json.default_keyword, position, source);
11353     position += keyword.width;
11354     let colon = EditableSyntax.from_json(
11355       json.default_colon, position, source);
11356     position += colon.width;
11357     return new DefaultLabel(
11358         keyword,
11359         colon);
11360   }
11361   get children_keys()
11362   {
11363     if (DefaultLabel._children_keys == null)
11364       DefaultLabel._children_keys = [
11365         'keyword',
11366         'colon'];
11367     return DefaultLabel._children_keys;
11368   }
11369 }
11370 class ReturnStatement extends EditableSyntax
11371 {
11372   constructor(
11373     keyword,
11374     expression,
11375     semicolon)
11376   {
11377     super('return_statement', {
11378       keyword: keyword,
11379       expression: expression,
11380       semicolon: semicolon });
11381   }
11382   get keyword() { return this.children.keyword; }
11383   get expression() { return this.children.expression; }
11384   get semicolon() { return this.children.semicolon; }
11385   with_keyword(keyword){
11386     return new ReturnStatement(
11387       keyword,
11388       this.expression,
11389       this.semicolon);
11390   }
11391   with_expression(expression){
11392     return new ReturnStatement(
11393       this.keyword,
11394       expression,
11395       this.semicolon);
11396   }
11397   with_semicolon(semicolon){
11398     return new ReturnStatement(
11399       this.keyword,
11400       this.expression,
11401       semicolon);
11402   }
11403   rewrite(rewriter, parents)
11404   {
11405     if (parents == undefined)
11406       parents = [];
11407     let new_parents = parents.slice();
11408     new_parents.push(this);
11409     var keyword = this.keyword.rewrite(rewriter, new_parents);
11410     var expression = this.expression.rewrite(rewriter, new_parents);
11411     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
11412     if (
11413       keyword === this.keyword &&
11414       expression === this.expression &&
11415       semicolon === this.semicolon)
11416     {
11417       return rewriter(this, parents);
11418     }
11419     else
11420     {
11421       return rewriter(new ReturnStatement(
11422         keyword,
11423         expression,
11424         semicolon), parents);
11425     }
11426   }
11427   static from_json(json, position, source)
11428   {
11429     let keyword = EditableSyntax.from_json(
11430       json.return_keyword, position, source);
11431     position += keyword.width;
11432     let expression = EditableSyntax.from_json(
11433       json.return_expression, position, source);
11434     position += expression.width;
11435     let semicolon = EditableSyntax.from_json(
11436       json.return_semicolon, position, source);
11437     position += semicolon.width;
11438     return new ReturnStatement(
11439         keyword,
11440         expression,
11441         semicolon);
11442   }
11443   get children_keys()
11444   {
11445     if (ReturnStatement._children_keys == null)
11446       ReturnStatement._children_keys = [
11447         'keyword',
11448         'expression',
11449         'semicolon'];
11450     return ReturnStatement._children_keys;
11451   }
11452 }
11453 class GotoLabel extends EditableSyntax
11454 {
11455   constructor(
11456     name,
11457     colon)
11458   {
11459     super('goto_label', {
11460       name: name,
11461       colon: colon });
11462   }
11463   get name() { return this.children.name; }
11464   get colon() { return this.children.colon; }
11465   with_name(name){
11466     return new GotoLabel(
11467       name,
11468       this.colon);
11469   }
11470   with_colon(colon){
11471     return new GotoLabel(
11472       this.name,
11473       colon);
11474   }
11475   rewrite(rewriter, parents)
11476   {
11477     if (parents == undefined)
11478       parents = [];
11479     let new_parents = parents.slice();
11480     new_parents.push(this);
11481     var name = this.name.rewrite(rewriter, new_parents);
11482     var colon = this.colon.rewrite(rewriter, new_parents);
11483     if (
11484       name === this.name &&
11485       colon === this.colon)
11486     {
11487       return rewriter(this, parents);
11488     }
11489     else
11490     {
11491       return rewriter(new GotoLabel(
11492         name,
11493         colon), parents);
11494     }
11495   }
11496   static from_json(json, position, source)
11497   {
11498     let name = EditableSyntax.from_json(
11499       json.goto_label_name, position, source);
11500     position += name.width;
11501     let colon = EditableSyntax.from_json(
11502       json.goto_label_colon, position, source);
11503     position += colon.width;
11504     return new GotoLabel(
11505         name,
11506         colon);
11507   }
11508   get children_keys()
11509   {
11510     if (GotoLabel._children_keys == null)
11511       GotoLabel._children_keys = [
11512         'name',
11513         'colon'];
11514     return GotoLabel._children_keys;
11515   }
11516 }
11517 class GotoStatement extends EditableSyntax
11518 {
11519   constructor(
11520     keyword,
11521     label_name,
11522     semicolon)
11523   {
11524     super('goto_statement', {
11525       keyword: keyword,
11526       label_name: label_name,
11527       semicolon: semicolon });
11528   }
11529   get keyword() { return this.children.keyword; }
11530   get label_name() { return this.children.label_name; }
11531   get semicolon() { return this.children.semicolon; }
11532   with_keyword(keyword){
11533     return new GotoStatement(
11534       keyword,
11535       this.label_name,
11536       this.semicolon);
11537   }
11538   with_label_name(label_name){
11539     return new GotoStatement(
11540       this.keyword,
11541       label_name,
11542       this.semicolon);
11543   }
11544   with_semicolon(semicolon){
11545     return new GotoStatement(
11546       this.keyword,
11547       this.label_name,
11548       semicolon);
11549   }
11550   rewrite(rewriter, parents)
11551   {
11552     if (parents == undefined)
11553       parents = [];
11554     let new_parents = parents.slice();
11555     new_parents.push(this);
11556     var keyword = this.keyword.rewrite(rewriter, new_parents);
11557     var label_name = this.label_name.rewrite(rewriter, new_parents);
11558     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
11559     if (
11560       keyword === this.keyword &&
11561       label_name === this.label_name &&
11562       semicolon === this.semicolon)
11563     {
11564       return rewriter(this, parents);
11565     }
11566     else
11567     {
11568       return rewriter(new GotoStatement(
11569         keyword,
11570         label_name,
11571         semicolon), parents);
11572     }
11573   }
11574   static from_json(json, position, source)
11575   {
11576     let keyword = EditableSyntax.from_json(
11577       json.goto_statement_keyword, position, source);
11578     position += keyword.width;
11579     let label_name = EditableSyntax.from_json(
11580       json.goto_statement_label_name, position, source);
11581     position += label_name.width;
11582     let semicolon = EditableSyntax.from_json(
11583       json.goto_statement_semicolon, position, source);
11584     position += semicolon.width;
11585     return new GotoStatement(
11586         keyword,
11587         label_name,
11588         semicolon);
11589   }
11590   get children_keys()
11591   {
11592     if (GotoStatement._children_keys == null)
11593       GotoStatement._children_keys = [
11594         'keyword',
11595         'label_name',
11596         'semicolon'];
11597     return GotoStatement._children_keys;
11598   }
11599 }
11600 class ThrowStatement extends EditableSyntax
11601 {
11602   constructor(
11603     keyword,
11604     expression,
11605     semicolon)
11606   {
11607     super('throw_statement', {
11608       keyword: keyword,
11609       expression: expression,
11610       semicolon: semicolon });
11611   }
11612   get keyword() { return this.children.keyword; }
11613   get expression() { return this.children.expression; }
11614   get semicolon() { return this.children.semicolon; }
11615   with_keyword(keyword){
11616     return new ThrowStatement(
11617       keyword,
11618       this.expression,
11619       this.semicolon);
11620   }
11621   with_expression(expression){
11622     return new ThrowStatement(
11623       this.keyword,
11624       expression,
11625       this.semicolon);
11626   }
11627   with_semicolon(semicolon){
11628     return new ThrowStatement(
11629       this.keyword,
11630       this.expression,
11631       semicolon);
11632   }
11633   rewrite(rewriter, parents)
11634   {
11635     if (parents == undefined)
11636       parents = [];
11637     let new_parents = parents.slice();
11638     new_parents.push(this);
11639     var keyword = this.keyword.rewrite(rewriter, new_parents);
11640     var expression = this.expression.rewrite(rewriter, new_parents);
11641     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
11642     if (
11643       keyword === this.keyword &&
11644       expression === this.expression &&
11645       semicolon === this.semicolon)
11646     {
11647       return rewriter(this, parents);
11648     }
11649     else
11650     {
11651       return rewriter(new ThrowStatement(
11652         keyword,
11653         expression,
11654         semicolon), parents);
11655     }
11656   }
11657   static from_json(json, position, source)
11658   {
11659     let keyword = EditableSyntax.from_json(
11660       json.throw_keyword, position, source);
11661     position += keyword.width;
11662     let expression = EditableSyntax.from_json(
11663       json.throw_expression, position, source);
11664     position += expression.width;
11665     let semicolon = EditableSyntax.from_json(
11666       json.throw_semicolon, position, source);
11667     position += semicolon.width;
11668     return new ThrowStatement(
11669         keyword,
11670         expression,
11671         semicolon);
11672   }
11673   get children_keys()
11674   {
11675     if (ThrowStatement._children_keys == null)
11676       ThrowStatement._children_keys = [
11677         'keyword',
11678         'expression',
11679         'semicolon'];
11680     return ThrowStatement._children_keys;
11681   }
11682 }
11683 class BreakStatement extends EditableSyntax
11684 {
11685   constructor(
11686     keyword,
11687     level,
11688     semicolon)
11689   {
11690     super('break_statement', {
11691       keyword: keyword,
11692       level: level,
11693       semicolon: semicolon });
11694   }
11695   get keyword() { return this.children.keyword; }
11696   get level() { return this.children.level; }
11697   get semicolon() { return this.children.semicolon; }
11698   with_keyword(keyword){
11699     return new BreakStatement(
11700       keyword,
11701       this.level,
11702       this.semicolon);
11703   }
11704   with_level(level){
11705     return new BreakStatement(
11706       this.keyword,
11707       level,
11708       this.semicolon);
11709   }
11710   with_semicolon(semicolon){
11711     return new BreakStatement(
11712       this.keyword,
11713       this.level,
11714       semicolon);
11715   }
11716   rewrite(rewriter, parents)
11717   {
11718     if (parents == undefined)
11719       parents = [];
11720     let new_parents = parents.slice();
11721     new_parents.push(this);
11722     var keyword = this.keyword.rewrite(rewriter, new_parents);
11723     var level = this.level.rewrite(rewriter, new_parents);
11724     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
11725     if (
11726       keyword === this.keyword &&
11727       level === this.level &&
11728       semicolon === this.semicolon)
11729     {
11730       return rewriter(this, parents);
11731     }
11732     else
11733     {
11734       return rewriter(new BreakStatement(
11735         keyword,
11736         level,
11737         semicolon), parents);
11738     }
11739   }
11740   static from_json(json, position, source)
11741   {
11742     let keyword = EditableSyntax.from_json(
11743       json.break_keyword, position, source);
11744     position += keyword.width;
11745     let level = EditableSyntax.from_json(
11746       json.break_level, position, source);
11747     position += level.width;
11748     let semicolon = EditableSyntax.from_json(
11749       json.break_semicolon, position, source);
11750     position += semicolon.width;
11751     return new BreakStatement(
11752         keyword,
11753         level,
11754         semicolon);
11755   }
11756   get children_keys()
11757   {
11758     if (BreakStatement._children_keys == null)
11759       BreakStatement._children_keys = [
11760         'keyword',
11761         'level',
11762         'semicolon'];
11763     return BreakStatement._children_keys;
11764   }
11765 }
11766 class ContinueStatement extends EditableSyntax
11767 {
11768   constructor(
11769     keyword,
11770     level,
11771     semicolon)
11772   {
11773     super('continue_statement', {
11774       keyword: keyword,
11775       level: level,
11776       semicolon: semicolon });
11777   }
11778   get keyword() { return this.children.keyword; }
11779   get level() { return this.children.level; }
11780   get semicolon() { return this.children.semicolon; }
11781   with_keyword(keyword){
11782     return new ContinueStatement(
11783       keyword,
11784       this.level,
11785       this.semicolon);
11786   }
11787   with_level(level){
11788     return new ContinueStatement(
11789       this.keyword,
11790       level,
11791       this.semicolon);
11792   }
11793   with_semicolon(semicolon){
11794     return new ContinueStatement(
11795       this.keyword,
11796       this.level,
11797       semicolon);
11798   }
11799   rewrite(rewriter, parents)
11800   {
11801     if (parents == undefined)
11802       parents = [];
11803     let new_parents = parents.slice();
11804     new_parents.push(this);
11805     var keyword = this.keyword.rewrite(rewriter, new_parents);
11806     var level = this.level.rewrite(rewriter, new_parents);
11807     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
11808     if (
11809       keyword === this.keyword &&
11810       level === this.level &&
11811       semicolon === this.semicolon)
11812     {
11813       return rewriter(this, parents);
11814     }
11815     else
11816     {
11817       return rewriter(new ContinueStatement(
11818         keyword,
11819         level,
11820         semicolon), parents);
11821     }
11822   }
11823   static from_json(json, position, source)
11824   {
11825     let keyword = EditableSyntax.from_json(
11826       json.continue_keyword, position, source);
11827     position += keyword.width;
11828     let level = EditableSyntax.from_json(
11829       json.continue_level, position, source);
11830     position += level.width;
11831     let semicolon = EditableSyntax.from_json(
11832       json.continue_semicolon, position, source);
11833     position += semicolon.width;
11834     return new ContinueStatement(
11835         keyword,
11836         level,
11837         semicolon);
11838   }
11839   get children_keys()
11840   {
11841     if (ContinueStatement._children_keys == null)
11842       ContinueStatement._children_keys = [
11843         'keyword',
11844         'level',
11845         'semicolon'];
11846     return ContinueStatement._children_keys;
11847   }
11848 }
11849 class EchoStatement extends EditableSyntax
11850 {
11851   constructor(
11852     keyword,
11853     expressions,
11854     semicolon)
11855   {
11856     super('echo_statement', {
11857       keyword: keyword,
11858       expressions: expressions,
11859       semicolon: semicolon });
11860   }
11861   get keyword() { return this.children.keyword; }
11862   get expressions() { return this.children.expressions; }
11863   get semicolon() { return this.children.semicolon; }
11864   with_keyword(keyword){
11865     return new EchoStatement(
11866       keyword,
11867       this.expressions,
11868       this.semicolon);
11869   }
11870   with_expressions(expressions){
11871     return new EchoStatement(
11872       this.keyword,
11873       expressions,
11874       this.semicolon);
11875   }
11876   with_semicolon(semicolon){
11877     return new EchoStatement(
11878       this.keyword,
11879       this.expressions,
11880       semicolon);
11881   }
11882   rewrite(rewriter, parents)
11883   {
11884     if (parents == undefined)
11885       parents = [];
11886     let new_parents = parents.slice();
11887     new_parents.push(this);
11888     var keyword = this.keyword.rewrite(rewriter, new_parents);
11889     var expressions = this.expressions.rewrite(rewriter, new_parents);
11890     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
11891     if (
11892       keyword === this.keyword &&
11893       expressions === this.expressions &&
11894       semicolon === this.semicolon)
11895     {
11896       return rewriter(this, parents);
11897     }
11898     else
11899     {
11900       return rewriter(new EchoStatement(
11901         keyword,
11902         expressions,
11903         semicolon), parents);
11904     }
11905   }
11906   static from_json(json, position, source)
11907   {
11908     let keyword = EditableSyntax.from_json(
11909       json.echo_keyword, position, source);
11910     position += keyword.width;
11911     let expressions = EditableSyntax.from_json(
11912       json.echo_expressions, position, source);
11913     position += expressions.width;
11914     let semicolon = EditableSyntax.from_json(
11915       json.echo_semicolon, position, source);
11916     position += semicolon.width;
11917     return new EchoStatement(
11918         keyword,
11919         expressions,
11920         semicolon);
11921   }
11922   get children_keys()
11923   {
11924     if (EchoStatement._children_keys == null)
11925       EchoStatement._children_keys = [
11926         'keyword',
11927         'expressions',
11928         'semicolon'];
11929     return EchoStatement._children_keys;
11930   }
11931 }
11932 class GlobalStatement extends EditableSyntax
11933 {
11934   constructor(
11935     keyword,
11936     variables,
11937     semicolon)
11938   {
11939     super('global_statement', {
11940       keyword: keyword,
11941       variables: variables,
11942       semicolon: semicolon });
11943   }
11944   get keyword() { return this.children.keyword; }
11945   get variables() { return this.children.variables; }
11946   get semicolon() { return this.children.semicolon; }
11947   with_keyword(keyword){
11948     return new GlobalStatement(
11949       keyword,
11950       this.variables,
11951       this.semicolon);
11952   }
11953   with_variables(variables){
11954     return new GlobalStatement(
11955       this.keyword,
11956       variables,
11957       this.semicolon);
11958   }
11959   with_semicolon(semicolon){
11960     return new GlobalStatement(
11961       this.keyword,
11962       this.variables,
11963       semicolon);
11964   }
11965   rewrite(rewriter, parents)
11966   {
11967     if (parents == undefined)
11968       parents = [];
11969     let new_parents = parents.slice();
11970     new_parents.push(this);
11971     var keyword = this.keyword.rewrite(rewriter, new_parents);
11972     var variables = this.variables.rewrite(rewriter, new_parents);
11973     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
11974     if (
11975       keyword === this.keyword &&
11976       variables === this.variables &&
11977       semicolon === this.semicolon)
11978     {
11979       return rewriter(this, parents);
11980     }
11981     else
11982     {
11983       return rewriter(new GlobalStatement(
11984         keyword,
11985         variables,
11986         semicolon), parents);
11987     }
11988   }
11989   static from_json(json, position, source)
11990   {
11991     let keyword = EditableSyntax.from_json(
11992       json.global_keyword, position, source);
11993     position += keyword.width;
11994     let variables = EditableSyntax.from_json(
11995       json.global_variables, position, source);
11996     position += variables.width;
11997     let semicolon = EditableSyntax.from_json(
11998       json.global_semicolon, position, source);
11999     position += semicolon.width;
12000     return new GlobalStatement(
12001         keyword,
12002         variables,
12003         semicolon);
12004   }
12005   get children_keys()
12006   {
12007     if (GlobalStatement._children_keys == null)
12008       GlobalStatement._children_keys = [
12009         'keyword',
12010         'variables',
12011         'semicolon'];
12012     return GlobalStatement._children_keys;
12013   }
12014 }
12015 class ConcurrentStatement extends EditableSyntax
12016 {
12017   constructor(
12018     keyword,
12019     statement)
12020   {
12021     super('concurrent_statement', {
12022       keyword: keyword,
12023       statement: statement });
12024   }
12025   get keyword() { return this.children.keyword; }
12026   get statement() { return this.children.statement; }
12027   with_keyword(keyword){
12028     return new ConcurrentStatement(
12029       keyword,
12030       this.statement);
12031   }
12032   with_statement(statement){
12033     return new ConcurrentStatement(
12034       this.keyword,
12035       statement);
12036   }
12037   rewrite(rewriter, parents)
12038   {
12039     if (parents == undefined)
12040       parents = [];
12041     let new_parents = parents.slice();
12042     new_parents.push(this);
12043     var keyword = this.keyword.rewrite(rewriter, new_parents);
12044     var statement = this.statement.rewrite(rewriter, new_parents);
12045     if (
12046       keyword === this.keyword &&
12047       statement === this.statement)
12048     {
12049       return rewriter(this, parents);
12050     }
12051     else
12052     {
12053       return rewriter(new ConcurrentStatement(
12054         keyword,
12055         statement), parents);
12056     }
12057   }
12058   static from_json(json, position, source)
12059   {
12060     let keyword = EditableSyntax.from_json(
12061       json.concurrent_keyword, position, source);
12062     position += keyword.width;
12063     let statement = EditableSyntax.from_json(
12064       json.concurrent_statement, position, source);
12065     position += statement.width;
12066     return new ConcurrentStatement(
12067         keyword,
12068         statement);
12069   }
12070   get children_keys()
12071   {
12072     if (ConcurrentStatement._children_keys == null)
12073       ConcurrentStatement._children_keys = [
12074         'keyword',
12075         'statement'];
12076     return ConcurrentStatement._children_keys;
12077   }
12078 }
12079 class SimpleInitializer extends EditableSyntax
12080 {
12081   constructor(
12082     equal,
12083     value)
12084   {
12085     super('simple_initializer', {
12086       equal: equal,
12087       value: value });
12088   }
12089   get equal() { return this.children.equal; }
12090   get value() { return this.children.value; }
12091   with_equal(equal){
12092     return new SimpleInitializer(
12093       equal,
12094       this.value);
12095   }
12096   with_value(value){
12097     return new SimpleInitializer(
12098       this.equal,
12099       value);
12100   }
12101   rewrite(rewriter, parents)
12102   {
12103     if (parents == undefined)
12104       parents = [];
12105     let new_parents = parents.slice();
12106     new_parents.push(this);
12107     var equal = this.equal.rewrite(rewriter, new_parents);
12108     var value = this.value.rewrite(rewriter, new_parents);
12109     if (
12110       equal === this.equal &&
12111       value === this.value)
12112     {
12113       return rewriter(this, parents);
12114     }
12115     else
12116     {
12117       return rewriter(new SimpleInitializer(
12118         equal,
12119         value), parents);
12120     }
12121   }
12122   static from_json(json, position, source)
12123   {
12124     let equal = EditableSyntax.from_json(
12125       json.simple_initializer_equal, position, source);
12126     position += equal.width;
12127     let value = EditableSyntax.from_json(
12128       json.simple_initializer_value, position, source);
12129     position += value.width;
12130     return new SimpleInitializer(
12131         equal,
12132         value);
12133   }
12134   get children_keys()
12135   {
12136     if (SimpleInitializer._children_keys == null)
12137       SimpleInitializer._children_keys = [
12138         'equal',
12139         'value'];
12140     return SimpleInitializer._children_keys;
12141   }
12142 }
12143 class AnonymousClass extends EditableSyntax
12144 {
12145   constructor(
12146     class_keyword,
12147     left_paren,
12148     argument_list,
12149     right_paren,
12150     extends_keyword,
12151     extends_list,
12152     implements_keyword,
12153     implements_list,
12154     body)
12155   {
12156     super('anonymous_class', {
12157       class_keyword: class_keyword,
12158       left_paren: left_paren,
12159       argument_list: argument_list,
12160       right_paren: right_paren,
12161       extends_keyword: extends_keyword,
12162       extends_list: extends_list,
12163       implements_keyword: implements_keyword,
12164       implements_list: implements_list,
12165       body: body });
12166   }
12167   get class_keyword() { return this.children.class_keyword; }
12168   get left_paren() { return this.children.left_paren; }
12169   get argument_list() { return this.children.argument_list; }
12170   get right_paren() { return this.children.right_paren; }
12171   get extends_keyword() { return this.children.extends_keyword; }
12172   get extends_list() { return this.children.extends_list; }
12173   get implements_keyword() { return this.children.implements_keyword; }
12174   get implements_list() { return this.children.implements_list; }
12175   get body() { return this.children.body; }
12176   with_class_keyword(class_keyword){
12177     return new AnonymousClass(
12178       class_keyword,
12179       this.left_paren,
12180       this.argument_list,
12181       this.right_paren,
12182       this.extends_keyword,
12183       this.extends_list,
12184       this.implements_keyword,
12185       this.implements_list,
12186       this.body);
12187   }
12188   with_left_paren(left_paren){
12189     return new AnonymousClass(
12190       this.class_keyword,
12191       left_paren,
12192       this.argument_list,
12193       this.right_paren,
12194       this.extends_keyword,
12195       this.extends_list,
12196       this.implements_keyword,
12197       this.implements_list,
12198       this.body);
12199   }
12200   with_argument_list(argument_list){
12201     return new AnonymousClass(
12202       this.class_keyword,
12203       this.left_paren,
12204       argument_list,
12205       this.right_paren,
12206       this.extends_keyword,
12207       this.extends_list,
12208       this.implements_keyword,
12209       this.implements_list,
12210       this.body);
12211   }
12212   with_right_paren(right_paren){
12213     return new AnonymousClass(
12214       this.class_keyword,
12215       this.left_paren,
12216       this.argument_list,
12217       right_paren,
12218       this.extends_keyword,
12219       this.extends_list,
12220       this.implements_keyword,
12221       this.implements_list,
12222       this.body);
12223   }
12224   with_extends_keyword(extends_keyword){
12225     return new AnonymousClass(
12226       this.class_keyword,
12227       this.left_paren,
12228       this.argument_list,
12229       this.right_paren,
12230       extends_keyword,
12231       this.extends_list,
12232       this.implements_keyword,
12233       this.implements_list,
12234       this.body);
12235   }
12236   with_extends_list(extends_list){
12237     return new AnonymousClass(
12238       this.class_keyword,
12239       this.left_paren,
12240       this.argument_list,
12241       this.right_paren,
12242       this.extends_keyword,
12243       extends_list,
12244       this.implements_keyword,
12245       this.implements_list,
12246       this.body);
12247   }
12248   with_implements_keyword(implements_keyword){
12249     return new AnonymousClass(
12250       this.class_keyword,
12251       this.left_paren,
12252       this.argument_list,
12253       this.right_paren,
12254       this.extends_keyword,
12255       this.extends_list,
12256       implements_keyword,
12257       this.implements_list,
12258       this.body);
12259   }
12260   with_implements_list(implements_list){
12261     return new AnonymousClass(
12262       this.class_keyword,
12263       this.left_paren,
12264       this.argument_list,
12265       this.right_paren,
12266       this.extends_keyword,
12267       this.extends_list,
12268       this.implements_keyword,
12269       implements_list,
12270       this.body);
12271   }
12272   with_body(body){
12273     return new AnonymousClass(
12274       this.class_keyword,
12275       this.left_paren,
12276       this.argument_list,
12277       this.right_paren,
12278       this.extends_keyword,
12279       this.extends_list,
12280       this.implements_keyword,
12281       this.implements_list,
12282       body);
12283   }
12284   rewrite(rewriter, parents)
12285   {
12286     if (parents == undefined)
12287       parents = [];
12288     let new_parents = parents.slice();
12289     new_parents.push(this);
12290     var class_keyword = this.class_keyword.rewrite(rewriter, new_parents);
12291     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
12292     var argument_list = this.argument_list.rewrite(rewriter, new_parents);
12293     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
12294     var extends_keyword = this.extends_keyword.rewrite(rewriter, new_parents);
12295     var extends_list = this.extends_list.rewrite(rewriter, new_parents);
12296     var implements_keyword = this.implements_keyword.rewrite(rewriter, new_parents);
12297     var implements_list = this.implements_list.rewrite(rewriter, new_parents);
12298     var body = this.body.rewrite(rewriter, new_parents);
12299     if (
12300       class_keyword === this.class_keyword &&
12301       left_paren === this.left_paren &&
12302       argument_list === this.argument_list &&
12303       right_paren === this.right_paren &&
12304       extends_keyword === this.extends_keyword &&
12305       extends_list === this.extends_list &&
12306       implements_keyword === this.implements_keyword &&
12307       implements_list === this.implements_list &&
12308       body === this.body)
12309     {
12310       return rewriter(this, parents);
12311     }
12312     else
12313     {
12314       return rewriter(new AnonymousClass(
12315         class_keyword,
12316         left_paren,
12317         argument_list,
12318         right_paren,
12319         extends_keyword,
12320         extends_list,
12321         implements_keyword,
12322         implements_list,
12323         body), parents);
12324     }
12325   }
12326   static from_json(json, position, source)
12327   {
12328     let class_keyword = EditableSyntax.from_json(
12329       json.anonymous_class_class_keyword, position, source);
12330     position += class_keyword.width;
12331     let left_paren = EditableSyntax.from_json(
12332       json.anonymous_class_left_paren, position, source);
12333     position += left_paren.width;
12334     let argument_list = EditableSyntax.from_json(
12335       json.anonymous_class_argument_list, position, source);
12336     position += argument_list.width;
12337     let right_paren = EditableSyntax.from_json(
12338       json.anonymous_class_right_paren, position, source);
12339     position += right_paren.width;
12340     let extends_keyword = EditableSyntax.from_json(
12341       json.anonymous_class_extends_keyword, position, source);
12342     position += extends_keyword.width;
12343     let extends_list = EditableSyntax.from_json(
12344       json.anonymous_class_extends_list, position, source);
12345     position += extends_list.width;
12346     let implements_keyword = EditableSyntax.from_json(
12347       json.anonymous_class_implements_keyword, position, source);
12348     position += implements_keyword.width;
12349     let implements_list = EditableSyntax.from_json(
12350       json.anonymous_class_implements_list, position, source);
12351     position += implements_list.width;
12352     let body = EditableSyntax.from_json(
12353       json.anonymous_class_body, position, source);
12354     position += body.width;
12355     return new AnonymousClass(
12356         class_keyword,
12357         left_paren,
12358         argument_list,
12359         right_paren,
12360         extends_keyword,
12361         extends_list,
12362         implements_keyword,
12363         implements_list,
12364         body);
12365   }
12366   get children_keys()
12367   {
12368     if (AnonymousClass._children_keys == null)
12369       AnonymousClass._children_keys = [
12370         'class_keyword',
12371         'left_paren',
12372         'argument_list',
12373         'right_paren',
12374         'extends_keyword',
12375         'extends_list',
12376         'implements_keyword',
12377         'implements_list',
12378         'body'];
12379     return AnonymousClass._children_keys;
12380   }
12381 }
12382 class AnonymousFunction extends EditableSyntax
12383 {
12384   constructor(
12385     attribute_spec,
12386     static_keyword,
12387     async_keyword,
12388     coroutine_keyword,
12389     function_keyword,
12390     left_paren,
12391     parameters,
12392     right_paren,
12393     colon,
12394     type,
12395     use,
12396     body)
12397   {
12398     super('anonymous_function', {
12399       attribute_spec: attribute_spec,
12400       static_keyword: static_keyword,
12401       async_keyword: async_keyword,
12402       coroutine_keyword: coroutine_keyword,
12403       function_keyword: function_keyword,
12404       left_paren: left_paren,
12405       parameters: parameters,
12406       right_paren: right_paren,
12407       colon: colon,
12408       type: type,
12409       use: use,
12410       body: body });
12411   }
12412   get attribute_spec() { return this.children.attribute_spec; }
12413   get static_keyword() { return this.children.static_keyword; }
12414   get async_keyword() { return this.children.async_keyword; }
12415   get coroutine_keyword() { return this.children.coroutine_keyword; }
12416   get function_keyword() { return this.children.function_keyword; }
12417   get left_paren() { return this.children.left_paren; }
12418   get parameters() { return this.children.parameters; }
12419   get right_paren() { return this.children.right_paren; }
12420   get colon() { return this.children.colon; }
12421   get type() { return this.children.type; }
12422   get use() { return this.children.use; }
12423   get body() { return this.children.body; }
12424   with_attribute_spec(attribute_spec){
12425     return new AnonymousFunction(
12426       attribute_spec,
12427       this.static_keyword,
12428       this.async_keyword,
12429       this.coroutine_keyword,
12430       this.function_keyword,
12431       this.left_paren,
12432       this.parameters,
12433       this.right_paren,
12434       this.colon,
12435       this.type,
12436       this.use,
12437       this.body);
12438   }
12439   with_static_keyword(static_keyword){
12440     return new AnonymousFunction(
12441       this.attribute_spec,
12442       static_keyword,
12443       this.async_keyword,
12444       this.coroutine_keyword,
12445       this.function_keyword,
12446       this.left_paren,
12447       this.parameters,
12448       this.right_paren,
12449       this.colon,
12450       this.type,
12451       this.use,
12452       this.body);
12453   }
12454   with_async_keyword(async_keyword){
12455     return new AnonymousFunction(
12456       this.attribute_spec,
12457       this.static_keyword,
12458       async_keyword,
12459       this.coroutine_keyword,
12460       this.function_keyword,
12461       this.left_paren,
12462       this.parameters,
12463       this.right_paren,
12464       this.colon,
12465       this.type,
12466       this.use,
12467       this.body);
12468   }
12469   with_coroutine_keyword(coroutine_keyword){
12470     return new AnonymousFunction(
12471       this.attribute_spec,
12472       this.static_keyword,
12473       this.async_keyword,
12474       coroutine_keyword,
12475       this.function_keyword,
12476       this.left_paren,
12477       this.parameters,
12478       this.right_paren,
12479       this.colon,
12480       this.type,
12481       this.use,
12482       this.body);
12483   }
12484   with_function_keyword(function_keyword){
12485     return new AnonymousFunction(
12486       this.attribute_spec,
12487       this.static_keyword,
12488       this.async_keyword,
12489       this.coroutine_keyword,
12490       function_keyword,
12491       this.left_paren,
12492       this.parameters,
12493       this.right_paren,
12494       this.colon,
12495       this.type,
12496       this.use,
12497       this.body);
12498   }
12499   with_left_paren(left_paren){
12500     return new AnonymousFunction(
12501       this.attribute_spec,
12502       this.static_keyword,
12503       this.async_keyword,
12504       this.coroutine_keyword,
12505       this.function_keyword,
12506       left_paren,
12507       this.parameters,
12508       this.right_paren,
12509       this.colon,
12510       this.type,
12511       this.use,
12512       this.body);
12513   }
12514   with_parameters(parameters){
12515     return new AnonymousFunction(
12516       this.attribute_spec,
12517       this.static_keyword,
12518       this.async_keyword,
12519       this.coroutine_keyword,
12520       this.function_keyword,
12521       this.left_paren,
12522       parameters,
12523       this.right_paren,
12524       this.colon,
12525       this.type,
12526       this.use,
12527       this.body);
12528   }
12529   with_right_paren(right_paren){
12530     return new AnonymousFunction(
12531       this.attribute_spec,
12532       this.static_keyword,
12533       this.async_keyword,
12534       this.coroutine_keyword,
12535       this.function_keyword,
12536       this.left_paren,
12537       this.parameters,
12538       right_paren,
12539       this.colon,
12540       this.type,
12541       this.use,
12542       this.body);
12543   }
12544   with_colon(colon){
12545     return new AnonymousFunction(
12546       this.attribute_spec,
12547       this.static_keyword,
12548       this.async_keyword,
12549       this.coroutine_keyword,
12550       this.function_keyword,
12551       this.left_paren,
12552       this.parameters,
12553       this.right_paren,
12554       colon,
12555       this.type,
12556       this.use,
12557       this.body);
12558   }
12559   with_type(type){
12560     return new AnonymousFunction(
12561       this.attribute_spec,
12562       this.static_keyword,
12563       this.async_keyword,
12564       this.coroutine_keyword,
12565       this.function_keyword,
12566       this.left_paren,
12567       this.parameters,
12568       this.right_paren,
12569       this.colon,
12570       type,
12571       this.use,
12572       this.body);
12573   }
12574   with_use(use){
12575     return new AnonymousFunction(
12576       this.attribute_spec,
12577       this.static_keyword,
12578       this.async_keyword,
12579       this.coroutine_keyword,
12580       this.function_keyword,
12581       this.left_paren,
12582       this.parameters,
12583       this.right_paren,
12584       this.colon,
12585       this.type,
12586       use,
12587       this.body);
12588   }
12589   with_body(body){
12590     return new AnonymousFunction(
12591       this.attribute_spec,
12592       this.static_keyword,
12593       this.async_keyword,
12594       this.coroutine_keyword,
12595       this.function_keyword,
12596       this.left_paren,
12597       this.parameters,
12598       this.right_paren,
12599       this.colon,
12600       this.type,
12601       this.use,
12602       body);
12603   }
12604   rewrite(rewriter, parents)
12605   {
12606     if (parents == undefined)
12607       parents = [];
12608     let new_parents = parents.slice();
12609     new_parents.push(this);
12610     var attribute_spec = this.attribute_spec.rewrite(rewriter, new_parents);
12611     var static_keyword = this.static_keyword.rewrite(rewriter, new_parents);
12612     var async_keyword = this.async_keyword.rewrite(rewriter, new_parents);
12613     var coroutine_keyword = this.coroutine_keyword.rewrite(rewriter, new_parents);
12614     var function_keyword = this.function_keyword.rewrite(rewriter, new_parents);
12615     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
12616     var parameters = this.parameters.rewrite(rewriter, new_parents);
12617     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
12618     var colon = this.colon.rewrite(rewriter, new_parents);
12619     var type = this.type.rewrite(rewriter, new_parents);
12620     var use = this.use.rewrite(rewriter, new_parents);
12621     var body = this.body.rewrite(rewriter, new_parents);
12622     if (
12623       attribute_spec === this.attribute_spec &&
12624       static_keyword === this.static_keyword &&
12625       async_keyword === this.async_keyword &&
12626       coroutine_keyword === this.coroutine_keyword &&
12627       function_keyword === this.function_keyword &&
12628       left_paren === this.left_paren &&
12629       parameters === this.parameters &&
12630       right_paren === this.right_paren &&
12631       colon === this.colon &&
12632       type === this.type &&
12633       use === this.use &&
12634       body === this.body)
12635     {
12636       return rewriter(this, parents);
12637     }
12638     else
12639     {
12640       return rewriter(new AnonymousFunction(
12641         attribute_spec,
12642         static_keyword,
12643         async_keyword,
12644         coroutine_keyword,
12645         function_keyword,
12646         left_paren,
12647         parameters,
12648         right_paren,
12649         colon,
12650         type,
12651         use,
12652         body), parents);
12653     }
12654   }
12655   static from_json(json, position, source)
12656   {
12657     let attribute_spec = EditableSyntax.from_json(
12658       json.anonymous_attribute_spec, position, source);
12659     position += attribute_spec.width;
12660     let static_keyword = EditableSyntax.from_json(
12661       json.anonymous_static_keyword, position, source);
12662     position += static_keyword.width;
12663     let async_keyword = EditableSyntax.from_json(
12664       json.anonymous_async_keyword, position, source);
12665     position += async_keyword.width;
12666     let coroutine_keyword = EditableSyntax.from_json(
12667       json.anonymous_coroutine_keyword, position, source);
12668     position += coroutine_keyword.width;
12669     let function_keyword = EditableSyntax.from_json(
12670       json.anonymous_function_keyword, position, source);
12671     position += function_keyword.width;
12672     let left_paren = EditableSyntax.from_json(
12673       json.anonymous_left_paren, position, source);
12674     position += left_paren.width;
12675     let parameters = EditableSyntax.from_json(
12676       json.anonymous_parameters, position, source);
12677     position += parameters.width;
12678     let right_paren = EditableSyntax.from_json(
12679       json.anonymous_right_paren, position, source);
12680     position += right_paren.width;
12681     let colon = EditableSyntax.from_json(
12682       json.anonymous_colon, position, source);
12683     position += colon.width;
12684     let type = EditableSyntax.from_json(
12685       json.anonymous_type, position, source);
12686     position += type.width;
12687     let use = EditableSyntax.from_json(
12688       json.anonymous_use, position, source);
12689     position += use.width;
12690     let body = EditableSyntax.from_json(
12691       json.anonymous_body, position, source);
12692     position += body.width;
12693     return new AnonymousFunction(
12694         attribute_spec,
12695         static_keyword,
12696         async_keyword,
12697         coroutine_keyword,
12698         function_keyword,
12699         left_paren,
12700         parameters,
12701         right_paren,
12702         colon,
12703         type,
12704         use,
12705         body);
12706   }
12707   get children_keys()
12708   {
12709     if (AnonymousFunction._children_keys == null)
12710       AnonymousFunction._children_keys = [
12711         'attribute_spec',
12712         'static_keyword',
12713         'async_keyword',
12714         'coroutine_keyword',
12715         'function_keyword',
12716         'left_paren',
12717         'parameters',
12718         'right_paren',
12719         'colon',
12720         'type',
12721         'use',
12722         'body'];
12723     return AnonymousFunction._children_keys;
12724   }
12725 }
12726 class Php7AnonymousFunction extends EditableSyntax
12727 {
12728   constructor(
12729     attribute_spec,
12730     static_keyword,
12731     async_keyword,
12732     coroutine_keyword,
12733     function_keyword,
12734     left_paren,
12735     parameters,
12736     right_paren,
12737     use,
12738     colon,
12739     type,
12740     body)
12741   {
12742     super('php7_anonymous_function', {
12743       attribute_spec: attribute_spec,
12744       static_keyword: static_keyword,
12745       async_keyword: async_keyword,
12746       coroutine_keyword: coroutine_keyword,
12747       function_keyword: function_keyword,
12748       left_paren: left_paren,
12749       parameters: parameters,
12750       right_paren: right_paren,
12751       use: use,
12752       colon: colon,
12753       type: type,
12754       body: body });
12755   }
12756   get attribute_spec() { return this.children.attribute_spec; }
12757   get static_keyword() { return this.children.static_keyword; }
12758   get async_keyword() { return this.children.async_keyword; }
12759   get coroutine_keyword() { return this.children.coroutine_keyword; }
12760   get function_keyword() { return this.children.function_keyword; }
12761   get left_paren() { return this.children.left_paren; }
12762   get parameters() { return this.children.parameters; }
12763   get right_paren() { return this.children.right_paren; }
12764   get use() { return this.children.use; }
12765   get colon() { return this.children.colon; }
12766   get type() { return this.children.type; }
12767   get body() { return this.children.body; }
12768   with_attribute_spec(attribute_spec){
12769     return new Php7AnonymousFunction(
12770       attribute_spec,
12771       this.static_keyword,
12772       this.async_keyword,
12773       this.coroutine_keyword,
12774       this.function_keyword,
12775       this.left_paren,
12776       this.parameters,
12777       this.right_paren,
12778       this.use,
12779       this.colon,
12780       this.type,
12781       this.body);
12782   }
12783   with_static_keyword(static_keyword){
12784     return new Php7AnonymousFunction(
12785       this.attribute_spec,
12786       static_keyword,
12787       this.async_keyword,
12788       this.coroutine_keyword,
12789       this.function_keyword,
12790       this.left_paren,
12791       this.parameters,
12792       this.right_paren,
12793       this.use,
12794       this.colon,
12795       this.type,
12796       this.body);
12797   }
12798   with_async_keyword(async_keyword){
12799     return new Php7AnonymousFunction(
12800       this.attribute_spec,
12801       this.static_keyword,
12802       async_keyword,
12803       this.coroutine_keyword,
12804       this.function_keyword,
12805       this.left_paren,
12806       this.parameters,
12807       this.right_paren,
12808       this.use,
12809       this.colon,
12810       this.type,
12811       this.body);
12812   }
12813   with_coroutine_keyword(coroutine_keyword){
12814     return new Php7AnonymousFunction(
12815       this.attribute_spec,
12816       this.static_keyword,
12817       this.async_keyword,
12818       coroutine_keyword,
12819       this.function_keyword,
12820       this.left_paren,
12821       this.parameters,
12822       this.right_paren,
12823       this.use,
12824       this.colon,
12825       this.type,
12826       this.body);
12827   }
12828   with_function_keyword(function_keyword){
12829     return new Php7AnonymousFunction(
12830       this.attribute_spec,
12831       this.static_keyword,
12832       this.async_keyword,
12833       this.coroutine_keyword,
12834       function_keyword,
12835       this.left_paren,
12836       this.parameters,
12837       this.right_paren,
12838       this.use,
12839       this.colon,
12840       this.type,
12841       this.body);
12842   }
12843   with_left_paren(left_paren){
12844     return new Php7AnonymousFunction(
12845       this.attribute_spec,
12846       this.static_keyword,
12847       this.async_keyword,
12848       this.coroutine_keyword,
12849       this.function_keyword,
12850       left_paren,
12851       this.parameters,
12852       this.right_paren,
12853       this.use,
12854       this.colon,
12855       this.type,
12856       this.body);
12857   }
12858   with_parameters(parameters){
12859     return new Php7AnonymousFunction(
12860       this.attribute_spec,
12861       this.static_keyword,
12862       this.async_keyword,
12863       this.coroutine_keyword,
12864       this.function_keyword,
12865       this.left_paren,
12866       parameters,
12867       this.right_paren,
12868       this.use,
12869       this.colon,
12870       this.type,
12871       this.body);
12872   }
12873   with_right_paren(right_paren){
12874     return new Php7AnonymousFunction(
12875       this.attribute_spec,
12876       this.static_keyword,
12877       this.async_keyword,
12878       this.coroutine_keyword,
12879       this.function_keyword,
12880       this.left_paren,
12881       this.parameters,
12882       right_paren,
12883       this.use,
12884       this.colon,
12885       this.type,
12886       this.body);
12887   }
12888   with_use(use){
12889     return new Php7AnonymousFunction(
12890       this.attribute_spec,
12891       this.static_keyword,
12892       this.async_keyword,
12893       this.coroutine_keyword,
12894       this.function_keyword,
12895       this.left_paren,
12896       this.parameters,
12897       this.right_paren,
12898       use,
12899       this.colon,
12900       this.type,
12901       this.body);
12902   }
12903   with_colon(colon){
12904     return new Php7AnonymousFunction(
12905       this.attribute_spec,
12906       this.static_keyword,
12907       this.async_keyword,
12908       this.coroutine_keyword,
12909       this.function_keyword,
12910       this.left_paren,
12911       this.parameters,
12912       this.right_paren,
12913       this.use,
12914       colon,
12915       this.type,
12916       this.body);
12917   }
12918   with_type(type){
12919     return new Php7AnonymousFunction(
12920       this.attribute_spec,
12921       this.static_keyword,
12922       this.async_keyword,
12923       this.coroutine_keyword,
12924       this.function_keyword,
12925       this.left_paren,
12926       this.parameters,
12927       this.right_paren,
12928       this.use,
12929       this.colon,
12930       type,
12931       this.body);
12932   }
12933   with_body(body){
12934     return new Php7AnonymousFunction(
12935       this.attribute_spec,
12936       this.static_keyword,
12937       this.async_keyword,
12938       this.coroutine_keyword,
12939       this.function_keyword,
12940       this.left_paren,
12941       this.parameters,
12942       this.right_paren,
12943       this.use,
12944       this.colon,
12945       this.type,
12946       body);
12947   }
12948   rewrite(rewriter, parents)
12949   {
12950     if (parents == undefined)
12951       parents = [];
12952     let new_parents = parents.slice();
12953     new_parents.push(this);
12954     var attribute_spec = this.attribute_spec.rewrite(rewriter, new_parents);
12955     var static_keyword = this.static_keyword.rewrite(rewriter, new_parents);
12956     var async_keyword = this.async_keyword.rewrite(rewriter, new_parents);
12957     var coroutine_keyword = this.coroutine_keyword.rewrite(rewriter, new_parents);
12958     var function_keyword = this.function_keyword.rewrite(rewriter, new_parents);
12959     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
12960     var parameters = this.parameters.rewrite(rewriter, new_parents);
12961     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
12962     var use = this.use.rewrite(rewriter, new_parents);
12963     var colon = this.colon.rewrite(rewriter, new_parents);
12964     var type = this.type.rewrite(rewriter, new_parents);
12965     var body = this.body.rewrite(rewriter, new_parents);
12966     if (
12967       attribute_spec === this.attribute_spec &&
12968       static_keyword === this.static_keyword &&
12969       async_keyword === this.async_keyword &&
12970       coroutine_keyword === this.coroutine_keyword &&
12971       function_keyword === this.function_keyword &&
12972       left_paren === this.left_paren &&
12973       parameters === this.parameters &&
12974       right_paren === this.right_paren &&
12975       use === this.use &&
12976       colon === this.colon &&
12977       type === this.type &&
12978       body === this.body)
12979     {
12980       return rewriter(this, parents);
12981     }
12982     else
12983     {
12984       return rewriter(new Php7AnonymousFunction(
12985         attribute_spec,
12986         static_keyword,
12987         async_keyword,
12988         coroutine_keyword,
12989         function_keyword,
12990         left_paren,
12991         parameters,
12992         right_paren,
12993         use,
12994         colon,
12995         type,
12996         body), parents);
12997     }
12998   }
12999   static from_json(json, position, source)
13000   {
13001     let attribute_spec = EditableSyntax.from_json(
13002       json.php7_anonymous_attribute_spec, position, source);
13003     position += attribute_spec.width;
13004     let static_keyword = EditableSyntax.from_json(
13005       json.php7_anonymous_static_keyword, position, source);
13006     position += static_keyword.width;
13007     let async_keyword = EditableSyntax.from_json(
13008       json.php7_anonymous_async_keyword, position, source);
13009     position += async_keyword.width;
13010     let coroutine_keyword = EditableSyntax.from_json(
13011       json.php7_anonymous_coroutine_keyword, position, source);
13012     position += coroutine_keyword.width;
13013     let function_keyword = EditableSyntax.from_json(
13014       json.php7_anonymous_function_keyword, position, source);
13015     position += function_keyword.width;
13016     let left_paren = EditableSyntax.from_json(
13017       json.php7_anonymous_left_paren, position, source);
13018     position += left_paren.width;
13019     let parameters = EditableSyntax.from_json(
13020       json.php7_anonymous_parameters, position, source);
13021     position += parameters.width;
13022     let right_paren = EditableSyntax.from_json(
13023       json.php7_anonymous_right_paren, position, source);
13024     position += right_paren.width;
13025     let use = EditableSyntax.from_json(
13026       json.php7_anonymous_use, position, source);
13027     position += use.width;
13028     let colon = EditableSyntax.from_json(
13029       json.php7_anonymous_colon, position, source);
13030     position += colon.width;
13031     let type = EditableSyntax.from_json(
13032       json.php7_anonymous_type, position, source);
13033     position += type.width;
13034     let body = EditableSyntax.from_json(
13035       json.php7_anonymous_body, position, source);
13036     position += body.width;
13037     return new Php7AnonymousFunction(
13038         attribute_spec,
13039         static_keyword,
13040         async_keyword,
13041         coroutine_keyword,
13042         function_keyword,
13043         left_paren,
13044         parameters,
13045         right_paren,
13046         use,
13047         colon,
13048         type,
13049         body);
13050   }
13051   get children_keys()
13052   {
13053     if (Php7AnonymousFunction._children_keys == null)
13054       Php7AnonymousFunction._children_keys = [
13055         'attribute_spec',
13056         'static_keyword',
13057         'async_keyword',
13058         'coroutine_keyword',
13059         'function_keyword',
13060         'left_paren',
13061         'parameters',
13062         'right_paren',
13063         'use',
13064         'colon',
13065         'type',
13066         'body'];
13067     return Php7AnonymousFunction._children_keys;
13068   }
13069 }
13070 class AnonymousFunctionUseClause extends EditableSyntax
13071 {
13072   constructor(
13073     keyword,
13074     left_paren,
13075     variables,
13076     right_paren)
13077   {
13078     super('anonymous_function_use_clause', {
13079       keyword: keyword,
13080       left_paren: left_paren,
13081       variables: variables,
13082       right_paren: right_paren });
13083   }
13084   get keyword() { return this.children.keyword; }
13085   get left_paren() { return this.children.left_paren; }
13086   get variables() { return this.children.variables; }
13087   get right_paren() { return this.children.right_paren; }
13088   with_keyword(keyword){
13089     return new AnonymousFunctionUseClause(
13090       keyword,
13091       this.left_paren,
13092       this.variables,
13093       this.right_paren);
13094   }
13095   with_left_paren(left_paren){
13096     return new AnonymousFunctionUseClause(
13097       this.keyword,
13098       left_paren,
13099       this.variables,
13100       this.right_paren);
13101   }
13102   with_variables(variables){
13103     return new AnonymousFunctionUseClause(
13104       this.keyword,
13105       this.left_paren,
13106       variables,
13107       this.right_paren);
13108   }
13109   with_right_paren(right_paren){
13110     return new AnonymousFunctionUseClause(
13111       this.keyword,
13112       this.left_paren,
13113       this.variables,
13114       right_paren);
13115   }
13116   rewrite(rewriter, parents)
13117   {
13118     if (parents == undefined)
13119       parents = [];
13120     let new_parents = parents.slice();
13121     new_parents.push(this);
13122     var keyword = this.keyword.rewrite(rewriter, new_parents);
13123     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
13124     var variables = this.variables.rewrite(rewriter, new_parents);
13125     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
13126     if (
13127       keyword === this.keyword &&
13128       left_paren === this.left_paren &&
13129       variables === this.variables &&
13130       right_paren === this.right_paren)
13131     {
13132       return rewriter(this, parents);
13133     }
13134     else
13135     {
13136       return rewriter(new AnonymousFunctionUseClause(
13137         keyword,
13138         left_paren,
13139         variables,
13140         right_paren), parents);
13141     }
13142   }
13143   static from_json(json, position, source)
13144   {
13145     let keyword = EditableSyntax.from_json(
13146       json.anonymous_use_keyword, position, source);
13147     position += keyword.width;
13148     let left_paren = EditableSyntax.from_json(
13149       json.anonymous_use_left_paren, position, source);
13150     position += left_paren.width;
13151     let variables = EditableSyntax.from_json(
13152       json.anonymous_use_variables, position, source);
13153     position += variables.width;
13154     let right_paren = EditableSyntax.from_json(
13155       json.anonymous_use_right_paren, position, source);
13156     position += right_paren.width;
13157     return new AnonymousFunctionUseClause(
13158         keyword,
13159         left_paren,
13160         variables,
13161         right_paren);
13162   }
13163   get children_keys()
13164   {
13165     if (AnonymousFunctionUseClause._children_keys == null)
13166       AnonymousFunctionUseClause._children_keys = [
13167         'keyword',
13168         'left_paren',
13169         'variables',
13170         'right_paren'];
13171     return AnonymousFunctionUseClause._children_keys;
13172   }
13173 }
13174 class LambdaExpression extends EditableSyntax
13175 {
13176   constructor(
13177     attribute_spec,
13178     async,
13179     coroutine,
13180     signature,
13181     arrow,
13182     body)
13183   {
13184     super('lambda_expression', {
13185       attribute_spec: attribute_spec,
13186       async: async,
13187       coroutine: coroutine,
13188       signature: signature,
13189       arrow: arrow,
13190       body: body });
13191   }
13192   get attribute_spec() { return this.children.attribute_spec; }
13193   get async() { return this.children.async; }
13194   get coroutine() { return this.children.coroutine; }
13195   get signature() { return this.children.signature; }
13196   get arrow() { return this.children.arrow; }
13197   get body() { return this.children.body; }
13198   with_attribute_spec(attribute_spec){
13199     return new LambdaExpression(
13200       attribute_spec,
13201       this.async,
13202       this.coroutine,
13203       this.signature,
13204       this.arrow,
13205       this.body);
13206   }
13207   with_async(async){
13208     return new LambdaExpression(
13209       this.attribute_spec,
13210       async,
13211       this.coroutine,
13212       this.signature,
13213       this.arrow,
13214       this.body);
13215   }
13216   with_coroutine(coroutine){
13217     return new LambdaExpression(
13218       this.attribute_spec,
13219       this.async,
13220       coroutine,
13221       this.signature,
13222       this.arrow,
13223       this.body);
13224   }
13225   with_signature(signature){
13226     return new LambdaExpression(
13227       this.attribute_spec,
13228       this.async,
13229       this.coroutine,
13230       signature,
13231       this.arrow,
13232       this.body);
13233   }
13234   with_arrow(arrow){
13235     return new LambdaExpression(
13236       this.attribute_spec,
13237       this.async,
13238       this.coroutine,
13239       this.signature,
13240       arrow,
13241       this.body);
13242   }
13243   with_body(body){
13244     return new LambdaExpression(
13245       this.attribute_spec,
13246       this.async,
13247       this.coroutine,
13248       this.signature,
13249       this.arrow,
13250       body);
13251   }
13252   rewrite(rewriter, parents)
13253   {
13254     if (parents == undefined)
13255       parents = [];
13256     let new_parents = parents.slice();
13257     new_parents.push(this);
13258     var attribute_spec = this.attribute_spec.rewrite(rewriter, new_parents);
13259     var async = this.async.rewrite(rewriter, new_parents);
13260     var coroutine = this.coroutine.rewrite(rewriter, new_parents);
13261     var signature = this.signature.rewrite(rewriter, new_parents);
13262     var arrow = this.arrow.rewrite(rewriter, new_parents);
13263     var body = this.body.rewrite(rewriter, new_parents);
13264     if (
13265       attribute_spec === this.attribute_spec &&
13266       async === this.async &&
13267       coroutine === this.coroutine &&
13268       signature === this.signature &&
13269       arrow === this.arrow &&
13270       body === this.body)
13271     {
13272       return rewriter(this, parents);
13273     }
13274     else
13275     {
13276       return rewriter(new LambdaExpression(
13277         attribute_spec,
13278         async,
13279         coroutine,
13280         signature,
13281         arrow,
13282         body), parents);
13283     }
13284   }
13285   static from_json(json, position, source)
13286   {
13287     let attribute_spec = EditableSyntax.from_json(
13288       json.lambda_attribute_spec, position, source);
13289     position += attribute_spec.width;
13290     let async = EditableSyntax.from_json(
13291       json.lambda_async, position, source);
13292     position += async.width;
13293     let coroutine = EditableSyntax.from_json(
13294       json.lambda_coroutine, position, source);
13295     position += coroutine.width;
13296     let signature = EditableSyntax.from_json(
13297       json.lambda_signature, position, source);
13298     position += signature.width;
13299     let arrow = EditableSyntax.from_json(
13300       json.lambda_arrow, position, source);
13301     position += arrow.width;
13302     let body = EditableSyntax.from_json(
13303       json.lambda_body, position, source);
13304     position += body.width;
13305     return new LambdaExpression(
13306         attribute_spec,
13307         async,
13308         coroutine,
13309         signature,
13310         arrow,
13311         body);
13312   }
13313   get children_keys()
13314   {
13315     if (LambdaExpression._children_keys == null)
13316       LambdaExpression._children_keys = [
13317         'attribute_spec',
13318         'async',
13319         'coroutine',
13320         'signature',
13321         'arrow',
13322         'body'];
13323     return LambdaExpression._children_keys;
13324   }
13325 }
13326 class LambdaSignature extends EditableSyntax
13327 {
13328   constructor(
13329     left_paren,
13330     parameters,
13331     right_paren,
13332     colon,
13333     type)
13334   {
13335     super('lambda_signature', {
13336       left_paren: left_paren,
13337       parameters: parameters,
13338       right_paren: right_paren,
13339       colon: colon,
13340       type: type });
13341   }
13342   get left_paren() { return this.children.left_paren; }
13343   get parameters() { return this.children.parameters; }
13344   get right_paren() { return this.children.right_paren; }
13345   get colon() { return this.children.colon; }
13346   get type() { return this.children.type; }
13347   with_left_paren(left_paren){
13348     return new LambdaSignature(
13349       left_paren,
13350       this.parameters,
13351       this.right_paren,
13352       this.colon,
13353       this.type);
13354   }
13355   with_parameters(parameters){
13356     return new LambdaSignature(
13357       this.left_paren,
13358       parameters,
13359       this.right_paren,
13360       this.colon,
13361       this.type);
13362   }
13363   with_right_paren(right_paren){
13364     return new LambdaSignature(
13365       this.left_paren,
13366       this.parameters,
13367       right_paren,
13368       this.colon,
13369       this.type);
13370   }
13371   with_colon(colon){
13372     return new LambdaSignature(
13373       this.left_paren,
13374       this.parameters,
13375       this.right_paren,
13376       colon,
13377       this.type);
13378   }
13379   with_type(type){
13380     return new LambdaSignature(
13381       this.left_paren,
13382       this.parameters,
13383       this.right_paren,
13384       this.colon,
13385       type);
13386   }
13387   rewrite(rewriter, parents)
13388   {
13389     if (parents == undefined)
13390       parents = [];
13391     let new_parents = parents.slice();
13392     new_parents.push(this);
13393     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
13394     var parameters = this.parameters.rewrite(rewriter, new_parents);
13395     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
13396     var colon = this.colon.rewrite(rewriter, new_parents);
13397     var type = this.type.rewrite(rewriter, new_parents);
13398     if (
13399       left_paren === this.left_paren &&
13400       parameters === this.parameters &&
13401       right_paren === this.right_paren &&
13402       colon === this.colon &&
13403       type === this.type)
13404     {
13405       return rewriter(this, parents);
13406     }
13407     else
13408     {
13409       return rewriter(new LambdaSignature(
13410         left_paren,
13411         parameters,
13412         right_paren,
13413         colon,
13414         type), parents);
13415     }
13416   }
13417   static from_json(json, position, source)
13418   {
13419     let left_paren = EditableSyntax.from_json(
13420       json.lambda_left_paren, position, source);
13421     position += left_paren.width;
13422     let parameters = EditableSyntax.from_json(
13423       json.lambda_parameters, position, source);
13424     position += parameters.width;
13425     let right_paren = EditableSyntax.from_json(
13426       json.lambda_right_paren, position, source);
13427     position += right_paren.width;
13428     let colon = EditableSyntax.from_json(
13429       json.lambda_colon, position, source);
13430     position += colon.width;
13431     let type = EditableSyntax.from_json(
13432       json.lambda_type, position, source);
13433     position += type.width;
13434     return new LambdaSignature(
13435         left_paren,
13436         parameters,
13437         right_paren,
13438         colon,
13439         type);
13440   }
13441   get children_keys()
13442   {
13443     if (LambdaSignature._children_keys == null)
13444       LambdaSignature._children_keys = [
13445         'left_paren',
13446         'parameters',
13447         'right_paren',
13448         'colon',
13449         'type'];
13450     return LambdaSignature._children_keys;
13451   }
13452 }
13453 class CastExpression extends EditableSyntax
13454 {
13455   constructor(
13456     left_paren,
13457     type,
13458     right_paren,
13459     operand)
13460   {
13461     super('cast_expression', {
13462       left_paren: left_paren,
13463       type: type,
13464       right_paren: right_paren,
13465       operand: operand });
13466   }
13467   get left_paren() { return this.children.left_paren; }
13468   get type() { return this.children.type; }
13469   get right_paren() { return this.children.right_paren; }
13470   get operand() { return this.children.operand; }
13471   with_left_paren(left_paren){
13472     return new CastExpression(
13473       left_paren,
13474       this.type,
13475       this.right_paren,
13476       this.operand);
13477   }
13478   with_type(type){
13479     return new CastExpression(
13480       this.left_paren,
13481       type,
13482       this.right_paren,
13483       this.operand);
13484   }
13485   with_right_paren(right_paren){
13486     return new CastExpression(
13487       this.left_paren,
13488       this.type,
13489       right_paren,
13490       this.operand);
13491   }
13492   with_operand(operand){
13493     return new CastExpression(
13494       this.left_paren,
13495       this.type,
13496       this.right_paren,
13497       operand);
13498   }
13499   rewrite(rewriter, parents)
13500   {
13501     if (parents == undefined)
13502       parents = [];
13503     let new_parents = parents.slice();
13504     new_parents.push(this);
13505     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
13506     var type = this.type.rewrite(rewriter, new_parents);
13507     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
13508     var operand = this.operand.rewrite(rewriter, new_parents);
13509     if (
13510       left_paren === this.left_paren &&
13511       type === this.type &&
13512       right_paren === this.right_paren &&
13513       operand === this.operand)
13514     {
13515       return rewriter(this, parents);
13516     }
13517     else
13518     {
13519       return rewriter(new CastExpression(
13520         left_paren,
13521         type,
13522         right_paren,
13523         operand), parents);
13524     }
13525   }
13526   static from_json(json, position, source)
13527   {
13528     let left_paren = EditableSyntax.from_json(
13529       json.cast_left_paren, position, source);
13530     position += left_paren.width;
13531     let type = EditableSyntax.from_json(
13532       json.cast_type, position, source);
13533     position += type.width;
13534     let right_paren = EditableSyntax.from_json(
13535       json.cast_right_paren, position, source);
13536     position += right_paren.width;
13537     let operand = EditableSyntax.from_json(
13538       json.cast_operand, position, source);
13539     position += operand.width;
13540     return new CastExpression(
13541         left_paren,
13542         type,
13543         right_paren,
13544         operand);
13545   }
13546   get children_keys()
13547   {
13548     if (CastExpression._children_keys == null)
13549       CastExpression._children_keys = [
13550         'left_paren',
13551         'type',
13552         'right_paren',
13553         'operand'];
13554     return CastExpression._children_keys;
13555   }
13556 }
13557 class ScopeResolutionExpression extends EditableSyntax
13558 {
13559   constructor(
13560     qualifier,
13561     operator,
13562     name)
13563   {
13564     super('scope_resolution_expression', {
13565       qualifier: qualifier,
13566       operator: operator,
13567       name: name });
13568   }
13569   get qualifier() { return this.children.qualifier; }
13570   get operator() { return this.children.operator; }
13571   get name() { return this.children.name; }
13572   with_qualifier(qualifier){
13573     return new ScopeResolutionExpression(
13574       qualifier,
13575       this.operator,
13576       this.name);
13577   }
13578   with_operator(operator){
13579     return new ScopeResolutionExpression(
13580       this.qualifier,
13581       operator,
13582       this.name);
13583   }
13584   with_name(name){
13585     return new ScopeResolutionExpression(
13586       this.qualifier,
13587       this.operator,
13588       name);
13589   }
13590   rewrite(rewriter, parents)
13591   {
13592     if (parents == undefined)
13593       parents = [];
13594     let new_parents = parents.slice();
13595     new_parents.push(this);
13596     var qualifier = this.qualifier.rewrite(rewriter, new_parents);
13597     var operator = this.operator.rewrite(rewriter, new_parents);
13598     var name = this.name.rewrite(rewriter, new_parents);
13599     if (
13600       qualifier === this.qualifier &&
13601       operator === this.operator &&
13602       name === this.name)
13603     {
13604       return rewriter(this, parents);
13605     }
13606     else
13607     {
13608       return rewriter(new ScopeResolutionExpression(
13609         qualifier,
13610         operator,
13611         name), parents);
13612     }
13613   }
13614   static from_json(json, position, source)
13615   {
13616     let qualifier = EditableSyntax.from_json(
13617       json.scope_resolution_qualifier, position, source);
13618     position += qualifier.width;
13619     let operator = EditableSyntax.from_json(
13620       json.scope_resolution_operator, position, source);
13621     position += operator.width;
13622     let name = EditableSyntax.from_json(
13623       json.scope_resolution_name, position, source);
13624     position += name.width;
13625     return new ScopeResolutionExpression(
13626         qualifier,
13627         operator,
13628         name);
13629   }
13630   get children_keys()
13631   {
13632     if (ScopeResolutionExpression._children_keys == null)
13633       ScopeResolutionExpression._children_keys = [
13634         'qualifier',
13635         'operator',
13636         'name'];
13637     return ScopeResolutionExpression._children_keys;
13638   }
13639 }
13640 class MemberSelectionExpression extends EditableSyntax
13641 {
13642   constructor(
13643     object,
13644     operator,
13645     name)
13646   {
13647     super('member_selection_expression', {
13648       object: object,
13649       operator: operator,
13650       name: name });
13651   }
13652   get object() { return this.children.object; }
13653   get operator() { return this.children.operator; }
13654   get name() { return this.children.name; }
13655   with_object(object){
13656     return new MemberSelectionExpression(
13657       object,
13658       this.operator,
13659       this.name);
13660   }
13661   with_operator(operator){
13662     return new MemberSelectionExpression(
13663       this.object,
13664       operator,
13665       this.name);
13666   }
13667   with_name(name){
13668     return new MemberSelectionExpression(
13669       this.object,
13670       this.operator,
13671       name);
13672   }
13673   rewrite(rewriter, parents)
13674   {
13675     if (parents == undefined)
13676       parents = [];
13677     let new_parents = parents.slice();
13678     new_parents.push(this);
13679     var object = this.object.rewrite(rewriter, new_parents);
13680     var operator = this.operator.rewrite(rewriter, new_parents);
13681     var name = this.name.rewrite(rewriter, new_parents);
13682     if (
13683       object === this.object &&
13684       operator === this.operator &&
13685       name === this.name)
13686     {
13687       return rewriter(this, parents);
13688     }
13689     else
13690     {
13691       return rewriter(new MemberSelectionExpression(
13692         object,
13693         operator,
13694         name), parents);
13695     }
13696   }
13697   static from_json(json, position, source)
13698   {
13699     let object = EditableSyntax.from_json(
13700       json.member_object, position, source);
13701     position += object.width;
13702     let operator = EditableSyntax.from_json(
13703       json.member_operator, position, source);
13704     position += operator.width;
13705     let name = EditableSyntax.from_json(
13706       json.member_name, position, source);
13707     position += name.width;
13708     return new MemberSelectionExpression(
13709         object,
13710         operator,
13711         name);
13712   }
13713   get children_keys()
13714   {
13715     if (MemberSelectionExpression._children_keys == null)
13716       MemberSelectionExpression._children_keys = [
13717         'object',
13718         'operator',
13719         'name'];
13720     return MemberSelectionExpression._children_keys;
13721   }
13722 }
13723 class SafeMemberSelectionExpression extends EditableSyntax
13724 {
13725   constructor(
13726     object,
13727     operator,
13728     name)
13729   {
13730     super('safe_member_selection_expression', {
13731       object: object,
13732       operator: operator,
13733       name: name });
13734   }
13735   get object() { return this.children.object; }
13736   get operator() { return this.children.operator; }
13737   get name() { return this.children.name; }
13738   with_object(object){
13739     return new SafeMemberSelectionExpression(
13740       object,
13741       this.operator,
13742       this.name);
13743   }
13744   with_operator(operator){
13745     return new SafeMemberSelectionExpression(
13746       this.object,
13747       operator,
13748       this.name);
13749   }
13750   with_name(name){
13751     return new SafeMemberSelectionExpression(
13752       this.object,
13753       this.operator,
13754       name);
13755   }
13756   rewrite(rewriter, parents)
13757   {
13758     if (parents == undefined)
13759       parents = [];
13760     let new_parents = parents.slice();
13761     new_parents.push(this);
13762     var object = this.object.rewrite(rewriter, new_parents);
13763     var operator = this.operator.rewrite(rewriter, new_parents);
13764     var name = this.name.rewrite(rewriter, new_parents);
13765     if (
13766       object === this.object &&
13767       operator === this.operator &&
13768       name === this.name)
13769     {
13770       return rewriter(this, parents);
13771     }
13772     else
13773     {
13774       return rewriter(new SafeMemberSelectionExpression(
13775         object,
13776         operator,
13777         name), parents);
13778     }
13779   }
13780   static from_json(json, position, source)
13781   {
13782     let object = EditableSyntax.from_json(
13783       json.safe_member_object, position, source);
13784     position += object.width;
13785     let operator = EditableSyntax.from_json(
13786       json.safe_member_operator, position, source);
13787     position += operator.width;
13788     let name = EditableSyntax.from_json(
13789       json.safe_member_name, position, source);
13790     position += name.width;
13791     return new SafeMemberSelectionExpression(
13792         object,
13793         operator,
13794         name);
13795   }
13796   get children_keys()
13797   {
13798     if (SafeMemberSelectionExpression._children_keys == null)
13799       SafeMemberSelectionExpression._children_keys = [
13800         'object',
13801         'operator',
13802         'name'];
13803     return SafeMemberSelectionExpression._children_keys;
13804   }
13805 }
13806 class EmbeddedMemberSelectionExpression extends EditableSyntax
13807 {
13808   constructor(
13809     object,
13810     operator,
13811     name)
13812   {
13813     super('embedded_member_selection_expression', {
13814       object: object,
13815       operator: operator,
13816       name: name });
13817   }
13818   get object() { return this.children.object; }
13819   get operator() { return this.children.operator; }
13820   get name() { return this.children.name; }
13821   with_object(object){
13822     return new EmbeddedMemberSelectionExpression(
13823       object,
13824       this.operator,
13825       this.name);
13826   }
13827   with_operator(operator){
13828     return new EmbeddedMemberSelectionExpression(
13829       this.object,
13830       operator,
13831       this.name);
13832   }
13833   with_name(name){
13834     return new EmbeddedMemberSelectionExpression(
13835       this.object,
13836       this.operator,
13837       name);
13838   }
13839   rewrite(rewriter, parents)
13840   {
13841     if (parents == undefined)
13842       parents = [];
13843     let new_parents = parents.slice();
13844     new_parents.push(this);
13845     var object = this.object.rewrite(rewriter, new_parents);
13846     var operator = this.operator.rewrite(rewriter, new_parents);
13847     var name = this.name.rewrite(rewriter, new_parents);
13848     if (
13849       object === this.object &&
13850       operator === this.operator &&
13851       name === this.name)
13852     {
13853       return rewriter(this, parents);
13854     }
13855     else
13856     {
13857       return rewriter(new EmbeddedMemberSelectionExpression(
13858         object,
13859         operator,
13860         name), parents);
13861     }
13862   }
13863   static from_json(json, position, source)
13864   {
13865     let object = EditableSyntax.from_json(
13866       json.embedded_member_object, position, source);
13867     position += object.width;
13868     let operator = EditableSyntax.from_json(
13869       json.embedded_member_operator, position, source);
13870     position += operator.width;
13871     let name = EditableSyntax.from_json(
13872       json.embedded_member_name, position, source);
13873     position += name.width;
13874     return new EmbeddedMemberSelectionExpression(
13875         object,
13876         operator,
13877         name);
13878   }
13879   get children_keys()
13880   {
13881     if (EmbeddedMemberSelectionExpression._children_keys == null)
13882       EmbeddedMemberSelectionExpression._children_keys = [
13883         'object',
13884         'operator',
13885         'name'];
13886     return EmbeddedMemberSelectionExpression._children_keys;
13887   }
13888 }
13889 class YieldExpression extends EditableSyntax
13890 {
13891   constructor(
13892     keyword,
13893     operand)
13894   {
13895     super('yield_expression', {
13896       keyword: keyword,
13897       operand: operand });
13898   }
13899   get keyword() { return this.children.keyword; }
13900   get operand() { return this.children.operand; }
13901   with_keyword(keyword){
13902     return new YieldExpression(
13903       keyword,
13904       this.operand);
13905   }
13906   with_operand(operand){
13907     return new YieldExpression(
13908       this.keyword,
13909       operand);
13910   }
13911   rewrite(rewriter, parents)
13912   {
13913     if (parents == undefined)
13914       parents = [];
13915     let new_parents = parents.slice();
13916     new_parents.push(this);
13917     var keyword = this.keyword.rewrite(rewriter, new_parents);
13918     var operand = this.operand.rewrite(rewriter, new_parents);
13919     if (
13920       keyword === this.keyword &&
13921       operand === this.operand)
13922     {
13923       return rewriter(this, parents);
13924     }
13925     else
13926     {
13927       return rewriter(new YieldExpression(
13928         keyword,
13929         operand), parents);
13930     }
13931   }
13932   static from_json(json, position, source)
13933   {
13934     let keyword = EditableSyntax.from_json(
13935       json.yield_keyword, position, source);
13936     position += keyword.width;
13937     let operand = EditableSyntax.from_json(
13938       json.yield_operand, position, source);
13939     position += operand.width;
13940     return new YieldExpression(
13941         keyword,
13942         operand);
13943   }
13944   get children_keys()
13945   {
13946     if (YieldExpression._children_keys == null)
13947       YieldExpression._children_keys = [
13948         'keyword',
13949         'operand'];
13950     return YieldExpression._children_keys;
13951   }
13952 }
13953 class YieldFromExpression extends EditableSyntax
13954 {
13955   constructor(
13956     yield_keyword,
13957     from_keyword,
13958     operand)
13959   {
13960     super('yield_from_expression', {
13961       yield_keyword: yield_keyword,
13962       from_keyword: from_keyword,
13963       operand: operand });
13964   }
13965   get yield_keyword() { return this.children.yield_keyword; }
13966   get from_keyword() { return this.children.from_keyword; }
13967   get operand() { return this.children.operand; }
13968   with_yield_keyword(yield_keyword){
13969     return new YieldFromExpression(
13970       yield_keyword,
13971       this.from_keyword,
13972       this.operand);
13973   }
13974   with_from_keyword(from_keyword){
13975     return new YieldFromExpression(
13976       this.yield_keyword,
13977       from_keyword,
13978       this.operand);
13979   }
13980   with_operand(operand){
13981     return new YieldFromExpression(
13982       this.yield_keyword,
13983       this.from_keyword,
13984       operand);
13985   }
13986   rewrite(rewriter, parents)
13987   {
13988     if (parents == undefined)
13989       parents = [];
13990     let new_parents = parents.slice();
13991     new_parents.push(this);
13992     var yield_keyword = this.yield_keyword.rewrite(rewriter, new_parents);
13993     var from_keyword = this.from_keyword.rewrite(rewriter, new_parents);
13994     var operand = this.operand.rewrite(rewriter, new_parents);
13995     if (
13996       yield_keyword === this.yield_keyword &&
13997       from_keyword === this.from_keyword &&
13998       operand === this.operand)
13999     {
14000       return rewriter(this, parents);
14001     }
14002     else
14003     {
14004       return rewriter(new YieldFromExpression(
14005         yield_keyword,
14006         from_keyword,
14007         operand), parents);
14008     }
14009   }
14010   static from_json(json, position, source)
14011   {
14012     let yield_keyword = EditableSyntax.from_json(
14013       json.yield_from_yield_keyword, position, source);
14014     position += yield_keyword.width;
14015     let from_keyword = EditableSyntax.from_json(
14016       json.yield_from_from_keyword, position, source);
14017     position += from_keyword.width;
14018     let operand = EditableSyntax.from_json(
14019       json.yield_from_operand, position, source);
14020     position += operand.width;
14021     return new YieldFromExpression(
14022         yield_keyword,
14023         from_keyword,
14024         operand);
14025   }
14026   get children_keys()
14027   {
14028     if (YieldFromExpression._children_keys == null)
14029       YieldFromExpression._children_keys = [
14030         'yield_keyword',
14031         'from_keyword',
14032         'operand'];
14033     return YieldFromExpression._children_keys;
14034   }
14035 }
14036 class PrefixUnaryExpression extends EditableSyntax
14037 {
14038   constructor(
14039     operator,
14040     operand)
14041   {
14042     super('prefix_unary_expression', {
14043       operator: operator,
14044       operand: operand });
14045   }
14046   get operator() { return this.children.operator; }
14047   get operand() { return this.children.operand; }
14048   with_operator(operator){
14049     return new PrefixUnaryExpression(
14050       operator,
14051       this.operand);
14052   }
14053   with_operand(operand){
14054     return new PrefixUnaryExpression(
14055       this.operator,
14056       operand);
14057   }
14058   rewrite(rewriter, parents)
14059   {
14060     if (parents == undefined)
14061       parents = [];
14062     let new_parents = parents.slice();
14063     new_parents.push(this);
14064     var operator = this.operator.rewrite(rewriter, new_parents);
14065     var operand = this.operand.rewrite(rewriter, new_parents);
14066     if (
14067       operator === this.operator &&
14068       operand === this.operand)
14069     {
14070       return rewriter(this, parents);
14071     }
14072     else
14073     {
14074       return rewriter(new PrefixUnaryExpression(
14075         operator,
14076         operand), parents);
14077     }
14078   }
14079   static from_json(json, position, source)
14080   {
14081     let operator = EditableSyntax.from_json(
14082       json.prefix_unary_operator, position, source);
14083     position += operator.width;
14084     let operand = EditableSyntax.from_json(
14085       json.prefix_unary_operand, position, source);
14086     position += operand.width;
14087     return new PrefixUnaryExpression(
14088         operator,
14089         operand);
14090   }
14091   get children_keys()
14092   {
14093     if (PrefixUnaryExpression._children_keys == null)
14094       PrefixUnaryExpression._children_keys = [
14095         'operator',
14096         'operand'];
14097     return PrefixUnaryExpression._children_keys;
14098   }
14099 }
14100 class PostfixUnaryExpression extends EditableSyntax
14101 {
14102   constructor(
14103     operand,
14104     operator)
14105   {
14106     super('postfix_unary_expression', {
14107       operand: operand,
14108       operator: operator });
14109   }
14110   get operand() { return this.children.operand; }
14111   get operator() { return this.children.operator; }
14112   with_operand(operand){
14113     return new PostfixUnaryExpression(
14114       operand,
14115       this.operator);
14116   }
14117   with_operator(operator){
14118     return new PostfixUnaryExpression(
14119       this.operand,
14120       operator);
14121   }
14122   rewrite(rewriter, parents)
14123   {
14124     if (parents == undefined)
14125       parents = [];
14126     let new_parents = parents.slice();
14127     new_parents.push(this);
14128     var operand = this.operand.rewrite(rewriter, new_parents);
14129     var operator = this.operator.rewrite(rewriter, new_parents);
14130     if (
14131       operand === this.operand &&
14132       operator === this.operator)
14133     {
14134       return rewriter(this, parents);
14135     }
14136     else
14137     {
14138       return rewriter(new PostfixUnaryExpression(
14139         operand,
14140         operator), parents);
14141     }
14142   }
14143   static from_json(json, position, source)
14144   {
14145     let operand = EditableSyntax.from_json(
14146       json.postfix_unary_operand, position, source);
14147     position += operand.width;
14148     let operator = EditableSyntax.from_json(
14149       json.postfix_unary_operator, position, source);
14150     position += operator.width;
14151     return new PostfixUnaryExpression(
14152         operand,
14153         operator);
14154   }
14155   get children_keys()
14156   {
14157     if (PostfixUnaryExpression._children_keys == null)
14158       PostfixUnaryExpression._children_keys = [
14159         'operand',
14160         'operator'];
14161     return PostfixUnaryExpression._children_keys;
14162   }
14163 }
14164 class BinaryExpression extends EditableSyntax
14165 {
14166   constructor(
14167     left_operand,
14168     operator,
14169     right_operand)
14170   {
14171     super('binary_expression', {
14172       left_operand: left_operand,
14173       operator: operator,
14174       right_operand: right_operand });
14175   }
14176   get left_operand() { return this.children.left_operand; }
14177   get operator() { return this.children.operator; }
14178   get right_operand() { return this.children.right_operand; }
14179   with_left_operand(left_operand){
14180     return new BinaryExpression(
14181       left_operand,
14182       this.operator,
14183       this.right_operand);
14184   }
14185   with_operator(operator){
14186     return new BinaryExpression(
14187       this.left_operand,
14188       operator,
14189       this.right_operand);
14190   }
14191   with_right_operand(right_operand){
14192     return new BinaryExpression(
14193       this.left_operand,
14194       this.operator,
14195       right_operand);
14196   }
14197   rewrite(rewriter, parents)
14198   {
14199     if (parents == undefined)
14200       parents = [];
14201     let new_parents = parents.slice();
14202     new_parents.push(this);
14203     var left_operand = this.left_operand.rewrite(rewriter, new_parents);
14204     var operator = this.operator.rewrite(rewriter, new_parents);
14205     var right_operand = this.right_operand.rewrite(rewriter, new_parents);
14206     if (
14207       left_operand === this.left_operand &&
14208       operator === this.operator &&
14209       right_operand === this.right_operand)
14210     {
14211       return rewriter(this, parents);
14212     }
14213     else
14214     {
14215       return rewriter(new BinaryExpression(
14216         left_operand,
14217         operator,
14218         right_operand), parents);
14219     }
14220   }
14221   static from_json(json, position, source)
14222   {
14223     let left_operand = EditableSyntax.from_json(
14224       json.binary_left_operand, position, source);
14225     position += left_operand.width;
14226     let operator = EditableSyntax.from_json(
14227       json.binary_operator, position, source);
14228     position += operator.width;
14229     let right_operand = EditableSyntax.from_json(
14230       json.binary_right_operand, position, source);
14231     position += right_operand.width;
14232     return new BinaryExpression(
14233         left_operand,
14234         operator,
14235         right_operand);
14236   }
14237   get children_keys()
14238   {
14239     if (BinaryExpression._children_keys == null)
14240       BinaryExpression._children_keys = [
14241         'left_operand',
14242         'operator',
14243         'right_operand'];
14244     return BinaryExpression._children_keys;
14245   }
14246 }
14247 class InstanceofExpression extends EditableSyntax
14248 {
14249   constructor(
14250     left_operand,
14251     operator,
14252     right_operand)
14253   {
14254     super('instanceof_expression', {
14255       left_operand: left_operand,
14256       operator: operator,
14257       right_operand: right_operand });
14258   }
14259   get left_operand() { return this.children.left_operand; }
14260   get operator() { return this.children.operator; }
14261   get right_operand() { return this.children.right_operand; }
14262   with_left_operand(left_operand){
14263     return new InstanceofExpression(
14264       left_operand,
14265       this.operator,
14266       this.right_operand);
14267   }
14268   with_operator(operator){
14269     return new InstanceofExpression(
14270       this.left_operand,
14271       operator,
14272       this.right_operand);
14273   }
14274   with_right_operand(right_operand){
14275     return new InstanceofExpression(
14276       this.left_operand,
14277       this.operator,
14278       right_operand);
14279   }
14280   rewrite(rewriter, parents)
14281   {
14282     if (parents == undefined)
14283       parents = [];
14284     let new_parents = parents.slice();
14285     new_parents.push(this);
14286     var left_operand = this.left_operand.rewrite(rewriter, new_parents);
14287     var operator = this.operator.rewrite(rewriter, new_parents);
14288     var right_operand = this.right_operand.rewrite(rewriter, new_parents);
14289     if (
14290       left_operand === this.left_operand &&
14291       operator === this.operator &&
14292       right_operand === this.right_operand)
14293     {
14294       return rewriter(this, parents);
14295     }
14296     else
14297     {
14298       return rewriter(new InstanceofExpression(
14299         left_operand,
14300         operator,
14301         right_operand), parents);
14302     }
14303   }
14304   static from_json(json, position, source)
14305   {
14306     let left_operand = EditableSyntax.from_json(
14307       json.instanceof_left_operand, position, source);
14308     position += left_operand.width;
14309     let operator = EditableSyntax.from_json(
14310       json.instanceof_operator, position, source);
14311     position += operator.width;
14312     let right_operand = EditableSyntax.from_json(
14313       json.instanceof_right_operand, position, source);
14314     position += right_operand.width;
14315     return new InstanceofExpression(
14316         left_operand,
14317         operator,
14318         right_operand);
14319   }
14320   get children_keys()
14321   {
14322     if (InstanceofExpression._children_keys == null)
14323       InstanceofExpression._children_keys = [
14324         'left_operand',
14325         'operator',
14326         'right_operand'];
14327     return InstanceofExpression._children_keys;
14328   }
14329 }
14330 class IsExpression extends EditableSyntax
14331 {
14332   constructor(
14333     left_operand,
14334     operator,
14335     right_operand)
14336   {
14337     super('is_expression', {
14338       left_operand: left_operand,
14339       operator: operator,
14340       right_operand: right_operand });
14341   }
14342   get left_operand() { return this.children.left_operand; }
14343   get operator() { return this.children.operator; }
14344   get right_operand() { return this.children.right_operand; }
14345   with_left_operand(left_operand){
14346     return new IsExpression(
14347       left_operand,
14348       this.operator,
14349       this.right_operand);
14350   }
14351   with_operator(operator){
14352     return new IsExpression(
14353       this.left_operand,
14354       operator,
14355       this.right_operand);
14356   }
14357   with_right_operand(right_operand){
14358     return new IsExpression(
14359       this.left_operand,
14360       this.operator,
14361       right_operand);
14362   }
14363   rewrite(rewriter, parents)
14364   {
14365     if (parents == undefined)
14366       parents = [];
14367     let new_parents = parents.slice();
14368     new_parents.push(this);
14369     var left_operand = this.left_operand.rewrite(rewriter, new_parents);
14370     var operator = this.operator.rewrite(rewriter, new_parents);
14371     var right_operand = this.right_operand.rewrite(rewriter, new_parents);
14372     if (
14373       left_operand === this.left_operand &&
14374       operator === this.operator &&
14375       right_operand === this.right_operand)
14376     {
14377       return rewriter(this, parents);
14378     }
14379     else
14380     {
14381       return rewriter(new IsExpression(
14382         left_operand,
14383         operator,
14384         right_operand), parents);
14385     }
14386   }
14387   static from_json(json, position, source)
14388   {
14389     let left_operand = EditableSyntax.from_json(
14390       json.is_left_operand, position, source);
14391     position += left_operand.width;
14392     let operator = EditableSyntax.from_json(
14393       json.is_operator, position, source);
14394     position += operator.width;
14395     let right_operand = EditableSyntax.from_json(
14396       json.is_right_operand, position, source);
14397     position += right_operand.width;
14398     return new IsExpression(
14399         left_operand,
14400         operator,
14401         right_operand);
14402   }
14403   get children_keys()
14404   {
14405     if (IsExpression._children_keys == null)
14406       IsExpression._children_keys = [
14407         'left_operand',
14408         'operator',
14409         'right_operand'];
14410     return IsExpression._children_keys;
14411   }
14412 }
14413 class AsExpression extends EditableSyntax
14414 {
14415   constructor(
14416     left_operand,
14417     operator,
14418     right_operand)
14419   {
14420     super('as_expression', {
14421       left_operand: left_operand,
14422       operator: operator,
14423       right_operand: right_operand });
14424   }
14425   get left_operand() { return this.children.left_operand; }
14426   get operator() { return this.children.operator; }
14427   get right_operand() { return this.children.right_operand; }
14428   with_left_operand(left_operand){
14429     return new AsExpression(
14430       left_operand,
14431       this.operator,
14432       this.right_operand);
14433   }
14434   with_operator(operator){
14435     return new AsExpression(
14436       this.left_operand,
14437       operator,
14438       this.right_operand);
14439   }
14440   with_right_operand(right_operand){
14441     return new AsExpression(
14442       this.left_operand,
14443       this.operator,
14444       right_operand);
14445   }
14446   rewrite(rewriter, parents)
14447   {
14448     if (parents == undefined)
14449       parents = [];
14450     let new_parents = parents.slice();
14451     new_parents.push(this);
14452     var left_operand = this.left_operand.rewrite(rewriter, new_parents);
14453     var operator = this.operator.rewrite(rewriter, new_parents);
14454     var right_operand = this.right_operand.rewrite(rewriter, new_parents);
14455     if (
14456       left_operand === this.left_operand &&
14457       operator === this.operator &&
14458       right_operand === this.right_operand)
14459     {
14460       return rewriter(this, parents);
14461     }
14462     else
14463     {
14464       return rewriter(new AsExpression(
14465         left_operand,
14466         operator,
14467         right_operand), parents);
14468     }
14469   }
14470   static from_json(json, position, source)
14471   {
14472     let left_operand = EditableSyntax.from_json(
14473       json.as_left_operand, position, source);
14474     position += left_operand.width;
14475     let operator = EditableSyntax.from_json(
14476       json.as_operator, position, source);
14477     position += operator.width;
14478     let right_operand = EditableSyntax.from_json(
14479       json.as_right_operand, position, source);
14480     position += right_operand.width;
14481     return new AsExpression(
14482         left_operand,
14483         operator,
14484         right_operand);
14485   }
14486   get children_keys()
14487   {
14488     if (AsExpression._children_keys == null)
14489       AsExpression._children_keys = [
14490         'left_operand',
14491         'operator',
14492         'right_operand'];
14493     return AsExpression._children_keys;
14494   }
14495 }
14496 class NullableAsExpression extends EditableSyntax
14497 {
14498   constructor(
14499     left_operand,
14500     operator,
14501     right_operand)
14502   {
14503     super('nullable_as_expression', {
14504       left_operand: left_operand,
14505       operator: operator,
14506       right_operand: right_operand });
14507   }
14508   get left_operand() { return this.children.left_operand; }
14509   get operator() { return this.children.operator; }
14510   get right_operand() { return this.children.right_operand; }
14511   with_left_operand(left_operand){
14512     return new NullableAsExpression(
14513       left_operand,
14514       this.operator,
14515       this.right_operand);
14516   }
14517   with_operator(operator){
14518     return new NullableAsExpression(
14519       this.left_operand,
14520       operator,
14521       this.right_operand);
14522   }
14523   with_right_operand(right_operand){
14524     return new NullableAsExpression(
14525       this.left_operand,
14526       this.operator,
14527       right_operand);
14528   }
14529   rewrite(rewriter, parents)
14530   {
14531     if (parents == undefined)
14532       parents = [];
14533     let new_parents = parents.slice();
14534     new_parents.push(this);
14535     var left_operand = this.left_operand.rewrite(rewriter, new_parents);
14536     var operator = this.operator.rewrite(rewriter, new_parents);
14537     var right_operand = this.right_operand.rewrite(rewriter, new_parents);
14538     if (
14539       left_operand === this.left_operand &&
14540       operator === this.operator &&
14541       right_operand === this.right_operand)
14542     {
14543       return rewriter(this, parents);
14544     }
14545     else
14546     {
14547       return rewriter(new NullableAsExpression(
14548         left_operand,
14549         operator,
14550         right_operand), parents);
14551     }
14552   }
14553   static from_json(json, position, source)
14554   {
14555     let left_operand = EditableSyntax.from_json(
14556       json.nullable_as_left_operand, position, source);
14557     position += left_operand.width;
14558     let operator = EditableSyntax.from_json(
14559       json.nullable_as_operator, position, source);
14560     position += operator.width;
14561     let right_operand = EditableSyntax.from_json(
14562       json.nullable_as_right_operand, position, source);
14563     position += right_operand.width;
14564     return new NullableAsExpression(
14565         left_operand,
14566         operator,
14567         right_operand);
14568   }
14569   get children_keys()
14570   {
14571     if (NullableAsExpression._children_keys == null)
14572       NullableAsExpression._children_keys = [
14573         'left_operand',
14574         'operator',
14575         'right_operand'];
14576     return NullableAsExpression._children_keys;
14577   }
14578 }
14579 class ConditionalExpression extends EditableSyntax
14580 {
14581   constructor(
14582     test,
14583     question,
14584     consequence,
14585     colon,
14586     alternative)
14587   {
14588     super('conditional_expression', {
14589       test: test,
14590       question: question,
14591       consequence: consequence,
14592       colon: colon,
14593       alternative: alternative });
14594   }
14595   get test() { return this.children.test; }
14596   get question() { return this.children.question; }
14597   get consequence() { return this.children.consequence; }
14598   get colon() { return this.children.colon; }
14599   get alternative() { return this.children.alternative; }
14600   with_test(test){
14601     return new ConditionalExpression(
14602       test,
14603       this.question,
14604       this.consequence,
14605       this.colon,
14606       this.alternative);
14607   }
14608   with_question(question){
14609     return new ConditionalExpression(
14610       this.test,
14611       question,
14612       this.consequence,
14613       this.colon,
14614       this.alternative);
14615   }
14616   with_consequence(consequence){
14617     return new ConditionalExpression(
14618       this.test,
14619       this.question,
14620       consequence,
14621       this.colon,
14622       this.alternative);
14623   }
14624   with_colon(colon){
14625     return new ConditionalExpression(
14626       this.test,
14627       this.question,
14628       this.consequence,
14629       colon,
14630       this.alternative);
14631   }
14632   with_alternative(alternative){
14633     return new ConditionalExpression(
14634       this.test,
14635       this.question,
14636       this.consequence,
14637       this.colon,
14638       alternative);
14639   }
14640   rewrite(rewriter, parents)
14641   {
14642     if (parents == undefined)
14643       parents = [];
14644     let new_parents = parents.slice();
14645     new_parents.push(this);
14646     var test = this.test.rewrite(rewriter, new_parents);
14647     var question = this.question.rewrite(rewriter, new_parents);
14648     var consequence = this.consequence.rewrite(rewriter, new_parents);
14649     var colon = this.colon.rewrite(rewriter, new_parents);
14650     var alternative = this.alternative.rewrite(rewriter, new_parents);
14651     if (
14652       test === this.test &&
14653       question === this.question &&
14654       consequence === this.consequence &&
14655       colon === this.colon &&
14656       alternative === this.alternative)
14657     {
14658       return rewriter(this, parents);
14659     }
14660     else
14661     {
14662       return rewriter(new ConditionalExpression(
14663         test,
14664         question,
14665         consequence,
14666         colon,
14667         alternative), parents);
14668     }
14669   }
14670   static from_json(json, position, source)
14671   {
14672     let test = EditableSyntax.from_json(
14673       json.conditional_test, position, source);
14674     position += test.width;
14675     let question = EditableSyntax.from_json(
14676       json.conditional_question, position, source);
14677     position += question.width;
14678     let consequence = EditableSyntax.from_json(
14679       json.conditional_consequence, position, source);
14680     position += consequence.width;
14681     let colon = EditableSyntax.from_json(
14682       json.conditional_colon, position, source);
14683     position += colon.width;
14684     let alternative = EditableSyntax.from_json(
14685       json.conditional_alternative, position, source);
14686     position += alternative.width;
14687     return new ConditionalExpression(
14688         test,
14689         question,
14690         consequence,
14691         colon,
14692         alternative);
14693   }
14694   get children_keys()
14695   {
14696     if (ConditionalExpression._children_keys == null)
14697       ConditionalExpression._children_keys = [
14698         'test',
14699         'question',
14700         'consequence',
14701         'colon',
14702         'alternative'];
14703     return ConditionalExpression._children_keys;
14704   }
14705 }
14706 class EvalExpression extends EditableSyntax
14707 {
14708   constructor(
14709     keyword,
14710     left_paren,
14711     argument,
14712     right_paren)
14713   {
14714     super('eval_expression', {
14715       keyword: keyword,
14716       left_paren: left_paren,
14717       argument: argument,
14718       right_paren: right_paren });
14719   }
14720   get keyword() { return this.children.keyword; }
14721   get left_paren() { return this.children.left_paren; }
14722   get argument() { return this.children.argument; }
14723   get right_paren() { return this.children.right_paren; }
14724   with_keyword(keyword){
14725     return new EvalExpression(
14726       keyword,
14727       this.left_paren,
14728       this.argument,
14729       this.right_paren);
14730   }
14731   with_left_paren(left_paren){
14732     return new EvalExpression(
14733       this.keyword,
14734       left_paren,
14735       this.argument,
14736       this.right_paren);
14737   }
14738   with_argument(argument){
14739     return new EvalExpression(
14740       this.keyword,
14741       this.left_paren,
14742       argument,
14743       this.right_paren);
14744   }
14745   with_right_paren(right_paren){
14746     return new EvalExpression(
14747       this.keyword,
14748       this.left_paren,
14749       this.argument,
14750       right_paren);
14751   }
14752   rewrite(rewriter, parents)
14753   {
14754     if (parents == undefined)
14755       parents = [];
14756     let new_parents = parents.slice();
14757     new_parents.push(this);
14758     var keyword = this.keyword.rewrite(rewriter, new_parents);
14759     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
14760     var argument = this.argument.rewrite(rewriter, new_parents);
14761     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
14762     if (
14763       keyword === this.keyword &&
14764       left_paren === this.left_paren &&
14765       argument === this.argument &&
14766       right_paren === this.right_paren)
14767     {
14768       return rewriter(this, parents);
14769     }
14770     else
14771     {
14772       return rewriter(new EvalExpression(
14773         keyword,
14774         left_paren,
14775         argument,
14776         right_paren), parents);
14777     }
14778   }
14779   static from_json(json, position, source)
14780   {
14781     let keyword = EditableSyntax.from_json(
14782       json.eval_keyword, position, source);
14783     position += keyword.width;
14784     let left_paren = EditableSyntax.from_json(
14785       json.eval_left_paren, position, source);
14786     position += left_paren.width;
14787     let argument = EditableSyntax.from_json(
14788       json.eval_argument, position, source);
14789     position += argument.width;
14790     let right_paren = EditableSyntax.from_json(
14791       json.eval_right_paren, position, source);
14792     position += right_paren.width;
14793     return new EvalExpression(
14794         keyword,
14795         left_paren,
14796         argument,
14797         right_paren);
14798   }
14799   get children_keys()
14800   {
14801     if (EvalExpression._children_keys == null)
14802       EvalExpression._children_keys = [
14803         'keyword',
14804         'left_paren',
14805         'argument',
14806         'right_paren'];
14807     return EvalExpression._children_keys;
14808   }
14809 }
14810 class EmptyExpression extends EditableSyntax
14811 {
14812   constructor(
14813     keyword,
14814     left_paren,
14815     argument,
14816     right_paren)
14817   {
14818     super('empty_expression', {
14819       keyword: keyword,
14820       left_paren: left_paren,
14821       argument: argument,
14822       right_paren: right_paren });
14823   }
14824   get keyword() { return this.children.keyword; }
14825   get left_paren() { return this.children.left_paren; }
14826   get argument() { return this.children.argument; }
14827   get right_paren() { return this.children.right_paren; }
14828   with_keyword(keyword){
14829     return new EmptyExpression(
14830       keyword,
14831       this.left_paren,
14832       this.argument,
14833       this.right_paren);
14834   }
14835   with_left_paren(left_paren){
14836     return new EmptyExpression(
14837       this.keyword,
14838       left_paren,
14839       this.argument,
14840       this.right_paren);
14841   }
14842   with_argument(argument){
14843     return new EmptyExpression(
14844       this.keyword,
14845       this.left_paren,
14846       argument,
14847       this.right_paren);
14848   }
14849   with_right_paren(right_paren){
14850     return new EmptyExpression(
14851       this.keyword,
14852       this.left_paren,
14853       this.argument,
14854       right_paren);
14855   }
14856   rewrite(rewriter, parents)
14857   {
14858     if (parents == undefined)
14859       parents = [];
14860     let new_parents = parents.slice();
14861     new_parents.push(this);
14862     var keyword = this.keyword.rewrite(rewriter, new_parents);
14863     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
14864     var argument = this.argument.rewrite(rewriter, new_parents);
14865     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
14866     if (
14867       keyword === this.keyword &&
14868       left_paren === this.left_paren &&
14869       argument === this.argument &&
14870       right_paren === this.right_paren)
14871     {
14872       return rewriter(this, parents);
14873     }
14874     else
14875     {
14876       return rewriter(new EmptyExpression(
14877         keyword,
14878         left_paren,
14879         argument,
14880         right_paren), parents);
14881     }
14882   }
14883   static from_json(json, position, source)
14884   {
14885     let keyword = EditableSyntax.from_json(
14886       json.empty_keyword, position, source);
14887     position += keyword.width;
14888     let left_paren = EditableSyntax.from_json(
14889       json.empty_left_paren, position, source);
14890     position += left_paren.width;
14891     let argument = EditableSyntax.from_json(
14892       json.empty_argument, position, source);
14893     position += argument.width;
14894     let right_paren = EditableSyntax.from_json(
14895       json.empty_right_paren, position, source);
14896     position += right_paren.width;
14897     return new EmptyExpression(
14898         keyword,
14899         left_paren,
14900         argument,
14901         right_paren);
14902   }
14903   get children_keys()
14904   {
14905     if (EmptyExpression._children_keys == null)
14906       EmptyExpression._children_keys = [
14907         'keyword',
14908         'left_paren',
14909         'argument',
14910         'right_paren'];
14911     return EmptyExpression._children_keys;
14912   }
14913 }
14914 class DefineExpression extends EditableSyntax
14915 {
14916   constructor(
14917     keyword,
14918     left_paren,
14919     argument_list,
14920     right_paren)
14921   {
14922     super('define_expression', {
14923       keyword: keyword,
14924       left_paren: left_paren,
14925       argument_list: argument_list,
14926       right_paren: right_paren });
14927   }
14928   get keyword() { return this.children.keyword; }
14929   get left_paren() { return this.children.left_paren; }
14930   get argument_list() { return this.children.argument_list; }
14931   get right_paren() { return this.children.right_paren; }
14932   with_keyword(keyword){
14933     return new DefineExpression(
14934       keyword,
14935       this.left_paren,
14936       this.argument_list,
14937       this.right_paren);
14938   }
14939   with_left_paren(left_paren){
14940     return new DefineExpression(
14941       this.keyword,
14942       left_paren,
14943       this.argument_list,
14944       this.right_paren);
14945   }
14946   with_argument_list(argument_list){
14947     return new DefineExpression(
14948       this.keyword,
14949       this.left_paren,
14950       argument_list,
14951       this.right_paren);
14952   }
14953   with_right_paren(right_paren){
14954     return new DefineExpression(
14955       this.keyword,
14956       this.left_paren,
14957       this.argument_list,
14958       right_paren);
14959   }
14960   rewrite(rewriter, parents)
14961   {
14962     if (parents == undefined)
14963       parents = [];
14964     let new_parents = parents.slice();
14965     new_parents.push(this);
14966     var keyword = this.keyword.rewrite(rewriter, new_parents);
14967     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
14968     var argument_list = this.argument_list.rewrite(rewriter, new_parents);
14969     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
14970     if (
14971       keyword === this.keyword &&
14972       left_paren === this.left_paren &&
14973       argument_list === this.argument_list &&
14974       right_paren === this.right_paren)
14975     {
14976       return rewriter(this, parents);
14977     }
14978     else
14979     {
14980       return rewriter(new DefineExpression(
14981         keyword,
14982         left_paren,
14983         argument_list,
14984         right_paren), parents);
14985     }
14986   }
14987   static from_json(json, position, source)
14988   {
14989     let keyword = EditableSyntax.from_json(
14990       json.define_keyword, position, source);
14991     position += keyword.width;
14992     let left_paren = EditableSyntax.from_json(
14993       json.define_left_paren, position, source);
14994     position += left_paren.width;
14995     let argument_list = EditableSyntax.from_json(
14996       json.define_argument_list, position, source);
14997     position += argument_list.width;
14998     let right_paren = EditableSyntax.from_json(
14999       json.define_right_paren, position, source);
15000     position += right_paren.width;
15001     return new DefineExpression(
15002         keyword,
15003         left_paren,
15004         argument_list,
15005         right_paren);
15006   }
15007   get children_keys()
15008   {
15009     if (DefineExpression._children_keys == null)
15010       DefineExpression._children_keys = [
15011         'keyword',
15012         'left_paren',
15013         'argument_list',
15014         'right_paren'];
15015     return DefineExpression._children_keys;
15016   }
15017 }
15018 class HaltCompilerExpression extends EditableSyntax
15019 {
15020   constructor(
15021     keyword,
15022     left_paren,
15023     argument_list,
15024     right_paren)
15025   {
15026     super('halt_compiler_expression', {
15027       keyword: keyword,
15028       left_paren: left_paren,
15029       argument_list: argument_list,
15030       right_paren: right_paren });
15031   }
15032   get keyword() { return this.children.keyword; }
15033   get left_paren() { return this.children.left_paren; }
15034   get argument_list() { return this.children.argument_list; }
15035   get right_paren() { return this.children.right_paren; }
15036   with_keyword(keyword){
15037     return new HaltCompilerExpression(
15038       keyword,
15039       this.left_paren,
15040       this.argument_list,
15041       this.right_paren);
15042   }
15043   with_left_paren(left_paren){
15044     return new HaltCompilerExpression(
15045       this.keyword,
15046       left_paren,
15047       this.argument_list,
15048       this.right_paren);
15049   }
15050   with_argument_list(argument_list){
15051     return new HaltCompilerExpression(
15052       this.keyword,
15053       this.left_paren,
15054       argument_list,
15055       this.right_paren);
15056   }
15057   with_right_paren(right_paren){
15058     return new HaltCompilerExpression(
15059       this.keyword,
15060       this.left_paren,
15061       this.argument_list,
15062       right_paren);
15063   }
15064   rewrite(rewriter, parents)
15065   {
15066     if (parents == undefined)
15067       parents = [];
15068     let new_parents = parents.slice();
15069     new_parents.push(this);
15070     var keyword = this.keyword.rewrite(rewriter, new_parents);
15071     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
15072     var argument_list = this.argument_list.rewrite(rewriter, new_parents);
15073     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
15074     if (
15075       keyword === this.keyword &&
15076       left_paren === this.left_paren &&
15077       argument_list === this.argument_list &&
15078       right_paren === this.right_paren)
15079     {
15080       return rewriter(this, parents);
15081     }
15082     else
15083     {
15084       return rewriter(new HaltCompilerExpression(
15085         keyword,
15086         left_paren,
15087         argument_list,
15088         right_paren), parents);
15089     }
15090   }
15091   static from_json(json, position, source)
15092   {
15093     let keyword = EditableSyntax.from_json(
15094       json.halt_compiler_keyword, position, source);
15095     position += keyword.width;
15096     let left_paren = EditableSyntax.from_json(
15097       json.halt_compiler_left_paren, position, source);
15098     position += left_paren.width;
15099     let argument_list = EditableSyntax.from_json(
15100       json.halt_compiler_argument_list, position, source);
15101     position += argument_list.width;
15102     let right_paren = EditableSyntax.from_json(
15103       json.halt_compiler_right_paren, position, source);
15104     position += right_paren.width;
15105     return new HaltCompilerExpression(
15106         keyword,
15107         left_paren,
15108         argument_list,
15109         right_paren);
15110   }
15111   get children_keys()
15112   {
15113     if (HaltCompilerExpression._children_keys == null)
15114       HaltCompilerExpression._children_keys = [
15115         'keyword',
15116         'left_paren',
15117         'argument_list',
15118         'right_paren'];
15119     return HaltCompilerExpression._children_keys;
15120   }
15121 }
15122 class IssetExpression extends EditableSyntax
15123 {
15124   constructor(
15125     keyword,
15126     left_paren,
15127     argument_list,
15128     right_paren)
15129   {
15130     super('isset_expression', {
15131       keyword: keyword,
15132       left_paren: left_paren,
15133       argument_list: argument_list,
15134       right_paren: right_paren });
15135   }
15136   get keyword() { return this.children.keyword; }
15137   get left_paren() { return this.children.left_paren; }
15138   get argument_list() { return this.children.argument_list; }
15139   get right_paren() { return this.children.right_paren; }
15140   with_keyword(keyword){
15141     return new IssetExpression(
15142       keyword,
15143       this.left_paren,
15144       this.argument_list,
15145       this.right_paren);
15146   }
15147   with_left_paren(left_paren){
15148     return new IssetExpression(
15149       this.keyword,
15150       left_paren,
15151       this.argument_list,
15152       this.right_paren);
15153   }
15154   with_argument_list(argument_list){
15155     return new IssetExpression(
15156       this.keyword,
15157       this.left_paren,
15158       argument_list,
15159       this.right_paren);
15160   }
15161   with_right_paren(right_paren){
15162     return new IssetExpression(
15163       this.keyword,
15164       this.left_paren,
15165       this.argument_list,
15166       right_paren);
15167   }
15168   rewrite(rewriter, parents)
15169   {
15170     if (parents == undefined)
15171       parents = [];
15172     let new_parents = parents.slice();
15173     new_parents.push(this);
15174     var keyword = this.keyword.rewrite(rewriter, new_parents);
15175     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
15176     var argument_list = this.argument_list.rewrite(rewriter, new_parents);
15177     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
15178     if (
15179       keyword === this.keyword &&
15180       left_paren === this.left_paren &&
15181       argument_list === this.argument_list &&
15182       right_paren === this.right_paren)
15183     {
15184       return rewriter(this, parents);
15185     }
15186     else
15187     {
15188       return rewriter(new IssetExpression(
15189         keyword,
15190         left_paren,
15191         argument_list,
15192         right_paren), parents);
15193     }
15194   }
15195   static from_json(json, position, source)
15196   {
15197     let keyword = EditableSyntax.from_json(
15198       json.isset_keyword, position, source);
15199     position += keyword.width;
15200     let left_paren = EditableSyntax.from_json(
15201       json.isset_left_paren, position, source);
15202     position += left_paren.width;
15203     let argument_list = EditableSyntax.from_json(
15204       json.isset_argument_list, position, source);
15205     position += argument_list.width;
15206     let right_paren = EditableSyntax.from_json(
15207       json.isset_right_paren, position, source);
15208     position += right_paren.width;
15209     return new IssetExpression(
15210         keyword,
15211         left_paren,
15212         argument_list,
15213         right_paren);
15214   }
15215   get children_keys()
15216   {
15217     if (IssetExpression._children_keys == null)
15218       IssetExpression._children_keys = [
15219         'keyword',
15220         'left_paren',
15221         'argument_list',
15222         'right_paren'];
15223     return IssetExpression._children_keys;
15224   }
15225 }
15226 class FunctionCallExpression extends EditableSyntax
15227 {
15228   constructor(
15229     receiver,
15230     left_paren,
15231     argument_list,
15232     right_paren)
15233   {
15234     super('function_call_expression', {
15235       receiver: receiver,
15236       left_paren: left_paren,
15237       argument_list: argument_list,
15238       right_paren: right_paren });
15239   }
15240   get receiver() { return this.children.receiver; }
15241   get left_paren() { return this.children.left_paren; }
15242   get argument_list() { return this.children.argument_list; }
15243   get right_paren() { return this.children.right_paren; }
15244   with_receiver(receiver){
15245     return new FunctionCallExpression(
15246       receiver,
15247       this.left_paren,
15248       this.argument_list,
15249       this.right_paren);
15250   }
15251   with_left_paren(left_paren){
15252     return new FunctionCallExpression(
15253       this.receiver,
15254       left_paren,
15255       this.argument_list,
15256       this.right_paren);
15257   }
15258   with_argument_list(argument_list){
15259     return new FunctionCallExpression(
15260       this.receiver,
15261       this.left_paren,
15262       argument_list,
15263       this.right_paren);
15264   }
15265   with_right_paren(right_paren){
15266     return new FunctionCallExpression(
15267       this.receiver,
15268       this.left_paren,
15269       this.argument_list,
15270       right_paren);
15271   }
15272   rewrite(rewriter, parents)
15273   {
15274     if (parents == undefined)
15275       parents = [];
15276     let new_parents = parents.slice();
15277     new_parents.push(this);
15278     var receiver = this.receiver.rewrite(rewriter, new_parents);
15279     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
15280     var argument_list = this.argument_list.rewrite(rewriter, new_parents);
15281     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
15282     if (
15283       receiver === this.receiver &&
15284       left_paren === this.left_paren &&
15285       argument_list === this.argument_list &&
15286       right_paren === this.right_paren)
15287     {
15288       return rewriter(this, parents);
15289     }
15290     else
15291     {
15292       return rewriter(new FunctionCallExpression(
15293         receiver,
15294         left_paren,
15295         argument_list,
15296         right_paren), parents);
15297     }
15298   }
15299   static from_json(json, position, source)
15300   {
15301     let receiver = EditableSyntax.from_json(
15302       json.function_call_receiver, position, source);
15303     position += receiver.width;
15304     let left_paren = EditableSyntax.from_json(
15305       json.function_call_left_paren, position, source);
15306     position += left_paren.width;
15307     let argument_list = EditableSyntax.from_json(
15308       json.function_call_argument_list, position, source);
15309     position += argument_list.width;
15310     let right_paren = EditableSyntax.from_json(
15311       json.function_call_right_paren, position, source);
15312     position += right_paren.width;
15313     return new FunctionCallExpression(
15314         receiver,
15315         left_paren,
15316         argument_list,
15317         right_paren);
15318   }
15319   get children_keys()
15320   {
15321     if (FunctionCallExpression._children_keys == null)
15322       FunctionCallExpression._children_keys = [
15323         'receiver',
15324         'left_paren',
15325         'argument_list',
15326         'right_paren'];
15327     return FunctionCallExpression._children_keys;
15328   }
15329 }
15330 class FunctionCallWithTypeArgumentsExpression extends EditableSyntax
15331 {
15332   constructor(
15333     receiver,
15334     type_args,
15335     left_paren,
15336     argument_list,
15337     right_paren)
15338   {
15339     super('function_call_with_type_arguments_expression', {
15340       receiver: receiver,
15341       type_args: type_args,
15342       left_paren: left_paren,
15343       argument_list: argument_list,
15344       right_paren: right_paren });
15345   }
15346   get receiver() { return this.children.receiver; }
15347   get type_args() { return this.children.type_args; }
15348   get left_paren() { return this.children.left_paren; }
15349   get argument_list() { return this.children.argument_list; }
15350   get right_paren() { return this.children.right_paren; }
15351   with_receiver(receiver){
15352     return new FunctionCallWithTypeArgumentsExpression(
15353       receiver,
15354       this.type_args,
15355       this.left_paren,
15356       this.argument_list,
15357       this.right_paren);
15358   }
15359   with_type_args(type_args){
15360     return new FunctionCallWithTypeArgumentsExpression(
15361       this.receiver,
15362       type_args,
15363       this.left_paren,
15364       this.argument_list,
15365       this.right_paren);
15366   }
15367   with_left_paren(left_paren){
15368     return new FunctionCallWithTypeArgumentsExpression(
15369       this.receiver,
15370       this.type_args,
15371       left_paren,
15372       this.argument_list,
15373       this.right_paren);
15374   }
15375   with_argument_list(argument_list){
15376     return new FunctionCallWithTypeArgumentsExpression(
15377       this.receiver,
15378       this.type_args,
15379       this.left_paren,
15380       argument_list,
15381       this.right_paren);
15382   }
15383   with_right_paren(right_paren){
15384     return new FunctionCallWithTypeArgumentsExpression(
15385       this.receiver,
15386       this.type_args,
15387       this.left_paren,
15388       this.argument_list,
15389       right_paren);
15390   }
15391   rewrite(rewriter, parents)
15392   {
15393     if (parents == undefined)
15394       parents = [];
15395     let new_parents = parents.slice();
15396     new_parents.push(this);
15397     var receiver = this.receiver.rewrite(rewriter, new_parents);
15398     var type_args = this.type_args.rewrite(rewriter, new_parents);
15399     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
15400     var argument_list = this.argument_list.rewrite(rewriter, new_parents);
15401     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
15402     if (
15403       receiver === this.receiver &&
15404       type_args === this.type_args &&
15405       left_paren === this.left_paren &&
15406       argument_list === this.argument_list &&
15407       right_paren === this.right_paren)
15408     {
15409       return rewriter(this, parents);
15410     }
15411     else
15412     {
15413       return rewriter(new FunctionCallWithTypeArgumentsExpression(
15414         receiver,
15415         type_args,
15416         left_paren,
15417         argument_list,
15418         right_paren), parents);
15419     }
15420   }
15421   static from_json(json, position, source)
15422   {
15423     let receiver = EditableSyntax.from_json(
15424       json.function_call_with_type_arguments_receiver, position, source);
15425     position += receiver.width;
15426     let type_args = EditableSyntax.from_json(
15427       json.function_call_with_type_arguments_type_args, position, source);
15428     position += type_args.width;
15429     let left_paren = EditableSyntax.from_json(
15430       json.function_call_with_type_arguments_left_paren, position, source);
15431     position += left_paren.width;
15432     let argument_list = EditableSyntax.from_json(
15433       json.function_call_with_type_arguments_argument_list, position, source);
15434     position += argument_list.width;
15435     let right_paren = EditableSyntax.from_json(
15436       json.function_call_with_type_arguments_right_paren, position, source);
15437     position += right_paren.width;
15438     return new FunctionCallWithTypeArgumentsExpression(
15439         receiver,
15440         type_args,
15441         left_paren,
15442         argument_list,
15443         right_paren);
15444   }
15445   get children_keys()
15446   {
15447     if (FunctionCallWithTypeArgumentsExpression._children_keys == null)
15448       FunctionCallWithTypeArgumentsExpression._children_keys = [
15449         'receiver',
15450         'type_args',
15451         'left_paren',
15452         'argument_list',
15453         'right_paren'];
15454     return FunctionCallWithTypeArgumentsExpression._children_keys;
15455   }
15456 }
15457 class ParenthesizedExpression extends EditableSyntax
15458 {
15459   constructor(
15460     left_paren,
15461     expression,
15462     right_paren)
15463   {
15464     super('parenthesized_expression', {
15465       left_paren: left_paren,
15466       expression: expression,
15467       right_paren: right_paren });
15468   }
15469   get left_paren() { return this.children.left_paren; }
15470   get expression() { return this.children.expression; }
15471   get right_paren() { return this.children.right_paren; }
15472   with_left_paren(left_paren){
15473     return new ParenthesizedExpression(
15474       left_paren,
15475       this.expression,
15476       this.right_paren);
15477   }
15478   with_expression(expression){
15479     return new ParenthesizedExpression(
15480       this.left_paren,
15481       expression,
15482       this.right_paren);
15483   }
15484   with_right_paren(right_paren){
15485     return new ParenthesizedExpression(
15486       this.left_paren,
15487       this.expression,
15488       right_paren);
15489   }
15490   rewrite(rewriter, parents)
15491   {
15492     if (parents == undefined)
15493       parents = [];
15494     let new_parents = parents.slice();
15495     new_parents.push(this);
15496     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
15497     var expression = this.expression.rewrite(rewriter, new_parents);
15498     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
15499     if (
15500       left_paren === this.left_paren &&
15501       expression === this.expression &&
15502       right_paren === this.right_paren)
15503     {
15504       return rewriter(this, parents);
15505     }
15506     else
15507     {
15508       return rewriter(new ParenthesizedExpression(
15509         left_paren,
15510         expression,
15511         right_paren), parents);
15512     }
15513   }
15514   static from_json(json, position, source)
15515   {
15516     let left_paren = EditableSyntax.from_json(
15517       json.parenthesized_expression_left_paren, position, source);
15518     position += left_paren.width;
15519     let expression = EditableSyntax.from_json(
15520       json.parenthesized_expression_expression, position, source);
15521     position += expression.width;
15522     let right_paren = EditableSyntax.from_json(
15523       json.parenthesized_expression_right_paren, position, source);
15524     position += right_paren.width;
15525     return new ParenthesizedExpression(
15526         left_paren,
15527         expression,
15528         right_paren);
15529   }
15530   get children_keys()
15531   {
15532     if (ParenthesizedExpression._children_keys == null)
15533       ParenthesizedExpression._children_keys = [
15534         'left_paren',
15535         'expression',
15536         'right_paren'];
15537     return ParenthesizedExpression._children_keys;
15538   }
15539 }
15540 class BracedExpression extends EditableSyntax
15541 {
15542   constructor(
15543     left_brace,
15544     expression,
15545     right_brace)
15546   {
15547     super('braced_expression', {
15548       left_brace: left_brace,
15549       expression: expression,
15550       right_brace: right_brace });
15551   }
15552   get left_brace() { return this.children.left_brace; }
15553   get expression() { return this.children.expression; }
15554   get right_brace() { return this.children.right_brace; }
15555   with_left_brace(left_brace){
15556     return new BracedExpression(
15557       left_brace,
15558       this.expression,
15559       this.right_brace);
15560   }
15561   with_expression(expression){
15562     return new BracedExpression(
15563       this.left_brace,
15564       expression,
15565       this.right_brace);
15566   }
15567   with_right_brace(right_brace){
15568     return new BracedExpression(
15569       this.left_brace,
15570       this.expression,
15571       right_brace);
15572   }
15573   rewrite(rewriter, parents)
15574   {
15575     if (parents == undefined)
15576       parents = [];
15577     let new_parents = parents.slice();
15578     new_parents.push(this);
15579     var left_brace = this.left_brace.rewrite(rewriter, new_parents);
15580     var expression = this.expression.rewrite(rewriter, new_parents);
15581     var right_brace = this.right_brace.rewrite(rewriter, new_parents);
15582     if (
15583       left_brace === this.left_brace &&
15584       expression === this.expression &&
15585       right_brace === this.right_brace)
15586     {
15587       return rewriter(this, parents);
15588     }
15589     else
15590     {
15591       return rewriter(new BracedExpression(
15592         left_brace,
15593         expression,
15594         right_brace), parents);
15595     }
15596   }
15597   static from_json(json, position, source)
15598   {
15599     let left_brace = EditableSyntax.from_json(
15600       json.braced_expression_left_brace, position, source);
15601     position += left_brace.width;
15602     let expression = EditableSyntax.from_json(
15603       json.braced_expression_expression, position, source);
15604     position += expression.width;
15605     let right_brace = EditableSyntax.from_json(
15606       json.braced_expression_right_brace, position, source);
15607     position += right_brace.width;
15608     return new BracedExpression(
15609         left_brace,
15610         expression,
15611         right_brace);
15612   }
15613   get children_keys()
15614   {
15615     if (BracedExpression._children_keys == null)
15616       BracedExpression._children_keys = [
15617         'left_brace',
15618         'expression',
15619         'right_brace'];
15620     return BracedExpression._children_keys;
15621   }
15622 }
15623 class EmbeddedBracedExpression extends EditableSyntax
15624 {
15625   constructor(
15626     left_brace,
15627     expression,
15628     right_brace)
15629   {
15630     super('embedded_braced_expression', {
15631       left_brace: left_brace,
15632       expression: expression,
15633       right_brace: right_brace });
15634   }
15635   get left_brace() { return this.children.left_brace; }
15636   get expression() { return this.children.expression; }
15637   get right_brace() { return this.children.right_brace; }
15638   with_left_brace(left_brace){
15639     return new EmbeddedBracedExpression(
15640       left_brace,
15641       this.expression,
15642       this.right_brace);
15643   }
15644   with_expression(expression){
15645     return new EmbeddedBracedExpression(
15646       this.left_brace,
15647       expression,
15648       this.right_brace);
15649   }
15650   with_right_brace(right_brace){
15651     return new EmbeddedBracedExpression(
15652       this.left_brace,
15653       this.expression,
15654       right_brace);
15655   }
15656   rewrite(rewriter, parents)
15657   {
15658     if (parents == undefined)
15659       parents = [];
15660     let new_parents = parents.slice();
15661     new_parents.push(this);
15662     var left_brace = this.left_brace.rewrite(rewriter, new_parents);
15663     var expression = this.expression.rewrite(rewriter, new_parents);
15664     var right_brace = this.right_brace.rewrite(rewriter, new_parents);
15665     if (
15666       left_brace === this.left_brace &&
15667       expression === this.expression &&
15668       right_brace === this.right_brace)
15669     {
15670       return rewriter(this, parents);
15671     }
15672     else
15673     {
15674       return rewriter(new EmbeddedBracedExpression(
15675         left_brace,
15676         expression,
15677         right_brace), parents);
15678     }
15679   }
15680   static from_json(json, position, source)
15681   {
15682     let left_brace = EditableSyntax.from_json(
15683       json.embedded_braced_expression_left_brace, position, source);
15684     position += left_brace.width;
15685     let expression = EditableSyntax.from_json(
15686       json.embedded_braced_expression_expression, position, source);
15687     position += expression.width;
15688     let right_brace = EditableSyntax.from_json(
15689       json.embedded_braced_expression_right_brace, position, source);
15690     position += right_brace.width;
15691     return new EmbeddedBracedExpression(
15692         left_brace,
15693         expression,
15694         right_brace);
15695   }
15696   get children_keys()
15697   {
15698     if (EmbeddedBracedExpression._children_keys == null)
15699       EmbeddedBracedExpression._children_keys = [
15700         'left_brace',
15701         'expression',
15702         'right_brace'];
15703     return EmbeddedBracedExpression._children_keys;
15704   }
15705 }
15706 class ListExpression extends EditableSyntax
15707 {
15708   constructor(
15709     keyword,
15710     left_paren,
15711     members,
15712     right_paren)
15713   {
15714     super('list_expression', {
15715       keyword: keyword,
15716       left_paren: left_paren,
15717       members: members,
15718       right_paren: right_paren });
15719   }
15720   get keyword() { return this.children.keyword; }
15721   get left_paren() { return this.children.left_paren; }
15722   get members() { return this.children.members; }
15723   get right_paren() { return this.children.right_paren; }
15724   with_keyword(keyword){
15725     return new ListExpression(
15726       keyword,
15727       this.left_paren,
15728       this.members,
15729       this.right_paren);
15730   }
15731   with_left_paren(left_paren){
15732     return new ListExpression(
15733       this.keyword,
15734       left_paren,
15735       this.members,
15736       this.right_paren);
15737   }
15738   with_members(members){
15739     return new ListExpression(
15740       this.keyword,
15741       this.left_paren,
15742       members,
15743       this.right_paren);
15744   }
15745   with_right_paren(right_paren){
15746     return new ListExpression(
15747       this.keyword,
15748       this.left_paren,
15749       this.members,
15750       right_paren);
15751   }
15752   rewrite(rewriter, parents)
15753   {
15754     if (parents == undefined)
15755       parents = [];
15756     let new_parents = parents.slice();
15757     new_parents.push(this);
15758     var keyword = this.keyword.rewrite(rewriter, new_parents);
15759     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
15760     var members = this.members.rewrite(rewriter, new_parents);
15761     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
15762     if (
15763       keyword === this.keyword &&
15764       left_paren === this.left_paren &&
15765       members === this.members &&
15766       right_paren === this.right_paren)
15767     {
15768       return rewriter(this, parents);
15769     }
15770     else
15771     {
15772       return rewriter(new ListExpression(
15773         keyword,
15774         left_paren,
15775         members,
15776         right_paren), parents);
15777     }
15778   }
15779   static from_json(json, position, source)
15780   {
15781     let keyword = EditableSyntax.from_json(
15782       json.list_keyword, position, source);
15783     position += keyword.width;
15784     let left_paren = EditableSyntax.from_json(
15785       json.list_left_paren, position, source);
15786     position += left_paren.width;
15787     let members = EditableSyntax.from_json(
15788       json.list_members, position, source);
15789     position += members.width;
15790     let right_paren = EditableSyntax.from_json(
15791       json.list_right_paren, position, source);
15792     position += right_paren.width;
15793     return new ListExpression(
15794         keyword,
15795         left_paren,
15796         members,
15797         right_paren);
15798   }
15799   get children_keys()
15800   {
15801     if (ListExpression._children_keys == null)
15802       ListExpression._children_keys = [
15803         'keyword',
15804         'left_paren',
15805         'members',
15806         'right_paren'];
15807     return ListExpression._children_keys;
15808   }
15809 }
15810 class CollectionLiteralExpression extends EditableSyntax
15811 {
15812   constructor(
15813     name,
15814     left_brace,
15815     initializers,
15816     right_brace)
15817   {
15818     super('collection_literal_expression', {
15819       name: name,
15820       left_brace: left_brace,
15821       initializers: initializers,
15822       right_brace: right_brace });
15823   }
15824   get name() { return this.children.name; }
15825   get left_brace() { return this.children.left_brace; }
15826   get initializers() { return this.children.initializers; }
15827   get right_brace() { return this.children.right_brace; }
15828   with_name(name){
15829     return new CollectionLiteralExpression(
15830       name,
15831       this.left_brace,
15832       this.initializers,
15833       this.right_brace);
15834   }
15835   with_left_brace(left_brace){
15836     return new CollectionLiteralExpression(
15837       this.name,
15838       left_brace,
15839       this.initializers,
15840       this.right_brace);
15841   }
15842   with_initializers(initializers){
15843     return new CollectionLiteralExpression(
15844       this.name,
15845       this.left_brace,
15846       initializers,
15847       this.right_brace);
15848   }
15849   with_right_brace(right_brace){
15850     return new CollectionLiteralExpression(
15851       this.name,
15852       this.left_brace,
15853       this.initializers,
15854       right_brace);
15855   }
15856   rewrite(rewriter, parents)
15857   {
15858     if (parents == undefined)
15859       parents = [];
15860     let new_parents = parents.slice();
15861     new_parents.push(this);
15862     var name = this.name.rewrite(rewriter, new_parents);
15863     var left_brace = this.left_brace.rewrite(rewriter, new_parents);
15864     var initializers = this.initializers.rewrite(rewriter, new_parents);
15865     var right_brace = this.right_brace.rewrite(rewriter, new_parents);
15866     if (
15867       name === this.name &&
15868       left_brace === this.left_brace &&
15869       initializers === this.initializers &&
15870       right_brace === this.right_brace)
15871     {
15872       return rewriter(this, parents);
15873     }
15874     else
15875     {
15876       return rewriter(new CollectionLiteralExpression(
15877         name,
15878         left_brace,
15879         initializers,
15880         right_brace), parents);
15881     }
15882   }
15883   static from_json(json, position, source)
15884   {
15885     let name = EditableSyntax.from_json(
15886       json.collection_literal_name, position, source);
15887     position += name.width;
15888     let left_brace = EditableSyntax.from_json(
15889       json.collection_literal_left_brace, position, source);
15890     position += left_brace.width;
15891     let initializers = EditableSyntax.from_json(
15892       json.collection_literal_initializers, position, source);
15893     position += initializers.width;
15894     let right_brace = EditableSyntax.from_json(
15895       json.collection_literal_right_brace, position, source);
15896     position += right_brace.width;
15897     return new CollectionLiteralExpression(
15898         name,
15899         left_brace,
15900         initializers,
15901         right_brace);
15902   }
15903   get children_keys()
15904   {
15905     if (CollectionLiteralExpression._children_keys == null)
15906       CollectionLiteralExpression._children_keys = [
15907         'name',
15908         'left_brace',
15909         'initializers',
15910         'right_brace'];
15911     return CollectionLiteralExpression._children_keys;
15912   }
15913 }
15914 class ObjectCreationExpression extends EditableSyntax
15915 {
15916   constructor(
15917     new_keyword,
15918     object)
15919   {
15920     super('object_creation_expression', {
15921       new_keyword: new_keyword,
15922       object: object });
15923   }
15924   get new_keyword() { return this.children.new_keyword; }
15925   get object() { return this.children.object; }
15926   with_new_keyword(new_keyword){
15927     return new ObjectCreationExpression(
15928       new_keyword,
15929       this.object);
15930   }
15931   with_object(object){
15932     return new ObjectCreationExpression(
15933       this.new_keyword,
15934       object);
15935   }
15936   rewrite(rewriter, parents)
15937   {
15938     if (parents == undefined)
15939       parents = [];
15940     let new_parents = parents.slice();
15941     new_parents.push(this);
15942     var new_keyword = this.new_keyword.rewrite(rewriter, new_parents);
15943     var object = this.object.rewrite(rewriter, new_parents);
15944     if (
15945       new_keyword === this.new_keyword &&
15946       object === this.object)
15947     {
15948       return rewriter(this, parents);
15949     }
15950     else
15951     {
15952       return rewriter(new ObjectCreationExpression(
15953         new_keyword,
15954         object), parents);
15955     }
15956   }
15957   static from_json(json, position, source)
15958   {
15959     let new_keyword = EditableSyntax.from_json(
15960       json.object_creation_new_keyword, position, source);
15961     position += new_keyword.width;
15962     let object = EditableSyntax.from_json(
15963       json.object_creation_object, position, source);
15964     position += object.width;
15965     return new ObjectCreationExpression(
15966         new_keyword,
15967         object);
15968   }
15969   get children_keys()
15970   {
15971     if (ObjectCreationExpression._children_keys == null)
15972       ObjectCreationExpression._children_keys = [
15973         'new_keyword',
15974         'object'];
15975     return ObjectCreationExpression._children_keys;
15976   }
15977 }
15978 class ConstructorCall extends EditableSyntax
15979 {
15980   constructor(
15981     type,
15982     left_paren,
15983     argument_list,
15984     right_paren)
15985   {
15986     super('constructor_call', {
15987       type: type,
15988       left_paren: left_paren,
15989       argument_list: argument_list,
15990       right_paren: right_paren });
15991   }
15992   get type() { return this.children.type; }
15993   get left_paren() { return this.children.left_paren; }
15994   get argument_list() { return this.children.argument_list; }
15995   get right_paren() { return this.children.right_paren; }
15996   with_type(type){
15997     return new ConstructorCall(
15998       type,
15999       this.left_paren,
16000       this.argument_list,
16001       this.right_paren);
16002   }
16003   with_left_paren(left_paren){
16004     return new ConstructorCall(
16005       this.type,
16006       left_paren,
16007       this.argument_list,
16008       this.right_paren);
16009   }
16010   with_argument_list(argument_list){
16011     return new ConstructorCall(
16012       this.type,
16013       this.left_paren,
16014       argument_list,
16015       this.right_paren);
16016   }
16017   with_right_paren(right_paren){
16018     return new ConstructorCall(
16019       this.type,
16020       this.left_paren,
16021       this.argument_list,
16022       right_paren);
16023   }
16024   rewrite(rewriter, parents)
16025   {
16026     if (parents == undefined)
16027       parents = [];
16028     let new_parents = parents.slice();
16029     new_parents.push(this);
16030     var type = this.type.rewrite(rewriter, new_parents);
16031     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
16032     var argument_list = this.argument_list.rewrite(rewriter, new_parents);
16033     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
16034     if (
16035       type === this.type &&
16036       left_paren === this.left_paren &&
16037       argument_list === this.argument_list &&
16038       right_paren === this.right_paren)
16039     {
16040       return rewriter(this, parents);
16041     }
16042     else
16043     {
16044       return rewriter(new ConstructorCall(
16045         type,
16046         left_paren,
16047         argument_list,
16048         right_paren), parents);
16049     }
16050   }
16051   static from_json(json, position, source)
16052   {
16053     let type = EditableSyntax.from_json(
16054       json.constructor_call_type, position, source);
16055     position += type.width;
16056     let left_paren = EditableSyntax.from_json(
16057       json.constructor_call_left_paren, position, source);
16058     position += left_paren.width;
16059     let argument_list = EditableSyntax.from_json(
16060       json.constructor_call_argument_list, position, source);
16061     position += argument_list.width;
16062     let right_paren = EditableSyntax.from_json(
16063       json.constructor_call_right_paren, position, source);
16064     position += right_paren.width;
16065     return new ConstructorCall(
16066         type,
16067         left_paren,
16068         argument_list,
16069         right_paren);
16070   }
16071   get children_keys()
16072   {
16073     if (ConstructorCall._children_keys == null)
16074       ConstructorCall._children_keys = [
16075         'type',
16076         'left_paren',
16077         'argument_list',
16078         'right_paren'];
16079     return ConstructorCall._children_keys;
16080   }
16081 }
16082 class ArrayCreationExpression extends EditableSyntax
16083 {
16084   constructor(
16085     left_bracket,
16086     members,
16087     right_bracket)
16088   {
16089     super('array_creation_expression', {
16090       left_bracket: left_bracket,
16091       members: members,
16092       right_bracket: right_bracket });
16093   }
16094   get left_bracket() { return this.children.left_bracket; }
16095   get members() { return this.children.members; }
16096   get right_bracket() { return this.children.right_bracket; }
16097   with_left_bracket(left_bracket){
16098     return new ArrayCreationExpression(
16099       left_bracket,
16100       this.members,
16101       this.right_bracket);
16102   }
16103   with_members(members){
16104     return new ArrayCreationExpression(
16105       this.left_bracket,
16106       members,
16107       this.right_bracket);
16108   }
16109   with_right_bracket(right_bracket){
16110     return new ArrayCreationExpression(
16111       this.left_bracket,
16112       this.members,
16113       right_bracket);
16114   }
16115   rewrite(rewriter, parents)
16116   {
16117     if (parents == undefined)
16118       parents = [];
16119     let new_parents = parents.slice();
16120     new_parents.push(this);
16121     var left_bracket = this.left_bracket.rewrite(rewriter, new_parents);
16122     var members = this.members.rewrite(rewriter, new_parents);
16123     var right_bracket = this.right_bracket.rewrite(rewriter, new_parents);
16124     if (
16125       left_bracket === this.left_bracket &&
16126       members === this.members &&
16127       right_bracket === this.right_bracket)
16128     {
16129       return rewriter(this, parents);
16130     }
16131     else
16132     {
16133       return rewriter(new ArrayCreationExpression(
16134         left_bracket,
16135         members,
16136         right_bracket), parents);
16137     }
16138   }
16139   static from_json(json, position, source)
16140   {
16141     let left_bracket = EditableSyntax.from_json(
16142       json.array_creation_left_bracket, position, source);
16143     position += left_bracket.width;
16144     let members = EditableSyntax.from_json(
16145       json.array_creation_members, position, source);
16146     position += members.width;
16147     let right_bracket = EditableSyntax.from_json(
16148       json.array_creation_right_bracket, position, source);
16149     position += right_bracket.width;
16150     return new ArrayCreationExpression(
16151         left_bracket,
16152         members,
16153         right_bracket);
16154   }
16155   get children_keys()
16156   {
16157     if (ArrayCreationExpression._children_keys == null)
16158       ArrayCreationExpression._children_keys = [
16159         'left_bracket',
16160         'members',
16161         'right_bracket'];
16162     return ArrayCreationExpression._children_keys;
16163   }
16164 }
16165 class ArrayIntrinsicExpression extends EditableSyntax
16166 {
16167   constructor(
16168     keyword,
16169     left_paren,
16170     members,
16171     right_paren)
16172   {
16173     super('array_intrinsic_expression', {
16174       keyword: keyword,
16175       left_paren: left_paren,
16176       members: members,
16177       right_paren: right_paren });
16178   }
16179   get keyword() { return this.children.keyword; }
16180   get left_paren() { return this.children.left_paren; }
16181   get members() { return this.children.members; }
16182   get right_paren() { return this.children.right_paren; }
16183   with_keyword(keyword){
16184     return new ArrayIntrinsicExpression(
16185       keyword,
16186       this.left_paren,
16187       this.members,
16188       this.right_paren);
16189   }
16190   with_left_paren(left_paren){
16191     return new ArrayIntrinsicExpression(
16192       this.keyword,
16193       left_paren,
16194       this.members,
16195       this.right_paren);
16196   }
16197   with_members(members){
16198     return new ArrayIntrinsicExpression(
16199       this.keyword,
16200       this.left_paren,
16201       members,
16202       this.right_paren);
16203   }
16204   with_right_paren(right_paren){
16205     return new ArrayIntrinsicExpression(
16206       this.keyword,
16207       this.left_paren,
16208       this.members,
16209       right_paren);
16210   }
16211   rewrite(rewriter, parents)
16212   {
16213     if (parents == undefined)
16214       parents = [];
16215     let new_parents = parents.slice();
16216     new_parents.push(this);
16217     var keyword = this.keyword.rewrite(rewriter, new_parents);
16218     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
16219     var members = this.members.rewrite(rewriter, new_parents);
16220     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
16221     if (
16222       keyword === this.keyword &&
16223       left_paren === this.left_paren &&
16224       members === this.members &&
16225       right_paren === this.right_paren)
16226     {
16227       return rewriter(this, parents);
16228     }
16229     else
16230     {
16231       return rewriter(new ArrayIntrinsicExpression(
16232         keyword,
16233         left_paren,
16234         members,
16235         right_paren), parents);
16236     }
16237   }
16238   static from_json(json, position, source)
16239   {
16240     let keyword = EditableSyntax.from_json(
16241       json.array_intrinsic_keyword, position, source);
16242     position += keyword.width;
16243     let left_paren = EditableSyntax.from_json(
16244       json.array_intrinsic_left_paren, position, source);
16245     position += left_paren.width;
16246     let members = EditableSyntax.from_json(
16247       json.array_intrinsic_members, position, source);
16248     position += members.width;
16249     let right_paren = EditableSyntax.from_json(
16250       json.array_intrinsic_right_paren, position, source);
16251     position += right_paren.width;
16252     return new ArrayIntrinsicExpression(
16253         keyword,
16254         left_paren,
16255         members,
16256         right_paren);
16257   }
16258   get children_keys()
16259   {
16260     if (ArrayIntrinsicExpression._children_keys == null)
16261       ArrayIntrinsicExpression._children_keys = [
16262         'keyword',
16263         'left_paren',
16264         'members',
16265         'right_paren'];
16266     return ArrayIntrinsicExpression._children_keys;
16267   }
16268 }
16269 class DarrayIntrinsicExpression extends EditableSyntax
16270 {
16271   constructor(
16272     keyword,
16273     explicit_type,
16274     left_bracket,
16275     members,
16276     right_bracket)
16277   {
16278     super('darray_intrinsic_expression', {
16279       keyword: keyword,
16280       explicit_type: explicit_type,
16281       left_bracket: left_bracket,
16282       members: members,
16283       right_bracket: right_bracket });
16284   }
16285   get keyword() { return this.children.keyword; }
16286   get explicit_type() { return this.children.explicit_type; }
16287   get left_bracket() { return this.children.left_bracket; }
16288   get members() { return this.children.members; }
16289   get right_bracket() { return this.children.right_bracket; }
16290   with_keyword(keyword){
16291     return new DarrayIntrinsicExpression(
16292       keyword,
16293       this.explicit_type,
16294       this.left_bracket,
16295       this.members,
16296       this.right_bracket);
16297   }
16298   with_explicit_type(explicit_type){
16299     return new DarrayIntrinsicExpression(
16300       this.keyword,
16301       explicit_type,
16302       this.left_bracket,
16303       this.members,
16304       this.right_bracket);
16305   }
16306   with_left_bracket(left_bracket){
16307     return new DarrayIntrinsicExpression(
16308       this.keyword,
16309       this.explicit_type,
16310       left_bracket,
16311       this.members,
16312       this.right_bracket);
16313   }
16314   with_members(members){
16315     return new DarrayIntrinsicExpression(
16316       this.keyword,
16317       this.explicit_type,
16318       this.left_bracket,
16319       members,
16320       this.right_bracket);
16321   }
16322   with_right_bracket(right_bracket){
16323     return new DarrayIntrinsicExpression(
16324       this.keyword,
16325       this.explicit_type,
16326       this.left_bracket,
16327       this.members,
16328       right_bracket);
16329   }
16330   rewrite(rewriter, parents)
16331   {
16332     if (parents == undefined)
16333       parents = [];
16334     let new_parents = parents.slice();
16335     new_parents.push(this);
16336     var keyword = this.keyword.rewrite(rewriter, new_parents);
16337     var explicit_type = this.explicit_type.rewrite(rewriter, new_parents);
16338     var left_bracket = this.left_bracket.rewrite(rewriter, new_parents);
16339     var members = this.members.rewrite(rewriter, new_parents);
16340     var right_bracket = this.right_bracket.rewrite(rewriter, new_parents);
16341     if (
16342       keyword === this.keyword &&
16343       explicit_type === this.explicit_type &&
16344       left_bracket === this.left_bracket &&
16345       members === this.members &&
16346       right_bracket === this.right_bracket)
16347     {
16348       return rewriter(this, parents);
16349     }
16350     else
16351     {
16352       return rewriter(new DarrayIntrinsicExpression(
16353         keyword,
16354         explicit_type,
16355         left_bracket,
16356         members,
16357         right_bracket), parents);
16358     }
16359   }
16360   static from_json(json, position, source)
16361   {
16362     let keyword = EditableSyntax.from_json(
16363       json.darray_intrinsic_keyword, position, source);
16364     position += keyword.width;
16365     let explicit_type = EditableSyntax.from_json(
16366       json.darray_intrinsic_explicit_type, position, source);
16367     position += explicit_type.width;
16368     let left_bracket = EditableSyntax.from_json(
16369       json.darray_intrinsic_left_bracket, position, source);
16370     position += left_bracket.width;
16371     let members = EditableSyntax.from_json(
16372       json.darray_intrinsic_members, position, source);
16373     position += members.width;
16374     let right_bracket = EditableSyntax.from_json(
16375       json.darray_intrinsic_right_bracket, position, source);
16376     position += right_bracket.width;
16377     return new DarrayIntrinsicExpression(
16378         keyword,
16379         explicit_type,
16380         left_bracket,
16381         members,
16382         right_bracket);
16383   }
16384   get children_keys()
16385   {
16386     if (DarrayIntrinsicExpression._children_keys == null)
16387       DarrayIntrinsicExpression._children_keys = [
16388         'keyword',
16389         'explicit_type',
16390         'left_bracket',
16391         'members',
16392         'right_bracket'];
16393     return DarrayIntrinsicExpression._children_keys;
16394   }
16395 }
16396 class DictionaryIntrinsicExpression extends EditableSyntax
16397 {
16398   constructor(
16399     keyword,
16400     explicit_type,
16401     left_bracket,
16402     members,
16403     right_bracket)
16404   {
16405     super('dictionary_intrinsic_expression', {
16406       keyword: keyword,
16407       explicit_type: explicit_type,
16408       left_bracket: left_bracket,
16409       members: members,
16410       right_bracket: right_bracket });
16411   }
16412   get keyword() { return this.children.keyword; }
16413   get explicit_type() { return this.children.explicit_type; }
16414   get left_bracket() { return this.children.left_bracket; }
16415   get members() { return this.children.members; }
16416   get right_bracket() { return this.children.right_bracket; }
16417   with_keyword(keyword){
16418     return new DictionaryIntrinsicExpression(
16419       keyword,
16420       this.explicit_type,
16421       this.left_bracket,
16422       this.members,
16423       this.right_bracket);
16424   }
16425   with_explicit_type(explicit_type){
16426     return new DictionaryIntrinsicExpression(
16427       this.keyword,
16428       explicit_type,
16429       this.left_bracket,
16430       this.members,
16431       this.right_bracket);
16432   }
16433   with_left_bracket(left_bracket){
16434     return new DictionaryIntrinsicExpression(
16435       this.keyword,
16436       this.explicit_type,
16437       left_bracket,
16438       this.members,
16439       this.right_bracket);
16440   }
16441   with_members(members){
16442     return new DictionaryIntrinsicExpression(
16443       this.keyword,
16444       this.explicit_type,
16445       this.left_bracket,
16446       members,
16447       this.right_bracket);
16448   }
16449   with_right_bracket(right_bracket){
16450     return new DictionaryIntrinsicExpression(
16451       this.keyword,
16452       this.explicit_type,
16453       this.left_bracket,
16454       this.members,
16455       right_bracket);
16456   }
16457   rewrite(rewriter, parents)
16458   {
16459     if (parents == undefined)
16460       parents = [];
16461     let new_parents = parents.slice();
16462     new_parents.push(this);
16463     var keyword = this.keyword.rewrite(rewriter, new_parents);
16464     var explicit_type = this.explicit_type.rewrite(rewriter, new_parents);
16465     var left_bracket = this.left_bracket.rewrite(rewriter, new_parents);
16466     var members = this.members.rewrite(rewriter, new_parents);
16467     var right_bracket = this.right_bracket.rewrite(rewriter, new_parents);
16468     if (
16469       keyword === this.keyword &&
16470       explicit_type === this.explicit_type &&
16471       left_bracket === this.left_bracket &&
16472       members === this.members &&
16473       right_bracket === this.right_bracket)
16474     {
16475       return rewriter(this, parents);
16476     }
16477     else
16478     {
16479       return rewriter(new DictionaryIntrinsicExpression(
16480         keyword,
16481         explicit_type,
16482         left_bracket,
16483         members,
16484         right_bracket), parents);
16485     }
16486   }
16487   static from_json(json, position, source)
16488   {
16489     let keyword = EditableSyntax.from_json(
16490       json.dictionary_intrinsic_keyword, position, source);
16491     position += keyword.width;
16492     let explicit_type = EditableSyntax.from_json(
16493       json.dictionary_intrinsic_explicit_type, position, source);
16494     position += explicit_type.width;
16495     let left_bracket = EditableSyntax.from_json(
16496       json.dictionary_intrinsic_left_bracket, position, source);
16497     position += left_bracket.width;
16498     let members = EditableSyntax.from_json(
16499       json.dictionary_intrinsic_members, position, source);
16500     position += members.width;
16501     let right_bracket = EditableSyntax.from_json(
16502       json.dictionary_intrinsic_right_bracket, position, source);
16503     position += right_bracket.width;
16504     return new DictionaryIntrinsicExpression(
16505         keyword,
16506         explicit_type,
16507         left_bracket,
16508         members,
16509         right_bracket);
16510   }
16511   get children_keys()
16512   {
16513     if (DictionaryIntrinsicExpression._children_keys == null)
16514       DictionaryIntrinsicExpression._children_keys = [
16515         'keyword',
16516         'explicit_type',
16517         'left_bracket',
16518         'members',
16519         'right_bracket'];
16520     return DictionaryIntrinsicExpression._children_keys;
16521   }
16522 }
16523 class KeysetIntrinsicExpression extends EditableSyntax
16524 {
16525   constructor(
16526     keyword,
16527     explicit_type,
16528     left_bracket,
16529     members,
16530     right_bracket)
16531   {
16532     super('keyset_intrinsic_expression', {
16533       keyword: keyword,
16534       explicit_type: explicit_type,
16535       left_bracket: left_bracket,
16536       members: members,
16537       right_bracket: right_bracket });
16538   }
16539   get keyword() { return this.children.keyword; }
16540   get explicit_type() { return this.children.explicit_type; }
16541   get left_bracket() { return this.children.left_bracket; }
16542   get members() { return this.children.members; }
16543   get right_bracket() { return this.children.right_bracket; }
16544   with_keyword(keyword){
16545     return new KeysetIntrinsicExpression(
16546       keyword,
16547       this.explicit_type,
16548       this.left_bracket,
16549       this.members,
16550       this.right_bracket);
16551   }
16552   with_explicit_type(explicit_type){
16553     return new KeysetIntrinsicExpression(
16554       this.keyword,
16555       explicit_type,
16556       this.left_bracket,
16557       this.members,
16558       this.right_bracket);
16559   }
16560   with_left_bracket(left_bracket){
16561     return new KeysetIntrinsicExpression(
16562       this.keyword,
16563       this.explicit_type,
16564       left_bracket,
16565       this.members,
16566       this.right_bracket);
16567   }
16568   with_members(members){
16569     return new KeysetIntrinsicExpression(
16570       this.keyword,
16571       this.explicit_type,
16572       this.left_bracket,
16573       members,
16574       this.right_bracket);
16575   }
16576   with_right_bracket(right_bracket){
16577     return new KeysetIntrinsicExpression(
16578       this.keyword,
16579       this.explicit_type,
16580       this.left_bracket,
16581       this.members,
16582       right_bracket);
16583   }
16584   rewrite(rewriter, parents)
16585   {
16586     if (parents == undefined)
16587       parents = [];
16588     let new_parents = parents.slice();
16589     new_parents.push(this);
16590     var keyword = this.keyword.rewrite(rewriter, new_parents);
16591     var explicit_type = this.explicit_type.rewrite(rewriter, new_parents);
16592     var left_bracket = this.left_bracket.rewrite(rewriter, new_parents);
16593     var members = this.members.rewrite(rewriter, new_parents);
16594     var right_bracket = this.right_bracket.rewrite(rewriter, new_parents);
16595     if (
16596       keyword === this.keyword &&
16597       explicit_type === this.explicit_type &&
16598       left_bracket === this.left_bracket &&
16599       members === this.members &&
16600       right_bracket === this.right_bracket)
16601     {
16602       return rewriter(this, parents);
16603     }
16604     else
16605     {
16606       return rewriter(new KeysetIntrinsicExpression(
16607         keyword,
16608         explicit_type,
16609         left_bracket,
16610         members,
16611         right_bracket), parents);
16612     }
16613   }
16614   static from_json(json, position, source)
16615   {
16616     let keyword = EditableSyntax.from_json(
16617       json.keyset_intrinsic_keyword, position, source);
16618     position += keyword.width;
16619     let explicit_type = EditableSyntax.from_json(
16620       json.keyset_intrinsic_explicit_type, position, source);
16621     position += explicit_type.width;
16622     let left_bracket = EditableSyntax.from_json(
16623       json.keyset_intrinsic_left_bracket, position, source);
16624     position += left_bracket.width;
16625     let members = EditableSyntax.from_json(
16626       json.keyset_intrinsic_members, position, source);
16627     position += members.width;
16628     let right_bracket = EditableSyntax.from_json(
16629       json.keyset_intrinsic_right_bracket, position, source);
16630     position += right_bracket.width;
16631     return new KeysetIntrinsicExpression(
16632         keyword,
16633         explicit_type,
16634         left_bracket,
16635         members,
16636         right_bracket);
16637   }
16638   get children_keys()
16639   {
16640     if (KeysetIntrinsicExpression._children_keys == null)
16641       KeysetIntrinsicExpression._children_keys = [
16642         'keyword',
16643         'explicit_type',
16644         'left_bracket',
16645         'members',
16646         'right_bracket'];
16647     return KeysetIntrinsicExpression._children_keys;
16648   }
16649 }
16650 class VarrayIntrinsicExpression extends EditableSyntax
16651 {
16652   constructor(
16653     keyword,
16654     explicit_type,
16655     left_bracket,
16656     members,
16657     right_bracket)
16658   {
16659     super('varray_intrinsic_expression', {
16660       keyword: keyword,
16661       explicit_type: explicit_type,
16662       left_bracket: left_bracket,
16663       members: members,
16664       right_bracket: right_bracket });
16665   }
16666   get keyword() { return this.children.keyword; }
16667   get explicit_type() { return this.children.explicit_type; }
16668   get left_bracket() { return this.children.left_bracket; }
16669   get members() { return this.children.members; }
16670   get right_bracket() { return this.children.right_bracket; }
16671   with_keyword(keyword){
16672     return new VarrayIntrinsicExpression(
16673       keyword,
16674       this.explicit_type,
16675       this.left_bracket,
16676       this.members,
16677       this.right_bracket);
16678   }
16679   with_explicit_type(explicit_type){
16680     return new VarrayIntrinsicExpression(
16681       this.keyword,
16682       explicit_type,
16683       this.left_bracket,
16684       this.members,
16685       this.right_bracket);
16686   }
16687   with_left_bracket(left_bracket){
16688     return new VarrayIntrinsicExpression(
16689       this.keyword,
16690       this.explicit_type,
16691       left_bracket,
16692       this.members,
16693       this.right_bracket);
16694   }
16695   with_members(members){
16696     return new VarrayIntrinsicExpression(
16697       this.keyword,
16698       this.explicit_type,
16699       this.left_bracket,
16700       members,
16701       this.right_bracket);
16702   }
16703   with_right_bracket(right_bracket){
16704     return new VarrayIntrinsicExpression(
16705       this.keyword,
16706       this.explicit_type,
16707       this.left_bracket,
16708       this.members,
16709       right_bracket);
16710   }
16711   rewrite(rewriter, parents)
16712   {
16713     if (parents == undefined)
16714       parents = [];
16715     let new_parents = parents.slice();
16716     new_parents.push(this);
16717     var keyword = this.keyword.rewrite(rewriter, new_parents);
16718     var explicit_type = this.explicit_type.rewrite(rewriter, new_parents);
16719     var left_bracket = this.left_bracket.rewrite(rewriter, new_parents);
16720     var members = this.members.rewrite(rewriter, new_parents);
16721     var right_bracket = this.right_bracket.rewrite(rewriter, new_parents);
16722     if (
16723       keyword === this.keyword &&
16724       explicit_type === this.explicit_type &&
16725       left_bracket === this.left_bracket &&
16726       members === this.members &&
16727       right_bracket === this.right_bracket)
16728     {
16729       return rewriter(this, parents);
16730     }
16731     else
16732     {
16733       return rewriter(new VarrayIntrinsicExpression(
16734         keyword,
16735         explicit_type,
16736         left_bracket,
16737         members,
16738         right_bracket), parents);
16739     }
16740   }
16741   static from_json(json, position, source)
16742   {
16743     let keyword = EditableSyntax.from_json(
16744       json.varray_intrinsic_keyword, position, source);
16745     position += keyword.width;
16746     let explicit_type = EditableSyntax.from_json(
16747       json.varray_intrinsic_explicit_type, position, source);
16748     position += explicit_type.width;
16749     let left_bracket = EditableSyntax.from_json(
16750       json.varray_intrinsic_left_bracket, position, source);
16751     position += left_bracket.width;
16752     let members = EditableSyntax.from_json(
16753       json.varray_intrinsic_members, position, source);
16754     position += members.width;
16755     let right_bracket = EditableSyntax.from_json(
16756       json.varray_intrinsic_right_bracket, position, source);
16757     position += right_bracket.width;
16758     return new VarrayIntrinsicExpression(
16759         keyword,
16760         explicit_type,
16761         left_bracket,
16762         members,
16763         right_bracket);
16764   }
16765   get children_keys()
16766   {
16767     if (VarrayIntrinsicExpression._children_keys == null)
16768       VarrayIntrinsicExpression._children_keys = [
16769         'keyword',
16770         'explicit_type',
16771         'left_bracket',
16772         'members',
16773         'right_bracket'];
16774     return VarrayIntrinsicExpression._children_keys;
16775   }
16776 }
16777 class VectorIntrinsicExpression extends EditableSyntax
16778 {
16779   constructor(
16780     keyword,
16781     explicit_type,
16782     left_bracket,
16783     members,
16784     right_bracket)
16785   {
16786     super('vector_intrinsic_expression', {
16787       keyword: keyword,
16788       explicit_type: explicit_type,
16789       left_bracket: left_bracket,
16790       members: members,
16791       right_bracket: right_bracket });
16792   }
16793   get keyword() { return this.children.keyword; }
16794   get explicit_type() { return this.children.explicit_type; }
16795   get left_bracket() { return this.children.left_bracket; }
16796   get members() { return this.children.members; }
16797   get right_bracket() { return this.children.right_bracket; }
16798   with_keyword(keyword){
16799     return new VectorIntrinsicExpression(
16800       keyword,
16801       this.explicit_type,
16802       this.left_bracket,
16803       this.members,
16804       this.right_bracket);
16805   }
16806   with_explicit_type(explicit_type){
16807     return new VectorIntrinsicExpression(
16808       this.keyword,
16809       explicit_type,
16810       this.left_bracket,
16811       this.members,
16812       this.right_bracket);
16813   }
16814   with_left_bracket(left_bracket){
16815     return new VectorIntrinsicExpression(
16816       this.keyword,
16817       this.explicit_type,
16818       left_bracket,
16819       this.members,
16820       this.right_bracket);
16821   }
16822   with_members(members){
16823     return new VectorIntrinsicExpression(
16824       this.keyword,
16825       this.explicit_type,
16826       this.left_bracket,
16827       members,
16828       this.right_bracket);
16829   }
16830   with_right_bracket(right_bracket){
16831     return new VectorIntrinsicExpression(
16832       this.keyword,
16833       this.explicit_type,
16834       this.left_bracket,
16835       this.members,
16836       right_bracket);
16837   }
16838   rewrite(rewriter, parents)
16839   {
16840     if (parents == undefined)
16841       parents = [];
16842     let new_parents = parents.slice();
16843     new_parents.push(this);
16844     var keyword = this.keyword.rewrite(rewriter, new_parents);
16845     var explicit_type = this.explicit_type.rewrite(rewriter, new_parents);
16846     var left_bracket = this.left_bracket.rewrite(rewriter, new_parents);
16847     var members = this.members.rewrite(rewriter, new_parents);
16848     var right_bracket = this.right_bracket.rewrite(rewriter, new_parents);
16849     if (
16850       keyword === this.keyword &&
16851       explicit_type === this.explicit_type &&
16852       left_bracket === this.left_bracket &&
16853       members === this.members &&
16854       right_bracket === this.right_bracket)
16855     {
16856       return rewriter(this, parents);
16857     }
16858     else
16859     {
16860       return rewriter(new VectorIntrinsicExpression(
16861         keyword,
16862         explicit_type,
16863         left_bracket,
16864         members,
16865         right_bracket), parents);
16866     }
16867   }
16868   static from_json(json, position, source)
16869   {
16870     let keyword = EditableSyntax.from_json(
16871       json.vector_intrinsic_keyword, position, source);
16872     position += keyword.width;
16873     let explicit_type = EditableSyntax.from_json(
16874       json.vector_intrinsic_explicit_type, position, source);
16875     position += explicit_type.width;
16876     let left_bracket = EditableSyntax.from_json(
16877       json.vector_intrinsic_left_bracket, position, source);
16878     position += left_bracket.width;
16879     let members = EditableSyntax.from_json(
16880       json.vector_intrinsic_members, position, source);
16881     position += members.width;
16882     let right_bracket = EditableSyntax.from_json(
16883       json.vector_intrinsic_right_bracket, position, source);
16884     position += right_bracket.width;
16885     return new VectorIntrinsicExpression(
16886         keyword,
16887         explicit_type,
16888         left_bracket,
16889         members,
16890         right_bracket);
16891   }
16892   get children_keys()
16893   {
16894     if (VectorIntrinsicExpression._children_keys == null)
16895       VectorIntrinsicExpression._children_keys = [
16896         'keyword',
16897         'explicit_type',
16898         'left_bracket',
16899         'members',
16900         'right_bracket'];
16901     return VectorIntrinsicExpression._children_keys;
16902   }
16903 }
16904 class ElementInitializer extends EditableSyntax
16905 {
16906   constructor(
16907     key,
16908     arrow,
16909     value)
16910   {
16911     super('element_initializer', {
16912       key: key,
16913       arrow: arrow,
16914       value: value });
16915   }
16916   get key() { return this.children.key; }
16917   get arrow() { return this.children.arrow; }
16918   get value() { return this.children.value; }
16919   with_key(key){
16920     return new ElementInitializer(
16921       key,
16922       this.arrow,
16923       this.value);
16924   }
16925   with_arrow(arrow){
16926     return new ElementInitializer(
16927       this.key,
16928       arrow,
16929       this.value);
16930   }
16931   with_value(value){
16932     return new ElementInitializer(
16933       this.key,
16934       this.arrow,
16935       value);
16936   }
16937   rewrite(rewriter, parents)
16938   {
16939     if (parents == undefined)
16940       parents = [];
16941     let new_parents = parents.slice();
16942     new_parents.push(this);
16943     var key = this.key.rewrite(rewriter, new_parents);
16944     var arrow = this.arrow.rewrite(rewriter, new_parents);
16945     var value = this.value.rewrite(rewriter, new_parents);
16946     if (
16947       key === this.key &&
16948       arrow === this.arrow &&
16949       value === this.value)
16950     {
16951       return rewriter(this, parents);
16952     }
16953     else
16954     {
16955       return rewriter(new ElementInitializer(
16956         key,
16957         arrow,
16958         value), parents);
16959     }
16960   }
16961   static from_json(json, position, source)
16962   {
16963     let key = EditableSyntax.from_json(
16964       json.element_key, position, source);
16965     position += key.width;
16966     let arrow = EditableSyntax.from_json(
16967       json.element_arrow, position, source);
16968     position += arrow.width;
16969     let value = EditableSyntax.from_json(
16970       json.element_value, position, source);
16971     position += value.width;
16972     return new ElementInitializer(
16973         key,
16974         arrow,
16975         value);
16976   }
16977   get children_keys()
16978   {
16979     if (ElementInitializer._children_keys == null)
16980       ElementInitializer._children_keys = [
16981         'key',
16982         'arrow',
16983         'value'];
16984     return ElementInitializer._children_keys;
16985   }
16986 }
16987 class SubscriptExpression extends EditableSyntax
16988 {
16989   constructor(
16990     receiver,
16991     left_bracket,
16992     index,
16993     right_bracket)
16994   {
16995     super('subscript_expression', {
16996       receiver: receiver,
16997       left_bracket: left_bracket,
16998       index: index,
16999       right_bracket: right_bracket });
17000   }
17001   get receiver() { return this.children.receiver; }
17002   get left_bracket() { return this.children.left_bracket; }
17003   get index() { return this.children.index; }
17004   get right_bracket() { return this.children.right_bracket; }
17005   with_receiver(receiver){
17006     return new SubscriptExpression(
17007       receiver,
17008       this.left_bracket,
17009       this.index,
17010       this.right_bracket);
17011   }
17012   with_left_bracket(left_bracket){
17013     return new SubscriptExpression(
17014       this.receiver,
17015       left_bracket,
17016       this.index,
17017       this.right_bracket);
17018   }
17019   with_index(index){
17020     return new SubscriptExpression(
17021       this.receiver,
17022       this.left_bracket,
17023       index,
17024       this.right_bracket);
17025   }
17026   with_right_bracket(right_bracket){
17027     return new SubscriptExpression(
17028       this.receiver,
17029       this.left_bracket,
17030       this.index,
17031       right_bracket);
17032   }
17033   rewrite(rewriter, parents)
17034   {
17035     if (parents == undefined)
17036       parents = [];
17037     let new_parents = parents.slice();
17038     new_parents.push(this);
17039     var receiver = this.receiver.rewrite(rewriter, new_parents);
17040     var left_bracket = this.left_bracket.rewrite(rewriter, new_parents);
17041     var index = this.index.rewrite(rewriter, new_parents);
17042     var right_bracket = this.right_bracket.rewrite(rewriter, new_parents);
17043     if (
17044       receiver === this.receiver &&
17045       left_bracket === this.left_bracket &&
17046       index === this.index &&
17047       right_bracket === this.right_bracket)
17048     {
17049       return rewriter(this, parents);
17050     }
17051     else
17052     {
17053       return rewriter(new SubscriptExpression(
17054         receiver,
17055         left_bracket,
17056         index,
17057         right_bracket), parents);
17058     }
17059   }
17060   static from_json(json, position, source)
17061   {
17062     let receiver = EditableSyntax.from_json(
17063       json.subscript_receiver, position, source);
17064     position += receiver.width;
17065     let left_bracket = EditableSyntax.from_json(
17066       json.subscript_left_bracket, position, source);
17067     position += left_bracket.width;
17068     let index = EditableSyntax.from_json(
17069       json.subscript_index, position, source);
17070     position += index.width;
17071     let right_bracket = EditableSyntax.from_json(
17072       json.subscript_right_bracket, position, source);
17073     position += right_bracket.width;
17074     return new SubscriptExpression(
17075         receiver,
17076         left_bracket,
17077         index,
17078         right_bracket);
17079   }
17080   get children_keys()
17081   {
17082     if (SubscriptExpression._children_keys == null)
17083       SubscriptExpression._children_keys = [
17084         'receiver',
17085         'left_bracket',
17086         'index',
17087         'right_bracket'];
17088     return SubscriptExpression._children_keys;
17089   }
17090 }
17091 class EmbeddedSubscriptExpression extends EditableSyntax
17092 {
17093   constructor(
17094     receiver,
17095     left_bracket,
17096     index,
17097     right_bracket)
17098   {
17099     super('embedded_subscript_expression', {
17100       receiver: receiver,
17101       left_bracket: left_bracket,
17102       index: index,
17103       right_bracket: right_bracket });
17104   }
17105   get receiver() { return this.children.receiver; }
17106   get left_bracket() { return this.children.left_bracket; }
17107   get index() { return this.children.index; }
17108   get right_bracket() { return this.children.right_bracket; }
17109   with_receiver(receiver){
17110     return new EmbeddedSubscriptExpression(
17111       receiver,
17112       this.left_bracket,
17113       this.index,
17114       this.right_bracket);
17115   }
17116   with_left_bracket(left_bracket){
17117     return new EmbeddedSubscriptExpression(
17118       this.receiver,
17119       left_bracket,
17120       this.index,
17121       this.right_bracket);
17122   }
17123   with_index(index){
17124     return new EmbeddedSubscriptExpression(
17125       this.receiver,
17126       this.left_bracket,
17127       index,
17128       this.right_bracket);
17129   }
17130   with_right_bracket(right_bracket){
17131     return new EmbeddedSubscriptExpression(
17132       this.receiver,
17133       this.left_bracket,
17134       this.index,
17135       right_bracket);
17136   }
17137   rewrite(rewriter, parents)
17138   {
17139     if (parents == undefined)
17140       parents = [];
17141     let new_parents = parents.slice();
17142     new_parents.push(this);
17143     var receiver = this.receiver.rewrite(rewriter, new_parents);
17144     var left_bracket = this.left_bracket.rewrite(rewriter, new_parents);
17145     var index = this.index.rewrite(rewriter, new_parents);
17146     var right_bracket = this.right_bracket.rewrite(rewriter, new_parents);
17147     if (
17148       receiver === this.receiver &&
17149       left_bracket === this.left_bracket &&
17150       index === this.index &&
17151       right_bracket === this.right_bracket)
17152     {
17153       return rewriter(this, parents);
17154     }
17155     else
17156     {
17157       return rewriter(new EmbeddedSubscriptExpression(
17158         receiver,
17159         left_bracket,
17160         index,
17161         right_bracket), parents);
17162     }
17163   }
17164   static from_json(json, position, source)
17165   {
17166     let receiver = EditableSyntax.from_json(
17167       json.embedded_subscript_receiver, position, source);
17168     position += receiver.width;
17169     let left_bracket = EditableSyntax.from_json(
17170       json.embedded_subscript_left_bracket, position, source);
17171     position += left_bracket.width;
17172     let index = EditableSyntax.from_json(
17173       json.embedded_subscript_index, position, source);
17174     position += index.width;
17175     let right_bracket = EditableSyntax.from_json(
17176       json.embedded_subscript_right_bracket, position, source);
17177     position += right_bracket.width;
17178     return new EmbeddedSubscriptExpression(
17179         receiver,
17180         left_bracket,
17181         index,
17182         right_bracket);
17183   }
17184   get children_keys()
17185   {
17186     if (EmbeddedSubscriptExpression._children_keys == null)
17187       EmbeddedSubscriptExpression._children_keys = [
17188         'receiver',
17189         'left_bracket',
17190         'index',
17191         'right_bracket'];
17192     return EmbeddedSubscriptExpression._children_keys;
17193   }
17194 }
17195 class AwaitableCreationExpression extends EditableSyntax
17196 {
17197   constructor(
17198     attribute_spec,
17199     async,
17200     coroutine,
17201     compound_statement)
17202   {
17203     super('awaitable_creation_expression', {
17204       attribute_spec: attribute_spec,
17205       async: async,
17206       coroutine: coroutine,
17207       compound_statement: compound_statement });
17208   }
17209   get attribute_spec() { return this.children.attribute_spec; }
17210   get async() { return this.children.async; }
17211   get coroutine() { return this.children.coroutine; }
17212   get compound_statement() { return this.children.compound_statement; }
17213   with_attribute_spec(attribute_spec){
17214     return new AwaitableCreationExpression(
17215       attribute_spec,
17216       this.async,
17217       this.coroutine,
17218       this.compound_statement);
17219   }
17220   with_async(async){
17221     return new AwaitableCreationExpression(
17222       this.attribute_spec,
17223       async,
17224       this.coroutine,
17225       this.compound_statement);
17226   }
17227   with_coroutine(coroutine){
17228     return new AwaitableCreationExpression(
17229       this.attribute_spec,
17230       this.async,
17231       coroutine,
17232       this.compound_statement);
17233   }
17234   with_compound_statement(compound_statement){
17235     return new AwaitableCreationExpression(
17236       this.attribute_spec,
17237       this.async,
17238       this.coroutine,
17239       compound_statement);
17240   }
17241   rewrite(rewriter, parents)
17242   {
17243     if (parents == undefined)
17244       parents = [];
17245     let new_parents = parents.slice();
17246     new_parents.push(this);
17247     var attribute_spec = this.attribute_spec.rewrite(rewriter, new_parents);
17248     var async = this.async.rewrite(rewriter, new_parents);
17249     var coroutine = this.coroutine.rewrite(rewriter, new_parents);
17250     var compound_statement = this.compound_statement.rewrite(rewriter, new_parents);
17251     if (
17252       attribute_spec === this.attribute_spec &&
17253       async === this.async &&
17254       coroutine === this.coroutine &&
17255       compound_statement === this.compound_statement)
17256     {
17257       return rewriter(this, parents);
17258     }
17259     else
17260     {
17261       return rewriter(new AwaitableCreationExpression(
17262         attribute_spec,
17263         async,
17264         coroutine,
17265         compound_statement), parents);
17266     }
17267   }
17268   static from_json(json, position, source)
17269   {
17270     let attribute_spec = EditableSyntax.from_json(
17271       json.awaitable_attribute_spec, position, source);
17272     position += attribute_spec.width;
17273     let async = EditableSyntax.from_json(
17274       json.awaitable_async, position, source);
17275     position += async.width;
17276     let coroutine = EditableSyntax.from_json(
17277       json.awaitable_coroutine, position, source);
17278     position += coroutine.width;
17279     let compound_statement = EditableSyntax.from_json(
17280       json.awaitable_compound_statement, position, source);
17281     position += compound_statement.width;
17282     return new AwaitableCreationExpression(
17283         attribute_spec,
17284         async,
17285         coroutine,
17286         compound_statement);
17287   }
17288   get children_keys()
17289   {
17290     if (AwaitableCreationExpression._children_keys == null)
17291       AwaitableCreationExpression._children_keys = [
17292         'attribute_spec',
17293         'async',
17294         'coroutine',
17295         'compound_statement'];
17296     return AwaitableCreationExpression._children_keys;
17297   }
17298 }
17299 class XHPChildrenDeclaration extends EditableSyntax
17300 {
17301   constructor(
17302     keyword,
17303     expression,
17304     semicolon)
17305   {
17306     super('xhp_children_declaration', {
17307       keyword: keyword,
17308       expression: expression,
17309       semicolon: semicolon });
17310   }
17311   get keyword() { return this.children.keyword; }
17312   get expression() { return this.children.expression; }
17313   get semicolon() { return this.children.semicolon; }
17314   with_keyword(keyword){
17315     return new XHPChildrenDeclaration(
17316       keyword,
17317       this.expression,
17318       this.semicolon);
17319   }
17320   with_expression(expression){
17321     return new XHPChildrenDeclaration(
17322       this.keyword,
17323       expression,
17324       this.semicolon);
17325   }
17326   with_semicolon(semicolon){
17327     return new XHPChildrenDeclaration(
17328       this.keyword,
17329       this.expression,
17330       semicolon);
17331   }
17332   rewrite(rewriter, parents)
17333   {
17334     if (parents == undefined)
17335       parents = [];
17336     let new_parents = parents.slice();
17337     new_parents.push(this);
17338     var keyword = this.keyword.rewrite(rewriter, new_parents);
17339     var expression = this.expression.rewrite(rewriter, new_parents);
17340     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
17341     if (
17342       keyword === this.keyword &&
17343       expression === this.expression &&
17344       semicolon === this.semicolon)
17345     {
17346       return rewriter(this, parents);
17347     }
17348     else
17349     {
17350       return rewriter(new XHPChildrenDeclaration(
17351         keyword,
17352         expression,
17353         semicolon), parents);
17354     }
17355   }
17356   static from_json(json, position, source)
17357   {
17358     let keyword = EditableSyntax.from_json(
17359       json.xhp_children_keyword, position, source);
17360     position += keyword.width;
17361     let expression = EditableSyntax.from_json(
17362       json.xhp_children_expression, position, source);
17363     position += expression.width;
17364     let semicolon = EditableSyntax.from_json(
17365       json.xhp_children_semicolon, position, source);
17366     position += semicolon.width;
17367     return new XHPChildrenDeclaration(
17368         keyword,
17369         expression,
17370         semicolon);
17371   }
17372   get children_keys()
17373   {
17374     if (XHPChildrenDeclaration._children_keys == null)
17375       XHPChildrenDeclaration._children_keys = [
17376         'keyword',
17377         'expression',
17378         'semicolon'];
17379     return XHPChildrenDeclaration._children_keys;
17380   }
17381 }
17382 class XHPChildrenParenthesizedList extends EditableSyntax
17383 {
17384   constructor(
17385     left_paren,
17386     xhp_children,
17387     right_paren)
17388   {
17389     super('xhp_children_parenthesized_list', {
17390       left_paren: left_paren,
17391       xhp_children: xhp_children,
17392       right_paren: right_paren });
17393   }
17394   get left_paren() { return this.children.left_paren; }
17395   get xhp_children() { return this.children.xhp_children; }
17396   get right_paren() { return this.children.right_paren; }
17397   with_left_paren(left_paren){
17398     return new XHPChildrenParenthesizedList(
17399       left_paren,
17400       this.xhp_children,
17401       this.right_paren);
17402   }
17403   with_xhp_children(xhp_children){
17404     return new XHPChildrenParenthesizedList(
17405       this.left_paren,
17406       xhp_children,
17407       this.right_paren);
17408   }
17409   with_right_paren(right_paren){
17410     return new XHPChildrenParenthesizedList(
17411       this.left_paren,
17412       this.xhp_children,
17413       right_paren);
17414   }
17415   rewrite(rewriter, parents)
17416   {
17417     if (parents == undefined)
17418       parents = [];
17419     let new_parents = parents.slice();
17420     new_parents.push(this);
17421     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
17422     var xhp_children = this.xhp_children.rewrite(rewriter, new_parents);
17423     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
17424     if (
17425       left_paren === this.left_paren &&
17426       xhp_children === this.xhp_children &&
17427       right_paren === this.right_paren)
17428     {
17429       return rewriter(this, parents);
17430     }
17431     else
17432     {
17433       return rewriter(new XHPChildrenParenthesizedList(
17434         left_paren,
17435         xhp_children,
17436         right_paren), parents);
17437     }
17438   }
17439   static from_json(json, position, source)
17440   {
17441     let left_paren = EditableSyntax.from_json(
17442       json.xhp_children_list_left_paren, position, source);
17443     position += left_paren.width;
17444     let xhp_children = EditableSyntax.from_json(
17445       json.xhp_children_list_xhp_children, position, source);
17446     position += xhp_children.width;
17447     let right_paren = EditableSyntax.from_json(
17448       json.xhp_children_list_right_paren, position, source);
17449     position += right_paren.width;
17450     return new XHPChildrenParenthesizedList(
17451         left_paren,
17452         xhp_children,
17453         right_paren);
17454   }
17455   get children_keys()
17456   {
17457     if (XHPChildrenParenthesizedList._children_keys == null)
17458       XHPChildrenParenthesizedList._children_keys = [
17459         'left_paren',
17460         'xhp_children',
17461         'right_paren'];
17462     return XHPChildrenParenthesizedList._children_keys;
17463   }
17464 }
17465 class XHPCategoryDeclaration extends EditableSyntax
17466 {
17467   constructor(
17468     keyword,
17469     categories,
17470     semicolon)
17471   {
17472     super('xhp_category_declaration', {
17473       keyword: keyword,
17474       categories: categories,
17475       semicolon: semicolon });
17476   }
17477   get keyword() { return this.children.keyword; }
17478   get categories() { return this.children.categories; }
17479   get semicolon() { return this.children.semicolon; }
17480   with_keyword(keyword){
17481     return new XHPCategoryDeclaration(
17482       keyword,
17483       this.categories,
17484       this.semicolon);
17485   }
17486   with_categories(categories){
17487     return new XHPCategoryDeclaration(
17488       this.keyword,
17489       categories,
17490       this.semicolon);
17491   }
17492   with_semicolon(semicolon){
17493     return new XHPCategoryDeclaration(
17494       this.keyword,
17495       this.categories,
17496       semicolon);
17497   }
17498   rewrite(rewriter, parents)
17499   {
17500     if (parents == undefined)
17501       parents = [];
17502     let new_parents = parents.slice();
17503     new_parents.push(this);
17504     var keyword = this.keyword.rewrite(rewriter, new_parents);
17505     var categories = this.categories.rewrite(rewriter, new_parents);
17506     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
17507     if (
17508       keyword === this.keyword &&
17509       categories === this.categories &&
17510       semicolon === this.semicolon)
17511     {
17512       return rewriter(this, parents);
17513     }
17514     else
17515     {
17516       return rewriter(new XHPCategoryDeclaration(
17517         keyword,
17518         categories,
17519         semicolon), parents);
17520     }
17521   }
17522   static from_json(json, position, source)
17523   {
17524     let keyword = EditableSyntax.from_json(
17525       json.xhp_category_keyword, position, source);
17526     position += keyword.width;
17527     let categories = EditableSyntax.from_json(
17528       json.xhp_category_categories, position, source);
17529     position += categories.width;
17530     let semicolon = EditableSyntax.from_json(
17531       json.xhp_category_semicolon, position, source);
17532     position += semicolon.width;
17533     return new XHPCategoryDeclaration(
17534         keyword,
17535         categories,
17536         semicolon);
17537   }
17538   get children_keys()
17539   {
17540     if (XHPCategoryDeclaration._children_keys == null)
17541       XHPCategoryDeclaration._children_keys = [
17542         'keyword',
17543         'categories',
17544         'semicolon'];
17545     return XHPCategoryDeclaration._children_keys;
17546   }
17547 }
17548 class XHPEnumType extends EditableSyntax
17549 {
17550   constructor(
17551     optional,
17552     keyword,
17553     left_brace,
17554     values,
17555     right_brace)
17556   {
17557     super('xhp_enum_type', {
17558       optional: optional,
17559       keyword: keyword,
17560       left_brace: left_brace,
17561       values: values,
17562       right_brace: right_brace });
17563   }
17564   get optional() { return this.children.optional; }
17565   get keyword() { return this.children.keyword; }
17566   get left_brace() { return this.children.left_brace; }
17567   get values() { return this.children.values; }
17568   get right_brace() { return this.children.right_brace; }
17569   with_optional(optional){
17570     return new XHPEnumType(
17571       optional,
17572       this.keyword,
17573       this.left_brace,
17574       this.values,
17575       this.right_brace);
17576   }
17577   with_keyword(keyword){
17578     return new XHPEnumType(
17579       this.optional,
17580       keyword,
17581       this.left_brace,
17582       this.values,
17583       this.right_brace);
17584   }
17585   with_left_brace(left_brace){
17586     return new XHPEnumType(
17587       this.optional,
17588       this.keyword,
17589       left_brace,
17590       this.values,
17591       this.right_brace);
17592   }
17593   with_values(values){
17594     return new XHPEnumType(
17595       this.optional,
17596       this.keyword,
17597       this.left_brace,
17598       values,
17599       this.right_brace);
17600   }
17601   with_right_brace(right_brace){
17602     return new XHPEnumType(
17603       this.optional,
17604       this.keyword,
17605       this.left_brace,
17606       this.values,
17607       right_brace);
17608   }
17609   rewrite(rewriter, parents)
17610   {
17611     if (parents == undefined)
17612       parents = [];
17613     let new_parents = parents.slice();
17614     new_parents.push(this);
17615     var optional = this.optional.rewrite(rewriter, new_parents);
17616     var keyword = this.keyword.rewrite(rewriter, new_parents);
17617     var left_brace = this.left_brace.rewrite(rewriter, new_parents);
17618     var values = this.values.rewrite(rewriter, new_parents);
17619     var right_brace = this.right_brace.rewrite(rewriter, new_parents);
17620     if (
17621       optional === this.optional &&
17622       keyword === this.keyword &&
17623       left_brace === this.left_brace &&
17624       values === this.values &&
17625       right_brace === this.right_brace)
17626     {
17627       return rewriter(this, parents);
17628     }
17629     else
17630     {
17631       return rewriter(new XHPEnumType(
17632         optional,
17633         keyword,
17634         left_brace,
17635         values,
17636         right_brace), parents);
17637     }
17638   }
17639   static from_json(json, position, source)
17640   {
17641     let optional = EditableSyntax.from_json(
17642       json.xhp_enum_optional, position, source);
17643     position += optional.width;
17644     let keyword = EditableSyntax.from_json(
17645       json.xhp_enum_keyword, position, source);
17646     position += keyword.width;
17647     let left_brace = EditableSyntax.from_json(
17648       json.xhp_enum_left_brace, position, source);
17649     position += left_brace.width;
17650     let values = EditableSyntax.from_json(
17651       json.xhp_enum_values, position, source);
17652     position += values.width;
17653     let right_brace = EditableSyntax.from_json(
17654       json.xhp_enum_right_brace, position, source);
17655     position += right_brace.width;
17656     return new XHPEnumType(
17657         optional,
17658         keyword,
17659         left_brace,
17660         values,
17661         right_brace);
17662   }
17663   get children_keys()
17664   {
17665     if (XHPEnumType._children_keys == null)
17666       XHPEnumType._children_keys = [
17667         'optional',
17668         'keyword',
17669         'left_brace',
17670         'values',
17671         'right_brace'];
17672     return XHPEnumType._children_keys;
17673   }
17674 }
17675 class XHPRequired extends EditableSyntax
17676 {
17677   constructor(
17678     at,
17679     keyword)
17680   {
17681     super('xhp_required', {
17682       at: at,
17683       keyword: keyword });
17684   }
17685   get at() { return this.children.at; }
17686   get keyword() { return this.children.keyword; }
17687   with_at(at){
17688     return new XHPRequired(
17689       at,
17690       this.keyword);
17691   }
17692   with_keyword(keyword){
17693     return new XHPRequired(
17694       this.at,
17695       keyword);
17696   }
17697   rewrite(rewriter, parents)
17698   {
17699     if (parents == undefined)
17700       parents = [];
17701     let new_parents = parents.slice();
17702     new_parents.push(this);
17703     var at = this.at.rewrite(rewriter, new_parents);
17704     var keyword = this.keyword.rewrite(rewriter, new_parents);
17705     if (
17706       at === this.at &&
17707       keyword === this.keyword)
17708     {
17709       return rewriter(this, parents);
17710     }
17711     else
17712     {
17713       return rewriter(new XHPRequired(
17714         at,
17715         keyword), parents);
17716     }
17717   }
17718   static from_json(json, position, source)
17719   {
17720     let at = EditableSyntax.from_json(
17721       json.xhp_required_at, position, source);
17722     position += at.width;
17723     let keyword = EditableSyntax.from_json(
17724       json.xhp_required_keyword, position, source);
17725     position += keyword.width;
17726     return new XHPRequired(
17727         at,
17728         keyword);
17729   }
17730   get children_keys()
17731   {
17732     if (XHPRequired._children_keys == null)
17733       XHPRequired._children_keys = [
17734         'at',
17735         'keyword'];
17736     return XHPRequired._children_keys;
17737   }
17738 }
17739 class XHPClassAttributeDeclaration extends EditableSyntax
17740 {
17741   constructor(
17742     keyword,
17743     attributes,
17744     semicolon)
17745   {
17746     super('xhp_class_attribute_declaration', {
17747       keyword: keyword,
17748       attributes: attributes,
17749       semicolon: semicolon });
17750   }
17751   get keyword() { return this.children.keyword; }
17752   get attributes() { return this.children.attributes; }
17753   get semicolon() { return this.children.semicolon; }
17754   with_keyword(keyword){
17755     return new XHPClassAttributeDeclaration(
17756       keyword,
17757       this.attributes,
17758       this.semicolon);
17759   }
17760   with_attributes(attributes){
17761     return new XHPClassAttributeDeclaration(
17762       this.keyword,
17763       attributes,
17764       this.semicolon);
17765   }
17766   with_semicolon(semicolon){
17767     return new XHPClassAttributeDeclaration(
17768       this.keyword,
17769       this.attributes,
17770       semicolon);
17771   }
17772   rewrite(rewriter, parents)
17773   {
17774     if (parents == undefined)
17775       parents = [];
17776     let new_parents = parents.slice();
17777     new_parents.push(this);
17778     var keyword = this.keyword.rewrite(rewriter, new_parents);
17779     var attributes = this.attributes.rewrite(rewriter, new_parents);
17780     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
17781     if (
17782       keyword === this.keyword &&
17783       attributes === this.attributes &&
17784       semicolon === this.semicolon)
17785     {
17786       return rewriter(this, parents);
17787     }
17788     else
17789     {
17790       return rewriter(new XHPClassAttributeDeclaration(
17791         keyword,
17792         attributes,
17793         semicolon), parents);
17794     }
17795   }
17796   static from_json(json, position, source)
17797   {
17798     let keyword = EditableSyntax.from_json(
17799       json.xhp_attribute_keyword, position, source);
17800     position += keyword.width;
17801     let attributes = EditableSyntax.from_json(
17802       json.xhp_attribute_attributes, position, source);
17803     position += attributes.width;
17804     let semicolon = EditableSyntax.from_json(
17805       json.xhp_attribute_semicolon, position, source);
17806     position += semicolon.width;
17807     return new XHPClassAttributeDeclaration(
17808         keyword,
17809         attributes,
17810         semicolon);
17811   }
17812   get children_keys()
17813   {
17814     if (XHPClassAttributeDeclaration._children_keys == null)
17815       XHPClassAttributeDeclaration._children_keys = [
17816         'keyword',
17817         'attributes',
17818         'semicolon'];
17819     return XHPClassAttributeDeclaration._children_keys;
17820   }
17821 }
17822 class XHPClassAttribute extends EditableSyntax
17823 {
17824   constructor(
17825     type,
17826     name,
17827     initializer,
17828     required)
17829   {
17830     super('xhp_class_attribute', {
17831       type: type,
17832       name: name,
17833       initializer: initializer,
17834       required: required });
17835   }
17836   get type() { return this.children.type; }
17837   get name() { return this.children.name; }
17838   get initializer() { return this.children.initializer; }
17839   get required() { return this.children.required; }
17840   with_type(type){
17841     return new XHPClassAttribute(
17842       type,
17843       this.name,
17844       this.initializer,
17845       this.required);
17846   }
17847   with_name(name){
17848     return new XHPClassAttribute(
17849       this.type,
17850       name,
17851       this.initializer,
17852       this.required);
17853   }
17854   with_initializer(initializer){
17855     return new XHPClassAttribute(
17856       this.type,
17857       this.name,
17858       initializer,
17859       this.required);
17860   }
17861   with_required(required){
17862     return new XHPClassAttribute(
17863       this.type,
17864       this.name,
17865       this.initializer,
17866       required);
17867   }
17868   rewrite(rewriter, parents)
17869   {
17870     if (parents == undefined)
17871       parents = [];
17872     let new_parents = parents.slice();
17873     new_parents.push(this);
17874     var type = this.type.rewrite(rewriter, new_parents);
17875     var name = this.name.rewrite(rewriter, new_parents);
17876     var initializer = this.initializer.rewrite(rewriter, new_parents);
17877     var required = this.required.rewrite(rewriter, new_parents);
17878     if (
17879       type === this.type &&
17880       name === this.name &&
17881       initializer === this.initializer &&
17882       required === this.required)
17883     {
17884       return rewriter(this, parents);
17885     }
17886     else
17887     {
17888       return rewriter(new XHPClassAttribute(
17889         type,
17890         name,
17891         initializer,
17892         required), parents);
17893     }
17894   }
17895   static from_json(json, position, source)
17896   {
17897     let type = EditableSyntax.from_json(
17898       json.xhp_attribute_decl_type, position, source);
17899     position += type.width;
17900     let name = EditableSyntax.from_json(
17901       json.xhp_attribute_decl_name, position, source);
17902     position += name.width;
17903     let initializer = EditableSyntax.from_json(
17904       json.xhp_attribute_decl_initializer, position, source);
17905     position += initializer.width;
17906     let required = EditableSyntax.from_json(
17907       json.xhp_attribute_decl_required, position, source);
17908     position += required.width;
17909     return new XHPClassAttribute(
17910         type,
17911         name,
17912         initializer,
17913         required);
17914   }
17915   get children_keys()
17916   {
17917     if (XHPClassAttribute._children_keys == null)
17918       XHPClassAttribute._children_keys = [
17919         'type',
17920         'name',
17921         'initializer',
17922         'required'];
17923     return XHPClassAttribute._children_keys;
17924   }
17925 }
17926 class XHPSimpleClassAttribute extends EditableSyntax
17927 {
17928   constructor(
17929     type)
17930   {
17931     super('xhp_simple_class_attribute', {
17932       type: type });
17933   }
17934   get type() { return this.children.type; }
17935   with_type(type){
17936     return new XHPSimpleClassAttribute(
17937       type);
17938   }
17939   rewrite(rewriter, parents)
17940   {
17941     if (parents == undefined)
17942       parents = [];
17943     let new_parents = parents.slice();
17944     new_parents.push(this);
17945     var type = this.type.rewrite(rewriter, new_parents);
17946     if (
17947       type === this.type)
17948     {
17949       return rewriter(this, parents);
17950     }
17951     else
17952     {
17953       return rewriter(new XHPSimpleClassAttribute(
17954         type), parents);
17955     }
17956   }
17957   static from_json(json, position, source)
17958   {
17959     let type = EditableSyntax.from_json(
17960       json.xhp_simple_class_attribute_type, position, source);
17961     position += type.width;
17962     return new XHPSimpleClassAttribute(
17963         type);
17964   }
17965   get children_keys()
17966   {
17967     if (XHPSimpleClassAttribute._children_keys == null)
17968       XHPSimpleClassAttribute._children_keys = [
17969         'type'];
17970     return XHPSimpleClassAttribute._children_keys;
17971   }
17972 }
17973 class XHPSimpleAttribute extends EditableSyntax
17974 {
17975   constructor(
17976     name,
17977     equal,
17978     expression)
17979   {
17980     super('xhp_simple_attribute', {
17981       name: name,
17982       equal: equal,
17983       expression: expression });
17984   }
17985   get name() { return this.children.name; }
17986   get equal() { return this.children.equal; }
17987   get expression() { return this.children.expression; }
17988   with_name(name){
17989     return new XHPSimpleAttribute(
17990       name,
17991       this.equal,
17992       this.expression);
17993   }
17994   with_equal(equal){
17995     return new XHPSimpleAttribute(
17996       this.name,
17997       equal,
17998       this.expression);
17999   }
18000   with_expression(expression){
18001     return new XHPSimpleAttribute(
18002       this.name,
18003       this.equal,
18004       expression);
18005   }
18006   rewrite(rewriter, parents)
18007   {
18008     if (parents == undefined)
18009       parents = [];
18010     let new_parents = parents.slice();
18011     new_parents.push(this);
18012     var name = this.name.rewrite(rewriter, new_parents);
18013     var equal = this.equal.rewrite(rewriter, new_parents);
18014     var expression = this.expression.rewrite(rewriter, new_parents);
18015     if (
18016       name === this.name &&
18017       equal === this.equal &&
18018       expression === this.expression)
18019     {
18020       return rewriter(this, parents);
18021     }
18022     else
18023     {
18024       return rewriter(new XHPSimpleAttribute(
18025         name,
18026         equal,
18027         expression), parents);
18028     }
18029   }
18030   static from_json(json, position, source)
18031   {
18032     let name = EditableSyntax.from_json(
18033       json.xhp_simple_attribute_name, position, source);
18034     position += name.width;
18035     let equal = EditableSyntax.from_json(
18036       json.xhp_simple_attribute_equal, position, source);
18037     position += equal.width;
18038     let expression = EditableSyntax.from_json(
18039       json.xhp_simple_attribute_expression, position, source);
18040     position += expression.width;
18041     return new XHPSimpleAttribute(
18042         name,
18043         equal,
18044         expression);
18045   }
18046   get children_keys()
18047   {
18048     if (XHPSimpleAttribute._children_keys == null)
18049       XHPSimpleAttribute._children_keys = [
18050         'name',
18051         'equal',
18052         'expression'];
18053     return XHPSimpleAttribute._children_keys;
18054   }
18055 }
18056 class XHPSpreadAttribute extends EditableSyntax
18057 {
18058   constructor(
18059     left_brace,
18060     spread_operator,
18061     expression,
18062     right_brace)
18063   {
18064     super('xhp_spread_attribute', {
18065       left_brace: left_brace,
18066       spread_operator: spread_operator,
18067       expression: expression,
18068       right_brace: right_brace });
18069   }
18070   get left_brace() { return this.children.left_brace; }
18071   get spread_operator() { return this.children.spread_operator; }
18072   get expression() { return this.children.expression; }
18073   get right_brace() { return this.children.right_brace; }
18074   with_left_brace(left_brace){
18075     return new XHPSpreadAttribute(
18076       left_brace,
18077       this.spread_operator,
18078       this.expression,
18079       this.right_brace);
18080   }
18081   with_spread_operator(spread_operator){
18082     return new XHPSpreadAttribute(
18083       this.left_brace,
18084       spread_operator,
18085       this.expression,
18086       this.right_brace);
18087   }
18088   with_expression(expression){
18089     return new XHPSpreadAttribute(
18090       this.left_brace,
18091       this.spread_operator,
18092       expression,
18093       this.right_brace);
18094   }
18095   with_right_brace(right_brace){
18096     return new XHPSpreadAttribute(
18097       this.left_brace,
18098       this.spread_operator,
18099       this.expression,
18100       right_brace);
18101   }
18102   rewrite(rewriter, parents)
18103   {
18104     if (parents == undefined)
18105       parents = [];
18106     let new_parents = parents.slice();
18107     new_parents.push(this);
18108     var left_brace = this.left_brace.rewrite(rewriter, new_parents);
18109     var spread_operator = this.spread_operator.rewrite(rewriter, new_parents);
18110     var expression = this.expression.rewrite(rewriter, new_parents);
18111     var right_brace = this.right_brace.rewrite(rewriter, new_parents);
18112     if (
18113       left_brace === this.left_brace &&
18114       spread_operator === this.spread_operator &&
18115       expression === this.expression &&
18116       right_brace === this.right_brace)
18117     {
18118       return rewriter(this, parents);
18119     }
18120     else
18121     {
18122       return rewriter(new XHPSpreadAttribute(
18123         left_brace,
18124         spread_operator,
18125         expression,
18126         right_brace), parents);
18127     }
18128   }
18129   static from_json(json, position, source)
18130   {
18131     let left_brace = EditableSyntax.from_json(
18132       json.xhp_spread_attribute_left_brace, position, source);
18133     position += left_brace.width;
18134     let spread_operator = EditableSyntax.from_json(
18135       json.xhp_spread_attribute_spread_operator, position, source);
18136     position += spread_operator.width;
18137     let expression = EditableSyntax.from_json(
18138       json.xhp_spread_attribute_expression, position, source);
18139     position += expression.width;
18140     let right_brace = EditableSyntax.from_json(
18141       json.xhp_spread_attribute_right_brace, position, source);
18142     position += right_brace.width;
18143     return new XHPSpreadAttribute(
18144         left_brace,
18145         spread_operator,
18146         expression,
18147         right_brace);
18148   }
18149   get children_keys()
18150   {
18151     if (XHPSpreadAttribute._children_keys == null)
18152       XHPSpreadAttribute._children_keys = [
18153         'left_brace',
18154         'spread_operator',
18155         'expression',
18156         'right_brace'];
18157     return XHPSpreadAttribute._children_keys;
18158   }
18159 }
18160 class XHPOpen extends EditableSyntax
18161 {
18162   constructor(
18163     left_angle,
18164     name,
18165     attributes,
18166     right_angle)
18167   {
18168     super('xhp_open', {
18169       left_angle: left_angle,
18170       name: name,
18171       attributes: attributes,
18172       right_angle: right_angle });
18173   }
18174   get left_angle() { return this.children.left_angle; }
18175   get name() { return this.children.name; }
18176   get attributes() { return this.children.attributes; }
18177   get right_angle() { return this.children.right_angle; }
18178   with_left_angle(left_angle){
18179     return new XHPOpen(
18180       left_angle,
18181       this.name,
18182       this.attributes,
18183       this.right_angle);
18184   }
18185   with_name(name){
18186     return new XHPOpen(
18187       this.left_angle,
18188       name,
18189       this.attributes,
18190       this.right_angle);
18191   }
18192   with_attributes(attributes){
18193     return new XHPOpen(
18194       this.left_angle,
18195       this.name,
18196       attributes,
18197       this.right_angle);
18198   }
18199   with_right_angle(right_angle){
18200     return new XHPOpen(
18201       this.left_angle,
18202       this.name,
18203       this.attributes,
18204       right_angle);
18205   }
18206   rewrite(rewriter, parents)
18207   {
18208     if (parents == undefined)
18209       parents = [];
18210     let new_parents = parents.slice();
18211     new_parents.push(this);
18212     var left_angle = this.left_angle.rewrite(rewriter, new_parents);
18213     var name = this.name.rewrite(rewriter, new_parents);
18214     var attributes = this.attributes.rewrite(rewriter, new_parents);
18215     var right_angle = this.right_angle.rewrite(rewriter, new_parents);
18216     if (
18217       left_angle === this.left_angle &&
18218       name === this.name &&
18219       attributes === this.attributes &&
18220       right_angle === this.right_angle)
18221     {
18222       return rewriter(this, parents);
18223     }
18224     else
18225     {
18226       return rewriter(new XHPOpen(
18227         left_angle,
18228         name,
18229         attributes,
18230         right_angle), parents);
18231     }
18232   }
18233   static from_json(json, position, source)
18234   {
18235     let left_angle = EditableSyntax.from_json(
18236       json.xhp_open_left_angle, position, source);
18237     position += left_angle.width;
18238     let name = EditableSyntax.from_json(
18239       json.xhp_open_name, position, source);
18240     position += name.width;
18241     let attributes = EditableSyntax.from_json(
18242       json.xhp_open_attributes, position, source);
18243     position += attributes.width;
18244     let right_angle = EditableSyntax.from_json(
18245       json.xhp_open_right_angle, position, source);
18246     position += right_angle.width;
18247     return new XHPOpen(
18248         left_angle,
18249         name,
18250         attributes,
18251         right_angle);
18252   }
18253   get children_keys()
18254   {
18255     if (XHPOpen._children_keys == null)
18256       XHPOpen._children_keys = [
18257         'left_angle',
18258         'name',
18259         'attributes',
18260         'right_angle'];
18261     return XHPOpen._children_keys;
18262   }
18263 }
18264 class XHPExpression extends EditableSyntax
18265 {
18266   constructor(
18267     open,
18268     body,
18269     close)
18270   {
18271     super('xhp_expression', {
18272       open: open,
18273       body: body,
18274       close: close });
18275   }
18276   get open() { return this.children.open; }
18277   get body() { return this.children.body; }
18278   get close() { return this.children.close; }
18279   with_open(open){
18280     return new XHPExpression(
18281       open,
18282       this.body,
18283       this.close);
18284   }
18285   with_body(body){
18286     return new XHPExpression(
18287       this.open,
18288       body,
18289       this.close);
18290   }
18291   with_close(close){
18292     return new XHPExpression(
18293       this.open,
18294       this.body,
18295       close);
18296   }
18297   rewrite(rewriter, parents)
18298   {
18299     if (parents == undefined)
18300       parents = [];
18301     let new_parents = parents.slice();
18302     new_parents.push(this);
18303     var open = this.open.rewrite(rewriter, new_parents);
18304     var body = this.body.rewrite(rewriter, new_parents);
18305     var close = this.close.rewrite(rewriter, new_parents);
18306     if (
18307       open === this.open &&
18308       body === this.body &&
18309       close === this.close)
18310     {
18311       return rewriter(this, parents);
18312     }
18313     else
18314     {
18315       return rewriter(new XHPExpression(
18316         open,
18317         body,
18318         close), parents);
18319     }
18320   }
18321   static from_json(json, position, source)
18322   {
18323     let open = EditableSyntax.from_json(
18324       json.xhp_open, position, source);
18325     position += open.width;
18326     let body = EditableSyntax.from_json(
18327       json.xhp_body, position, source);
18328     position += body.width;
18329     let close = EditableSyntax.from_json(
18330       json.xhp_close, position, source);
18331     position += close.width;
18332     return new XHPExpression(
18333         open,
18334         body,
18335         close);
18336   }
18337   get children_keys()
18338   {
18339     if (XHPExpression._children_keys == null)
18340       XHPExpression._children_keys = [
18341         'open',
18342         'body',
18343         'close'];
18344     return XHPExpression._children_keys;
18345   }
18346 }
18347 class XHPClose extends EditableSyntax
18348 {
18349   constructor(
18350     left_angle,
18351     name,
18352     right_angle)
18353   {
18354     super('xhp_close', {
18355       left_angle: left_angle,
18356       name: name,
18357       right_angle: right_angle });
18358   }
18359   get left_angle() { return this.children.left_angle; }
18360   get name() { return this.children.name; }
18361   get right_angle() { return this.children.right_angle; }
18362   with_left_angle(left_angle){
18363     return new XHPClose(
18364       left_angle,
18365       this.name,
18366       this.right_angle);
18367   }
18368   with_name(name){
18369     return new XHPClose(
18370       this.left_angle,
18371       name,
18372       this.right_angle);
18373   }
18374   with_right_angle(right_angle){
18375     return new XHPClose(
18376       this.left_angle,
18377       this.name,
18378       right_angle);
18379   }
18380   rewrite(rewriter, parents)
18381   {
18382     if (parents == undefined)
18383       parents = [];
18384     let new_parents = parents.slice();
18385     new_parents.push(this);
18386     var left_angle = this.left_angle.rewrite(rewriter, new_parents);
18387     var name = this.name.rewrite(rewriter, new_parents);
18388     var right_angle = this.right_angle.rewrite(rewriter, new_parents);
18389     if (
18390       left_angle === this.left_angle &&
18391       name === this.name &&
18392       right_angle === this.right_angle)
18393     {
18394       return rewriter(this, parents);
18395     }
18396     else
18397     {
18398       return rewriter(new XHPClose(
18399         left_angle,
18400         name,
18401         right_angle), parents);
18402     }
18403   }
18404   static from_json(json, position, source)
18405   {
18406     let left_angle = EditableSyntax.from_json(
18407       json.xhp_close_left_angle, position, source);
18408     position += left_angle.width;
18409     let name = EditableSyntax.from_json(
18410       json.xhp_close_name, position, source);
18411     position += name.width;
18412     let right_angle = EditableSyntax.from_json(
18413       json.xhp_close_right_angle, position, source);
18414     position += right_angle.width;
18415     return new XHPClose(
18416         left_angle,
18417         name,
18418         right_angle);
18419   }
18420   get children_keys()
18421   {
18422     if (XHPClose._children_keys == null)
18423       XHPClose._children_keys = [
18424         'left_angle',
18425         'name',
18426         'right_angle'];
18427     return XHPClose._children_keys;
18428   }
18429 }
18430 class TypeConstant extends EditableSyntax
18431 {
18432   constructor(
18433     left_type,
18434     separator,
18435     right_type)
18436   {
18437     super('type_constant', {
18438       left_type: left_type,
18439       separator: separator,
18440       right_type: right_type });
18441   }
18442   get left_type() { return this.children.left_type; }
18443   get separator() { return this.children.separator; }
18444   get right_type() { return this.children.right_type; }
18445   with_left_type(left_type){
18446     return new TypeConstant(
18447       left_type,
18448       this.separator,
18449       this.right_type);
18450   }
18451   with_separator(separator){
18452     return new TypeConstant(
18453       this.left_type,
18454       separator,
18455       this.right_type);
18456   }
18457   with_right_type(right_type){
18458     return new TypeConstant(
18459       this.left_type,
18460       this.separator,
18461       right_type);
18462   }
18463   rewrite(rewriter, parents)
18464   {
18465     if (parents == undefined)
18466       parents = [];
18467     let new_parents = parents.slice();
18468     new_parents.push(this);
18469     var left_type = this.left_type.rewrite(rewriter, new_parents);
18470     var separator = this.separator.rewrite(rewriter, new_parents);
18471     var right_type = this.right_type.rewrite(rewriter, new_parents);
18472     if (
18473       left_type === this.left_type &&
18474       separator === this.separator &&
18475       right_type === this.right_type)
18476     {
18477       return rewriter(this, parents);
18478     }
18479     else
18480     {
18481       return rewriter(new TypeConstant(
18482         left_type,
18483         separator,
18484         right_type), parents);
18485     }
18486   }
18487   static from_json(json, position, source)
18488   {
18489     let left_type = EditableSyntax.from_json(
18490       json.type_constant_left_type, position, source);
18491     position += left_type.width;
18492     let separator = EditableSyntax.from_json(
18493       json.type_constant_separator, position, source);
18494     position += separator.width;
18495     let right_type = EditableSyntax.from_json(
18496       json.type_constant_right_type, position, source);
18497     position += right_type.width;
18498     return new TypeConstant(
18499         left_type,
18500         separator,
18501         right_type);
18502   }
18503   get children_keys()
18504   {
18505     if (TypeConstant._children_keys == null)
18506       TypeConstant._children_keys = [
18507         'left_type',
18508         'separator',
18509         'right_type'];
18510     return TypeConstant._children_keys;
18511   }
18512 }
18513 class VectorTypeSpecifier extends EditableSyntax
18514 {
18515   constructor(
18516     keyword,
18517     left_angle,
18518     type,
18519     trailing_comma,
18520     right_angle)
18521   {
18522     super('vector_type_specifier', {
18523       keyword: keyword,
18524       left_angle: left_angle,
18525       type: type,
18526       trailing_comma: trailing_comma,
18527       right_angle: right_angle });
18528   }
18529   get keyword() { return this.children.keyword; }
18530   get left_angle() { return this.children.left_angle; }
18531   get type() { return this.children.type; }
18532   get trailing_comma() { return this.children.trailing_comma; }
18533   get right_angle() { return this.children.right_angle; }
18534   with_keyword(keyword){
18535     return new VectorTypeSpecifier(
18536       keyword,
18537       this.left_angle,
18538       this.type,
18539       this.trailing_comma,
18540       this.right_angle);
18541   }
18542   with_left_angle(left_angle){
18543     return new VectorTypeSpecifier(
18544       this.keyword,
18545       left_angle,
18546       this.type,
18547       this.trailing_comma,
18548       this.right_angle);
18549   }
18550   with_type(type){
18551     return new VectorTypeSpecifier(
18552       this.keyword,
18553       this.left_angle,
18554       type,
18555       this.trailing_comma,
18556       this.right_angle);
18557   }
18558   with_trailing_comma(trailing_comma){
18559     return new VectorTypeSpecifier(
18560       this.keyword,
18561       this.left_angle,
18562       this.type,
18563       trailing_comma,
18564       this.right_angle);
18565   }
18566   with_right_angle(right_angle){
18567     return new VectorTypeSpecifier(
18568       this.keyword,
18569       this.left_angle,
18570       this.type,
18571       this.trailing_comma,
18572       right_angle);
18573   }
18574   rewrite(rewriter, parents)
18575   {
18576     if (parents == undefined)
18577       parents = [];
18578     let new_parents = parents.slice();
18579     new_parents.push(this);
18580     var keyword = this.keyword.rewrite(rewriter, new_parents);
18581     var left_angle = this.left_angle.rewrite(rewriter, new_parents);
18582     var type = this.type.rewrite(rewriter, new_parents);
18583     var trailing_comma = this.trailing_comma.rewrite(rewriter, new_parents);
18584     var right_angle = this.right_angle.rewrite(rewriter, new_parents);
18585     if (
18586       keyword === this.keyword &&
18587       left_angle === this.left_angle &&
18588       type === this.type &&
18589       trailing_comma === this.trailing_comma &&
18590       right_angle === this.right_angle)
18591     {
18592       return rewriter(this, parents);
18593     }
18594     else
18595     {
18596       return rewriter(new VectorTypeSpecifier(
18597         keyword,
18598         left_angle,
18599         type,
18600         trailing_comma,
18601         right_angle), parents);
18602     }
18603   }
18604   static from_json(json, position, source)
18605   {
18606     let keyword = EditableSyntax.from_json(
18607       json.vector_type_keyword, position, source);
18608     position += keyword.width;
18609     let left_angle = EditableSyntax.from_json(
18610       json.vector_type_left_angle, position, source);
18611     position += left_angle.width;
18612     let type = EditableSyntax.from_json(
18613       json.vector_type_type, position, source);
18614     position += type.width;
18615     let trailing_comma = EditableSyntax.from_json(
18616       json.vector_type_trailing_comma, position, source);
18617     position += trailing_comma.width;
18618     let right_angle = EditableSyntax.from_json(
18619       json.vector_type_right_angle, position, source);
18620     position += right_angle.width;
18621     return new VectorTypeSpecifier(
18622         keyword,
18623         left_angle,
18624         type,
18625         trailing_comma,
18626         right_angle);
18627   }
18628   get children_keys()
18629   {
18630     if (VectorTypeSpecifier._children_keys == null)
18631       VectorTypeSpecifier._children_keys = [
18632         'keyword',
18633         'left_angle',
18634         'type',
18635         'trailing_comma',
18636         'right_angle'];
18637     return VectorTypeSpecifier._children_keys;
18638   }
18639 }
18640 class KeysetTypeSpecifier extends EditableSyntax
18641 {
18642   constructor(
18643     keyword,
18644     left_angle,
18645     type,
18646     trailing_comma,
18647     right_angle)
18648   {
18649     super('keyset_type_specifier', {
18650       keyword: keyword,
18651       left_angle: left_angle,
18652       type: type,
18653       trailing_comma: trailing_comma,
18654       right_angle: right_angle });
18655   }
18656   get keyword() { return this.children.keyword; }
18657   get left_angle() { return this.children.left_angle; }
18658   get type() { return this.children.type; }
18659   get trailing_comma() { return this.children.trailing_comma; }
18660   get right_angle() { return this.children.right_angle; }
18661   with_keyword(keyword){
18662     return new KeysetTypeSpecifier(
18663       keyword,
18664       this.left_angle,
18665       this.type,
18666       this.trailing_comma,
18667       this.right_angle);
18668   }
18669   with_left_angle(left_angle){
18670     return new KeysetTypeSpecifier(
18671       this.keyword,
18672       left_angle,
18673       this.type,
18674       this.trailing_comma,
18675       this.right_angle);
18676   }
18677   with_type(type){
18678     return new KeysetTypeSpecifier(
18679       this.keyword,
18680       this.left_angle,
18681       type,
18682       this.trailing_comma,
18683       this.right_angle);
18684   }
18685   with_trailing_comma(trailing_comma){
18686     return new KeysetTypeSpecifier(
18687       this.keyword,
18688       this.left_angle,
18689       this.type,
18690       trailing_comma,
18691       this.right_angle);
18692   }
18693   with_right_angle(right_angle){
18694     return new KeysetTypeSpecifier(
18695       this.keyword,
18696       this.left_angle,
18697       this.type,
18698       this.trailing_comma,
18699       right_angle);
18700   }
18701   rewrite(rewriter, parents)
18702   {
18703     if (parents == undefined)
18704       parents = [];
18705     let new_parents = parents.slice();
18706     new_parents.push(this);
18707     var keyword = this.keyword.rewrite(rewriter, new_parents);
18708     var left_angle = this.left_angle.rewrite(rewriter, new_parents);
18709     var type = this.type.rewrite(rewriter, new_parents);
18710     var trailing_comma = this.trailing_comma.rewrite(rewriter, new_parents);
18711     var right_angle = this.right_angle.rewrite(rewriter, new_parents);
18712     if (
18713       keyword === this.keyword &&
18714       left_angle === this.left_angle &&
18715       type === this.type &&
18716       trailing_comma === this.trailing_comma &&
18717       right_angle === this.right_angle)
18718     {
18719       return rewriter(this, parents);
18720     }
18721     else
18722     {
18723       return rewriter(new KeysetTypeSpecifier(
18724         keyword,
18725         left_angle,
18726         type,
18727         trailing_comma,
18728         right_angle), parents);
18729     }
18730   }
18731   static from_json(json, position, source)
18732   {
18733     let keyword = EditableSyntax.from_json(
18734       json.keyset_type_keyword, position, source);
18735     position += keyword.width;
18736     let left_angle = EditableSyntax.from_json(
18737       json.keyset_type_left_angle, position, source);
18738     position += left_angle.width;
18739     let type = EditableSyntax.from_json(
18740       json.keyset_type_type, position, source);
18741     position += type.width;
18742     let trailing_comma = EditableSyntax.from_json(
18743       json.keyset_type_trailing_comma, position, source);
18744     position += trailing_comma.width;
18745     let right_angle = EditableSyntax.from_json(
18746       json.keyset_type_right_angle, position, source);
18747     position += right_angle.width;
18748     return new KeysetTypeSpecifier(
18749         keyword,
18750         left_angle,
18751         type,
18752         trailing_comma,
18753         right_angle);
18754   }
18755   get children_keys()
18756   {
18757     if (KeysetTypeSpecifier._children_keys == null)
18758       KeysetTypeSpecifier._children_keys = [
18759         'keyword',
18760         'left_angle',
18761         'type',
18762         'trailing_comma',
18763         'right_angle'];
18764     return KeysetTypeSpecifier._children_keys;
18765   }
18766 }
18767 class TupleTypeExplicitSpecifier extends EditableSyntax
18768 {
18769   constructor(
18770     keyword,
18771     left_angle,
18772     types,
18773     right_angle)
18774   {
18775     super('tuple_type_explicit_specifier', {
18776       keyword: keyword,
18777       left_angle: left_angle,
18778       types: types,
18779       right_angle: right_angle });
18780   }
18781   get keyword() { return this.children.keyword; }
18782   get left_angle() { return this.children.left_angle; }
18783   get types() { return this.children.types; }
18784   get right_angle() { return this.children.right_angle; }
18785   with_keyword(keyword){
18786     return new TupleTypeExplicitSpecifier(
18787       keyword,
18788       this.left_angle,
18789       this.types,
18790       this.right_angle);
18791   }
18792   with_left_angle(left_angle){
18793     return new TupleTypeExplicitSpecifier(
18794       this.keyword,
18795       left_angle,
18796       this.types,
18797       this.right_angle);
18798   }
18799   with_types(types){
18800     return new TupleTypeExplicitSpecifier(
18801       this.keyword,
18802       this.left_angle,
18803       types,
18804       this.right_angle);
18805   }
18806   with_right_angle(right_angle){
18807     return new TupleTypeExplicitSpecifier(
18808       this.keyword,
18809       this.left_angle,
18810       this.types,
18811       right_angle);
18812   }
18813   rewrite(rewriter, parents)
18814   {
18815     if (parents == undefined)
18816       parents = [];
18817     let new_parents = parents.slice();
18818     new_parents.push(this);
18819     var keyword = this.keyword.rewrite(rewriter, new_parents);
18820     var left_angle = this.left_angle.rewrite(rewriter, new_parents);
18821     var types = this.types.rewrite(rewriter, new_parents);
18822     var right_angle = this.right_angle.rewrite(rewriter, new_parents);
18823     if (
18824       keyword === this.keyword &&
18825       left_angle === this.left_angle &&
18826       types === this.types &&
18827       right_angle === this.right_angle)
18828     {
18829       return rewriter(this, parents);
18830     }
18831     else
18832     {
18833       return rewriter(new TupleTypeExplicitSpecifier(
18834         keyword,
18835         left_angle,
18836         types,
18837         right_angle), parents);
18838     }
18839   }
18840   static from_json(json, position, source)
18841   {
18842     let keyword = EditableSyntax.from_json(
18843       json.tuple_type_keyword, position, source);
18844     position += keyword.width;
18845     let left_angle = EditableSyntax.from_json(
18846       json.tuple_type_left_angle, position, source);
18847     position += left_angle.width;
18848     let types = EditableSyntax.from_json(
18849       json.tuple_type_types, position, source);
18850     position += types.width;
18851     let right_angle = EditableSyntax.from_json(
18852       json.tuple_type_right_angle, position, source);
18853     position += right_angle.width;
18854     return new TupleTypeExplicitSpecifier(
18855         keyword,
18856         left_angle,
18857         types,
18858         right_angle);
18859   }
18860   get children_keys()
18861   {
18862     if (TupleTypeExplicitSpecifier._children_keys == null)
18863       TupleTypeExplicitSpecifier._children_keys = [
18864         'keyword',
18865         'left_angle',
18866         'types',
18867         'right_angle'];
18868     return TupleTypeExplicitSpecifier._children_keys;
18869   }
18870 }
18871 class VarrayTypeSpecifier extends EditableSyntax
18872 {
18873   constructor(
18874     keyword,
18875     left_angle,
18876     type,
18877     trailing_comma,
18878     right_angle)
18879   {
18880     super('varray_type_specifier', {
18881       keyword: keyword,
18882       left_angle: left_angle,
18883       type: type,
18884       trailing_comma: trailing_comma,
18885       right_angle: right_angle });
18886   }
18887   get keyword() { return this.children.keyword; }
18888   get left_angle() { return this.children.left_angle; }
18889   get type() { return this.children.type; }
18890   get trailing_comma() { return this.children.trailing_comma; }
18891   get right_angle() { return this.children.right_angle; }
18892   with_keyword(keyword){
18893     return new VarrayTypeSpecifier(
18894       keyword,
18895       this.left_angle,
18896       this.type,
18897       this.trailing_comma,
18898       this.right_angle);
18899   }
18900   with_left_angle(left_angle){
18901     return new VarrayTypeSpecifier(
18902       this.keyword,
18903       left_angle,
18904       this.type,
18905       this.trailing_comma,
18906       this.right_angle);
18907   }
18908   with_type(type){
18909     return new VarrayTypeSpecifier(
18910       this.keyword,
18911       this.left_angle,
18912       type,
18913       this.trailing_comma,
18914       this.right_angle);
18915   }
18916   with_trailing_comma(trailing_comma){
18917     return new VarrayTypeSpecifier(
18918       this.keyword,
18919       this.left_angle,
18920       this.type,
18921       trailing_comma,
18922       this.right_angle);
18923   }
18924   with_right_angle(right_angle){
18925     return new VarrayTypeSpecifier(
18926       this.keyword,
18927       this.left_angle,
18928       this.type,
18929       this.trailing_comma,
18930       right_angle);
18931   }
18932   rewrite(rewriter, parents)
18933   {
18934     if (parents == undefined)
18935       parents = [];
18936     let new_parents = parents.slice();
18937     new_parents.push(this);
18938     var keyword = this.keyword.rewrite(rewriter, new_parents);
18939     var left_angle = this.left_angle.rewrite(rewriter, new_parents);
18940     var type = this.type.rewrite(rewriter, new_parents);
18941     var trailing_comma = this.trailing_comma.rewrite(rewriter, new_parents);
18942     var right_angle = this.right_angle.rewrite(rewriter, new_parents);
18943     if (
18944       keyword === this.keyword &&
18945       left_angle === this.left_angle &&
18946       type === this.type &&
18947       trailing_comma === this.trailing_comma &&
18948       right_angle === this.right_angle)
18949     {
18950       return rewriter(this, parents);
18951     }
18952     else
18953     {
18954       return rewriter(new VarrayTypeSpecifier(
18955         keyword,
18956         left_angle,
18957         type,
18958         trailing_comma,
18959         right_angle), parents);
18960     }
18961   }
18962   static from_json(json, position, source)
18963   {
18964     let keyword = EditableSyntax.from_json(
18965       json.varray_keyword, position, source);
18966     position += keyword.width;
18967     let left_angle = EditableSyntax.from_json(
18968       json.varray_left_angle, position, source);
18969     position += left_angle.width;
18970     let type = EditableSyntax.from_json(
18971       json.varray_type, position, source);
18972     position += type.width;
18973     let trailing_comma = EditableSyntax.from_json(
18974       json.varray_trailing_comma, position, source);
18975     position += trailing_comma.width;
18976     let right_angle = EditableSyntax.from_json(
18977       json.varray_right_angle, position, source);
18978     position += right_angle.width;
18979     return new VarrayTypeSpecifier(
18980         keyword,
18981         left_angle,
18982         type,
18983         trailing_comma,
18984         right_angle);
18985   }
18986   get children_keys()
18987   {
18988     if (VarrayTypeSpecifier._children_keys == null)
18989       VarrayTypeSpecifier._children_keys = [
18990         'keyword',
18991         'left_angle',
18992         'type',
18993         'trailing_comma',
18994         'right_angle'];
18995     return VarrayTypeSpecifier._children_keys;
18996   }
18997 }
18998 class VectorArrayTypeSpecifier extends EditableSyntax
18999 {
19000   constructor(
19001     keyword,
19002     left_angle,
19003     type,
19004     right_angle)
19005   {
19006     super('vector_array_type_specifier', {
19007       keyword: keyword,
19008       left_angle: left_angle,
19009       type: type,
19010       right_angle: right_angle });
19011   }
19012   get keyword() { return this.children.keyword; }
19013   get left_angle() { return this.children.left_angle; }
19014   get type() { return this.children.type; }
19015   get right_angle() { return this.children.right_angle; }
19016   with_keyword(keyword){
19017     return new VectorArrayTypeSpecifier(
19018       keyword,
19019       this.left_angle,
19020       this.type,
19021       this.right_angle);
19022   }
19023   with_left_angle(left_angle){
19024     return new VectorArrayTypeSpecifier(
19025       this.keyword,
19026       left_angle,
19027       this.type,
19028       this.right_angle);
19029   }
19030   with_type(type){
19031     return new VectorArrayTypeSpecifier(
19032       this.keyword,
19033       this.left_angle,
19034       type,
19035       this.right_angle);
19036   }
19037   with_right_angle(right_angle){
19038     return new VectorArrayTypeSpecifier(
19039       this.keyword,
19040       this.left_angle,
19041       this.type,
19042       right_angle);
19043   }
19044   rewrite(rewriter, parents)
19045   {
19046     if (parents == undefined)
19047       parents = [];
19048     let new_parents = parents.slice();
19049     new_parents.push(this);
19050     var keyword = this.keyword.rewrite(rewriter, new_parents);
19051     var left_angle = this.left_angle.rewrite(rewriter, new_parents);
19052     var type = this.type.rewrite(rewriter, new_parents);
19053     var right_angle = this.right_angle.rewrite(rewriter, new_parents);
19054     if (
19055       keyword === this.keyword &&
19056       left_angle === this.left_angle &&
19057       type === this.type &&
19058       right_angle === this.right_angle)
19059     {
19060       return rewriter(this, parents);
19061     }
19062     else
19063     {
19064       return rewriter(new VectorArrayTypeSpecifier(
19065         keyword,
19066         left_angle,
19067         type,
19068         right_angle), parents);
19069     }
19070   }
19071   static from_json(json, position, source)
19072   {
19073     let keyword = EditableSyntax.from_json(
19074       json.vector_array_keyword, position, source);
19075     position += keyword.width;
19076     let left_angle = EditableSyntax.from_json(
19077       json.vector_array_left_angle, position, source);
19078     position += left_angle.width;
19079     let type = EditableSyntax.from_json(
19080       json.vector_array_type, position, source);
19081     position += type.width;
19082     let right_angle = EditableSyntax.from_json(
19083       json.vector_array_right_angle, position, source);
19084     position += right_angle.width;
19085     return new VectorArrayTypeSpecifier(
19086         keyword,
19087         left_angle,
19088         type,
19089         right_angle);
19090   }
19091   get children_keys()
19092   {
19093     if (VectorArrayTypeSpecifier._children_keys == null)
19094       VectorArrayTypeSpecifier._children_keys = [
19095         'keyword',
19096         'left_angle',
19097         'type',
19098         'right_angle'];
19099     return VectorArrayTypeSpecifier._children_keys;
19100   }
19101 }
19102 class TypeParameter extends EditableSyntax
19103 {
19104   constructor(
19105     attribute_spec,
19106     reified,
19107     variance,
19108     name,
19109     constraints)
19110   {
19111     super('type_parameter', {
19112       attribute_spec: attribute_spec,
19113       reified: reified,
19114       variance: variance,
19115       name: name,
19116       constraints: constraints });
19117   }
19118   get attribute_spec() { return this.children.attribute_spec; }
19119   get reified() { return this.children.reified; }
19120   get variance() { return this.children.variance; }
19121   get name() { return this.children.name; }
19122   get constraints() { return this.children.constraints; }
19123   with_attribute_spec(attribute_spec){
19124     return new TypeParameter(
19125       attribute_spec,
19126       this.reified,
19127       this.variance,
19128       this.name,
19129       this.constraints);
19130   }
19131   with_reified(reified){
19132     return new TypeParameter(
19133       this.attribute_spec,
19134       reified,
19135       this.variance,
19136       this.name,
19137       this.constraints);
19138   }
19139   with_variance(variance){
19140     return new TypeParameter(
19141       this.attribute_spec,
19142       this.reified,
19143       variance,
19144       this.name,
19145       this.constraints);
19146   }
19147   with_name(name){
19148     return new TypeParameter(
19149       this.attribute_spec,
19150       this.reified,
19151       this.variance,
19152       name,
19153       this.constraints);
19154   }
19155   with_constraints(constraints){
19156     return new TypeParameter(
19157       this.attribute_spec,
19158       this.reified,
19159       this.variance,
19160       this.name,
19161       constraints);
19162   }
19163   rewrite(rewriter, parents)
19164   {
19165     if (parents == undefined)
19166       parents = [];
19167     let new_parents = parents.slice();
19168     new_parents.push(this);
19169     var attribute_spec = this.attribute_spec.rewrite(rewriter, new_parents);
19170     var reified = this.reified.rewrite(rewriter, new_parents);
19171     var variance = this.variance.rewrite(rewriter, new_parents);
19172     var name = this.name.rewrite(rewriter, new_parents);
19173     var constraints = this.constraints.rewrite(rewriter, new_parents);
19174     if (
19175       attribute_spec === this.attribute_spec &&
19176       reified === this.reified &&
19177       variance === this.variance &&
19178       name === this.name &&
19179       constraints === this.constraints)
19180     {
19181       return rewriter(this, parents);
19182     }
19183     else
19184     {
19185       return rewriter(new TypeParameter(
19186         attribute_spec,
19187         reified,
19188         variance,
19189         name,
19190         constraints), parents);
19191     }
19192   }
19193   static from_json(json, position, source)
19194   {
19195     let attribute_spec = EditableSyntax.from_json(
19196       json.type_attribute_spec, position, source);
19197     position += attribute_spec.width;
19198     let reified = EditableSyntax.from_json(
19199       json.type_reified, position, source);
19200     position += reified.width;
19201     let variance = EditableSyntax.from_json(
19202       json.type_variance, position, source);
19203     position += variance.width;
19204     let name = EditableSyntax.from_json(
19205       json.type_name, position, source);
19206     position += name.width;
19207     let constraints = EditableSyntax.from_json(
19208       json.type_constraints, position, source);
19209     position += constraints.width;
19210     return new TypeParameter(
19211         attribute_spec,
19212         reified,
19213         variance,
19214         name,
19215         constraints);
19216   }
19217   get children_keys()
19218   {
19219     if (TypeParameter._children_keys == null)
19220       TypeParameter._children_keys = [
19221         'attribute_spec',
19222         'reified',
19223         'variance',
19224         'name',
19225         'constraints'];
19226     return TypeParameter._children_keys;
19227   }
19228 }
19229 class TypeConstraint extends EditableSyntax
19230 {
19231   constructor(
19232     keyword,
19233     type)
19234   {
19235     super('type_constraint', {
19236       keyword: keyword,
19237       type: type });
19238   }
19239   get keyword() { return this.children.keyword; }
19240   get type() { return this.children.type; }
19241   with_keyword(keyword){
19242     return new TypeConstraint(
19243       keyword,
19244       this.type);
19245   }
19246   with_type(type){
19247     return new TypeConstraint(
19248       this.keyword,
19249       type);
19250   }
19251   rewrite(rewriter, parents)
19252   {
19253     if (parents == undefined)
19254       parents = [];
19255     let new_parents = parents.slice();
19256     new_parents.push(this);
19257     var keyword = this.keyword.rewrite(rewriter, new_parents);
19258     var type = this.type.rewrite(rewriter, new_parents);
19259     if (
19260       keyword === this.keyword &&
19261       type === this.type)
19262     {
19263       return rewriter(this, parents);
19264     }
19265     else
19266     {
19267       return rewriter(new TypeConstraint(
19268         keyword,
19269         type), parents);
19270     }
19271   }
19272   static from_json(json, position, source)
19273   {
19274     let keyword = EditableSyntax.from_json(
19275       json.constraint_keyword, position, source);
19276     position += keyword.width;
19277     let type = EditableSyntax.from_json(
19278       json.constraint_type, position, source);
19279     position += type.width;
19280     return new TypeConstraint(
19281         keyword,
19282         type);
19283   }
19284   get children_keys()
19285   {
19286     if (TypeConstraint._children_keys == null)
19287       TypeConstraint._children_keys = [
19288         'keyword',
19289         'type'];
19290     return TypeConstraint._children_keys;
19291   }
19292 }
19293 class DarrayTypeSpecifier extends EditableSyntax
19294 {
19295   constructor(
19296     keyword,
19297     left_angle,
19298     key,
19299     comma,
19300     value,
19301     trailing_comma,
19302     right_angle)
19303   {
19304     super('darray_type_specifier', {
19305       keyword: keyword,
19306       left_angle: left_angle,
19307       key: key,
19308       comma: comma,
19309       value: value,
19310       trailing_comma: trailing_comma,
19311       right_angle: right_angle });
19312   }
19313   get keyword() { return this.children.keyword; }
19314   get left_angle() { return this.children.left_angle; }
19315   get key() { return this.children.key; }
19316   get comma() { return this.children.comma; }
19317   get value() { return this.children.value; }
19318   get trailing_comma() { return this.children.trailing_comma; }
19319   get right_angle() { return this.children.right_angle; }
19320   with_keyword(keyword){
19321     return new DarrayTypeSpecifier(
19322       keyword,
19323       this.left_angle,
19324       this.key,
19325       this.comma,
19326       this.value,
19327       this.trailing_comma,
19328       this.right_angle);
19329   }
19330   with_left_angle(left_angle){
19331     return new DarrayTypeSpecifier(
19332       this.keyword,
19333       left_angle,
19334       this.key,
19335       this.comma,
19336       this.value,
19337       this.trailing_comma,
19338       this.right_angle);
19339   }
19340   with_key(key){
19341     return new DarrayTypeSpecifier(
19342       this.keyword,
19343       this.left_angle,
19344       key,
19345       this.comma,
19346       this.value,
19347       this.trailing_comma,
19348       this.right_angle);
19349   }
19350   with_comma(comma){
19351     return new DarrayTypeSpecifier(
19352       this.keyword,
19353       this.left_angle,
19354       this.key,
19355       comma,
19356       this.value,
19357       this.trailing_comma,
19358       this.right_angle);
19359   }
19360   with_value(value){
19361     return new DarrayTypeSpecifier(
19362       this.keyword,
19363       this.left_angle,
19364       this.key,
19365       this.comma,
19366       value,
19367       this.trailing_comma,
19368       this.right_angle);
19369   }
19370   with_trailing_comma(trailing_comma){
19371     return new DarrayTypeSpecifier(
19372       this.keyword,
19373       this.left_angle,
19374       this.key,
19375       this.comma,
19376       this.value,
19377       trailing_comma,
19378       this.right_angle);
19379   }
19380   with_right_angle(right_angle){
19381     return new DarrayTypeSpecifier(
19382       this.keyword,
19383       this.left_angle,
19384       this.key,
19385       this.comma,
19386       this.value,
19387       this.trailing_comma,
19388       right_angle);
19389   }
19390   rewrite(rewriter, parents)
19391   {
19392     if (parents == undefined)
19393       parents = [];
19394     let new_parents = parents.slice();
19395     new_parents.push(this);
19396     var keyword = this.keyword.rewrite(rewriter, new_parents);
19397     var left_angle = this.left_angle.rewrite(rewriter, new_parents);
19398     var key = this.key.rewrite(rewriter, new_parents);
19399     var comma = this.comma.rewrite(rewriter, new_parents);
19400     var value = this.value.rewrite(rewriter, new_parents);
19401     var trailing_comma = this.trailing_comma.rewrite(rewriter, new_parents);
19402     var right_angle = this.right_angle.rewrite(rewriter, new_parents);
19403     if (
19404       keyword === this.keyword &&
19405       left_angle === this.left_angle &&
19406       key === this.key &&
19407       comma === this.comma &&
19408       value === this.value &&
19409       trailing_comma === this.trailing_comma &&
19410       right_angle === this.right_angle)
19411     {
19412       return rewriter(this, parents);
19413     }
19414     else
19415     {
19416       return rewriter(new DarrayTypeSpecifier(
19417         keyword,
19418         left_angle,
19419         key,
19420         comma,
19421         value,
19422         trailing_comma,
19423         right_angle), parents);
19424     }
19425   }
19426   static from_json(json, position, source)
19427   {
19428     let keyword = EditableSyntax.from_json(
19429       json.darray_keyword, position, source);
19430     position += keyword.width;
19431     let left_angle = EditableSyntax.from_json(
19432       json.darray_left_angle, position, source);
19433     position += left_angle.width;
19434     let key = EditableSyntax.from_json(
19435       json.darray_key, position, source);
19436     position += key.width;
19437     let comma = EditableSyntax.from_json(
19438       json.darray_comma, position, source);
19439     position += comma.width;
19440     let value = EditableSyntax.from_json(
19441       json.darray_value, position, source);
19442     position += value.width;
19443     let trailing_comma = EditableSyntax.from_json(
19444       json.darray_trailing_comma, position, source);
19445     position += trailing_comma.width;
19446     let right_angle = EditableSyntax.from_json(
19447       json.darray_right_angle, position, source);
19448     position += right_angle.width;
19449     return new DarrayTypeSpecifier(
19450         keyword,
19451         left_angle,
19452         key,
19453         comma,
19454         value,
19455         trailing_comma,
19456         right_angle);
19457   }
19458   get children_keys()
19459   {
19460     if (DarrayTypeSpecifier._children_keys == null)
19461       DarrayTypeSpecifier._children_keys = [
19462         'keyword',
19463         'left_angle',
19464         'key',
19465         'comma',
19466         'value',
19467         'trailing_comma',
19468         'right_angle'];
19469     return DarrayTypeSpecifier._children_keys;
19470   }
19471 }
19472 class MapArrayTypeSpecifier extends EditableSyntax
19473 {
19474   constructor(
19475     keyword,
19476     left_angle,
19477     key,
19478     comma,
19479     value,
19480     right_angle)
19481   {
19482     super('map_array_type_specifier', {
19483       keyword: keyword,
19484       left_angle: left_angle,
19485       key: key,
19486       comma: comma,
19487       value: value,
19488       right_angle: right_angle });
19489   }
19490   get keyword() { return this.children.keyword; }
19491   get left_angle() { return this.children.left_angle; }
19492   get key() { return this.children.key; }
19493   get comma() { return this.children.comma; }
19494   get value() { return this.children.value; }
19495   get right_angle() { return this.children.right_angle; }
19496   with_keyword(keyword){
19497     return new MapArrayTypeSpecifier(
19498       keyword,
19499       this.left_angle,
19500       this.key,
19501       this.comma,
19502       this.value,
19503       this.right_angle);
19504   }
19505   with_left_angle(left_angle){
19506     return new MapArrayTypeSpecifier(
19507       this.keyword,
19508       left_angle,
19509       this.key,
19510       this.comma,
19511       this.value,
19512       this.right_angle);
19513   }
19514   with_key(key){
19515     return new MapArrayTypeSpecifier(
19516       this.keyword,
19517       this.left_angle,
19518       key,
19519       this.comma,
19520       this.value,
19521       this.right_angle);
19522   }
19523   with_comma(comma){
19524     return new MapArrayTypeSpecifier(
19525       this.keyword,
19526       this.left_angle,
19527       this.key,
19528       comma,
19529       this.value,
19530       this.right_angle);
19531   }
19532   with_value(value){
19533     return new MapArrayTypeSpecifier(
19534       this.keyword,
19535       this.left_angle,
19536       this.key,
19537       this.comma,
19538       value,
19539       this.right_angle);
19540   }
19541   with_right_angle(right_angle){
19542     return new MapArrayTypeSpecifier(
19543       this.keyword,
19544       this.left_angle,
19545       this.key,
19546       this.comma,
19547       this.value,
19548       right_angle);
19549   }
19550   rewrite(rewriter, parents)
19551   {
19552     if (parents == undefined)
19553       parents = [];
19554     let new_parents = parents.slice();
19555     new_parents.push(this);
19556     var keyword = this.keyword.rewrite(rewriter, new_parents);
19557     var left_angle = this.left_angle.rewrite(rewriter, new_parents);
19558     var key = this.key.rewrite(rewriter, new_parents);
19559     var comma = this.comma.rewrite(rewriter, new_parents);
19560     var value = this.value.rewrite(rewriter, new_parents);
19561     var right_angle = this.right_angle.rewrite(rewriter, new_parents);
19562     if (
19563       keyword === this.keyword &&
19564       left_angle === this.left_angle &&
19565       key === this.key &&
19566       comma === this.comma &&
19567       value === this.value &&
19568       right_angle === this.right_angle)
19569     {
19570       return rewriter(this, parents);
19571     }
19572     else
19573     {
19574       return rewriter(new MapArrayTypeSpecifier(
19575         keyword,
19576         left_angle,
19577         key,
19578         comma,
19579         value,
19580         right_angle), parents);
19581     }
19582   }
19583   static from_json(json, position, source)
19584   {
19585     let keyword = EditableSyntax.from_json(
19586       json.map_array_keyword, position, source);
19587     position += keyword.width;
19588     let left_angle = EditableSyntax.from_json(
19589       json.map_array_left_angle, position, source);
19590     position += left_angle.width;
19591     let key = EditableSyntax.from_json(
19592       json.map_array_key, position, source);
19593     position += key.width;
19594     let comma = EditableSyntax.from_json(
19595       json.map_array_comma, position, source);
19596     position += comma.width;
19597     let value = EditableSyntax.from_json(
19598       json.map_array_value, position, source);
19599     position += value.width;
19600     let right_angle = EditableSyntax.from_json(
19601       json.map_array_right_angle, position, source);
19602     position += right_angle.width;
19603     return new MapArrayTypeSpecifier(
19604         keyword,
19605         left_angle,
19606         key,
19607         comma,
19608         value,
19609         right_angle);
19610   }
19611   get children_keys()
19612   {
19613     if (MapArrayTypeSpecifier._children_keys == null)
19614       MapArrayTypeSpecifier._children_keys = [
19615         'keyword',
19616         'left_angle',
19617         'key',
19618         'comma',
19619         'value',
19620         'right_angle'];
19621     return MapArrayTypeSpecifier._children_keys;
19622   }
19623 }
19624 class DictionaryTypeSpecifier extends EditableSyntax
19625 {
19626   constructor(
19627     keyword,
19628     left_angle,
19629     members,
19630     right_angle)
19631   {
19632     super('dictionary_type_specifier', {
19633       keyword: keyword,
19634       left_angle: left_angle,
19635       members: members,
19636       right_angle: right_angle });
19637   }
19638   get keyword() { return this.children.keyword; }
19639   get left_angle() { return this.children.left_angle; }
19640   get members() { return this.children.members; }
19641   get right_angle() { return this.children.right_angle; }
19642   with_keyword(keyword){
19643     return new DictionaryTypeSpecifier(
19644       keyword,
19645       this.left_angle,
19646       this.members,
19647       this.right_angle);
19648   }
19649   with_left_angle(left_angle){
19650     return new DictionaryTypeSpecifier(
19651       this.keyword,
19652       left_angle,
19653       this.members,
19654       this.right_angle);
19655   }
19656   with_members(members){
19657     return new DictionaryTypeSpecifier(
19658       this.keyword,
19659       this.left_angle,
19660       members,
19661       this.right_angle);
19662   }
19663   with_right_angle(right_angle){
19664     return new DictionaryTypeSpecifier(
19665       this.keyword,
19666       this.left_angle,
19667       this.members,
19668       right_angle);
19669   }
19670   rewrite(rewriter, parents)
19671   {
19672     if (parents == undefined)
19673       parents = [];
19674     let new_parents = parents.slice();
19675     new_parents.push(this);
19676     var keyword = this.keyword.rewrite(rewriter, new_parents);
19677     var left_angle = this.left_angle.rewrite(rewriter, new_parents);
19678     var members = this.members.rewrite(rewriter, new_parents);
19679     var right_angle = this.right_angle.rewrite(rewriter, new_parents);
19680     if (
19681       keyword === this.keyword &&
19682       left_angle === this.left_angle &&
19683       members === this.members &&
19684       right_angle === this.right_angle)
19685     {
19686       return rewriter(this, parents);
19687     }
19688     else
19689     {
19690       return rewriter(new DictionaryTypeSpecifier(
19691         keyword,
19692         left_angle,
19693         members,
19694         right_angle), parents);
19695     }
19696   }
19697   static from_json(json, position, source)
19698   {
19699     let keyword = EditableSyntax.from_json(
19700       json.dictionary_type_keyword, position, source);
19701     position += keyword.width;
19702     let left_angle = EditableSyntax.from_json(
19703       json.dictionary_type_left_angle, position, source);
19704     position += left_angle.width;
19705     let members = EditableSyntax.from_json(
19706       json.dictionary_type_members, position, source);
19707     position += members.width;
19708     let right_angle = EditableSyntax.from_json(
19709       json.dictionary_type_right_angle, position, source);
19710     position += right_angle.width;
19711     return new DictionaryTypeSpecifier(
19712         keyword,
19713         left_angle,
19714         members,
19715         right_angle);
19716   }
19717   get children_keys()
19718   {
19719     if (DictionaryTypeSpecifier._children_keys == null)
19720       DictionaryTypeSpecifier._children_keys = [
19721         'keyword',
19722         'left_angle',
19723         'members',
19724         'right_angle'];
19725     return DictionaryTypeSpecifier._children_keys;
19726   }
19727 }
19728 class ClosureTypeSpecifier extends EditableSyntax
19729 {
19730   constructor(
19731     outer_left_paren,
19732     coroutine,
19733     function_keyword,
19734     inner_left_paren,
19735     parameter_list,
19736     inner_right_paren,
19737     colon,
19738     return_type,
19739     outer_right_paren)
19740   {
19741     super('closure_type_specifier', {
19742       outer_left_paren: outer_left_paren,
19743       coroutine: coroutine,
19744       function_keyword: function_keyword,
19745       inner_left_paren: inner_left_paren,
19746       parameter_list: parameter_list,
19747       inner_right_paren: inner_right_paren,
19748       colon: colon,
19749       return_type: return_type,
19750       outer_right_paren: outer_right_paren });
19751   }
19752   get outer_left_paren() { return this.children.outer_left_paren; }
19753   get coroutine() { return this.children.coroutine; }
19754   get function_keyword() { return this.children.function_keyword; }
19755   get inner_left_paren() { return this.children.inner_left_paren; }
19756   get parameter_list() { return this.children.parameter_list; }
19757   get inner_right_paren() { return this.children.inner_right_paren; }
19758   get colon() { return this.children.colon; }
19759   get return_type() { return this.children.return_type; }
19760   get outer_right_paren() { return this.children.outer_right_paren; }
19761   with_outer_left_paren(outer_left_paren){
19762     return new ClosureTypeSpecifier(
19763       outer_left_paren,
19764       this.coroutine,
19765       this.function_keyword,
19766       this.inner_left_paren,
19767       this.parameter_list,
19768       this.inner_right_paren,
19769       this.colon,
19770       this.return_type,
19771       this.outer_right_paren);
19772   }
19773   with_coroutine(coroutine){
19774     return new ClosureTypeSpecifier(
19775       this.outer_left_paren,
19776       coroutine,
19777       this.function_keyword,
19778       this.inner_left_paren,
19779       this.parameter_list,
19780       this.inner_right_paren,
19781       this.colon,
19782       this.return_type,
19783       this.outer_right_paren);
19784   }
19785   with_function_keyword(function_keyword){
19786     return new ClosureTypeSpecifier(
19787       this.outer_left_paren,
19788       this.coroutine,
19789       function_keyword,
19790       this.inner_left_paren,
19791       this.parameter_list,
19792       this.inner_right_paren,
19793       this.colon,
19794       this.return_type,
19795       this.outer_right_paren);
19796   }
19797   with_inner_left_paren(inner_left_paren){
19798     return new ClosureTypeSpecifier(
19799       this.outer_left_paren,
19800       this.coroutine,
19801       this.function_keyword,
19802       inner_left_paren,
19803       this.parameter_list,
19804       this.inner_right_paren,
19805       this.colon,
19806       this.return_type,
19807       this.outer_right_paren);
19808   }
19809   with_parameter_list(parameter_list){
19810     return new ClosureTypeSpecifier(
19811       this.outer_left_paren,
19812       this.coroutine,
19813       this.function_keyword,
19814       this.inner_left_paren,
19815       parameter_list,
19816       this.inner_right_paren,
19817       this.colon,
19818       this.return_type,
19819       this.outer_right_paren);
19820   }
19821   with_inner_right_paren(inner_right_paren){
19822     return new ClosureTypeSpecifier(
19823       this.outer_left_paren,
19824       this.coroutine,
19825       this.function_keyword,
19826       this.inner_left_paren,
19827       this.parameter_list,
19828       inner_right_paren,
19829       this.colon,
19830       this.return_type,
19831       this.outer_right_paren);
19832   }
19833   with_colon(colon){
19834     return new ClosureTypeSpecifier(
19835       this.outer_left_paren,
19836       this.coroutine,
19837       this.function_keyword,
19838       this.inner_left_paren,
19839       this.parameter_list,
19840       this.inner_right_paren,
19841       colon,
19842       this.return_type,
19843       this.outer_right_paren);
19844   }
19845   with_return_type(return_type){
19846     return new ClosureTypeSpecifier(
19847       this.outer_left_paren,
19848       this.coroutine,
19849       this.function_keyword,
19850       this.inner_left_paren,
19851       this.parameter_list,
19852       this.inner_right_paren,
19853       this.colon,
19854       return_type,
19855       this.outer_right_paren);
19856   }
19857   with_outer_right_paren(outer_right_paren){
19858     return new ClosureTypeSpecifier(
19859       this.outer_left_paren,
19860       this.coroutine,
19861       this.function_keyword,
19862       this.inner_left_paren,
19863       this.parameter_list,
19864       this.inner_right_paren,
19865       this.colon,
19866       this.return_type,
19867       outer_right_paren);
19868   }
19869   rewrite(rewriter, parents)
19870   {
19871     if (parents == undefined)
19872       parents = [];
19873     let new_parents = parents.slice();
19874     new_parents.push(this);
19875     var outer_left_paren = this.outer_left_paren.rewrite(rewriter, new_parents);
19876     var coroutine = this.coroutine.rewrite(rewriter, new_parents);
19877     var function_keyword = this.function_keyword.rewrite(rewriter, new_parents);
19878     var inner_left_paren = this.inner_left_paren.rewrite(rewriter, new_parents);
19879     var parameter_list = this.parameter_list.rewrite(rewriter, new_parents);
19880     var inner_right_paren = this.inner_right_paren.rewrite(rewriter, new_parents);
19881     var colon = this.colon.rewrite(rewriter, new_parents);
19882     var return_type = this.return_type.rewrite(rewriter, new_parents);
19883     var outer_right_paren = this.outer_right_paren.rewrite(rewriter, new_parents);
19884     if (
19885       outer_left_paren === this.outer_left_paren &&
19886       coroutine === this.coroutine &&
19887       function_keyword === this.function_keyword &&
19888       inner_left_paren === this.inner_left_paren &&
19889       parameter_list === this.parameter_list &&
19890       inner_right_paren === this.inner_right_paren &&
19891       colon === this.colon &&
19892       return_type === this.return_type &&
19893       outer_right_paren === this.outer_right_paren)
19894     {
19895       return rewriter(this, parents);
19896     }
19897     else
19898     {
19899       return rewriter(new ClosureTypeSpecifier(
19900         outer_left_paren,
19901         coroutine,
19902         function_keyword,
19903         inner_left_paren,
19904         parameter_list,
19905         inner_right_paren,
19906         colon,
19907         return_type,
19908         outer_right_paren), parents);
19909     }
19910   }
19911   static from_json(json, position, source)
19912   {
19913     let outer_left_paren = EditableSyntax.from_json(
19914       json.closure_outer_left_paren, position, source);
19915     position += outer_left_paren.width;
19916     let coroutine = EditableSyntax.from_json(
19917       json.closure_coroutine, position, source);
19918     position += coroutine.width;
19919     let function_keyword = EditableSyntax.from_json(
19920       json.closure_function_keyword, position, source);
19921     position += function_keyword.width;
19922     let inner_left_paren = EditableSyntax.from_json(
19923       json.closure_inner_left_paren, position, source);
19924     position += inner_left_paren.width;
19925     let parameter_list = EditableSyntax.from_json(
19926       json.closure_parameter_list, position, source);
19927     position += parameter_list.width;
19928     let inner_right_paren = EditableSyntax.from_json(
19929       json.closure_inner_right_paren, position, source);
19930     position += inner_right_paren.width;
19931     let colon = EditableSyntax.from_json(
19932       json.closure_colon, position, source);
19933     position += colon.width;
19934     let return_type = EditableSyntax.from_json(
19935       json.closure_return_type, position, source);
19936     position += return_type.width;
19937     let outer_right_paren = EditableSyntax.from_json(
19938       json.closure_outer_right_paren, position, source);
19939     position += outer_right_paren.width;
19940     return new ClosureTypeSpecifier(
19941         outer_left_paren,
19942         coroutine,
19943         function_keyword,
19944         inner_left_paren,
19945         parameter_list,
19946         inner_right_paren,
19947         colon,
19948         return_type,
19949         outer_right_paren);
19950   }
19951   get children_keys()
19952   {
19953     if (ClosureTypeSpecifier._children_keys == null)
19954       ClosureTypeSpecifier._children_keys = [
19955         'outer_left_paren',
19956         'coroutine',
19957         'function_keyword',
19958         'inner_left_paren',
19959         'parameter_list',
19960         'inner_right_paren',
19961         'colon',
19962         'return_type',
19963         'outer_right_paren'];
19964     return ClosureTypeSpecifier._children_keys;
19965   }
19966 }
19967 class ClosureParameterTypeSpecifier extends EditableSyntax
19968 {
19969   constructor(
19970     call_convention,
19971     type)
19972   {
19973     super('closure_parameter_type_specifier', {
19974       call_convention: call_convention,
19975       type: type });
19976   }
19977   get call_convention() { return this.children.call_convention; }
19978   get type() { return this.children.type; }
19979   with_call_convention(call_convention){
19980     return new ClosureParameterTypeSpecifier(
19981       call_convention,
19982       this.type);
19983   }
19984   with_type(type){
19985     return new ClosureParameterTypeSpecifier(
19986       this.call_convention,
19987       type);
19988   }
19989   rewrite(rewriter, parents)
19990   {
19991     if (parents == undefined)
19992       parents = [];
19993     let new_parents = parents.slice();
19994     new_parents.push(this);
19995     var call_convention = this.call_convention.rewrite(rewriter, new_parents);
19996     var type = this.type.rewrite(rewriter, new_parents);
19997     if (
19998       call_convention === this.call_convention &&
19999       type === this.type)
20000     {
20001       return rewriter(this, parents);
20002     }
20003     else
20004     {
20005       return rewriter(new ClosureParameterTypeSpecifier(
20006         call_convention,
20007         type), parents);
20008     }
20009   }
20010   static from_json(json, position, source)
20011   {
20012     let call_convention = EditableSyntax.from_json(
20013       json.closure_parameter_call_convention, position, source);
20014     position += call_convention.width;
20015     let type = EditableSyntax.from_json(
20016       json.closure_parameter_type, position, source);
20017     position += type.width;
20018     return new ClosureParameterTypeSpecifier(
20019         call_convention,
20020         type);
20021   }
20022   get children_keys()
20023   {
20024     if (ClosureParameterTypeSpecifier._children_keys == null)
20025       ClosureParameterTypeSpecifier._children_keys = [
20026         'call_convention',
20027         'type'];
20028     return ClosureParameterTypeSpecifier._children_keys;
20029   }
20030 }
20031 class ClassnameTypeSpecifier extends EditableSyntax
20032 {
20033   constructor(
20034     keyword,
20035     left_angle,
20036     type,
20037     trailing_comma,
20038     right_angle)
20039   {
20040     super('classname_type_specifier', {
20041       keyword: keyword,
20042       left_angle: left_angle,
20043       type: type,
20044       trailing_comma: trailing_comma,
20045       right_angle: right_angle });
20046   }
20047   get keyword() { return this.children.keyword; }
20048   get left_angle() { return this.children.left_angle; }
20049   get type() { return this.children.type; }
20050   get trailing_comma() { return this.children.trailing_comma; }
20051   get right_angle() { return this.children.right_angle; }
20052   with_keyword(keyword){
20053     return new ClassnameTypeSpecifier(
20054       keyword,
20055       this.left_angle,
20056       this.type,
20057       this.trailing_comma,
20058       this.right_angle);
20059   }
20060   with_left_angle(left_angle){
20061     return new ClassnameTypeSpecifier(
20062       this.keyword,
20063       left_angle,
20064       this.type,
20065       this.trailing_comma,
20066       this.right_angle);
20067   }
20068   with_type(type){
20069     return new ClassnameTypeSpecifier(
20070       this.keyword,
20071       this.left_angle,
20072       type,
20073       this.trailing_comma,
20074       this.right_angle);
20075   }
20076   with_trailing_comma(trailing_comma){
20077     return new ClassnameTypeSpecifier(
20078       this.keyword,
20079       this.left_angle,
20080       this.type,
20081       trailing_comma,
20082       this.right_angle);
20083   }
20084   with_right_angle(right_angle){
20085     return new ClassnameTypeSpecifier(
20086       this.keyword,
20087       this.left_angle,
20088       this.type,
20089       this.trailing_comma,
20090       right_angle);
20091   }
20092   rewrite(rewriter, parents)
20093   {
20094     if (parents == undefined)
20095       parents = [];
20096     let new_parents = parents.slice();
20097     new_parents.push(this);
20098     var keyword = this.keyword.rewrite(rewriter, new_parents);
20099     var left_angle = this.left_angle.rewrite(rewriter, new_parents);
20100     var type = this.type.rewrite(rewriter, new_parents);
20101     var trailing_comma = this.trailing_comma.rewrite(rewriter, new_parents);
20102     var right_angle = this.right_angle.rewrite(rewriter, new_parents);
20103     if (
20104       keyword === this.keyword &&
20105       left_angle === this.left_angle &&
20106       type === this.type &&
20107       trailing_comma === this.trailing_comma &&
20108       right_angle === this.right_angle)
20109     {
20110       return rewriter(this, parents);
20111     }
20112     else
20113     {
20114       return rewriter(new ClassnameTypeSpecifier(
20115         keyword,
20116         left_angle,
20117         type,
20118         trailing_comma,
20119         right_angle), parents);
20120     }
20121   }
20122   static from_json(json, position, source)
20123   {
20124     let keyword = EditableSyntax.from_json(
20125       json.classname_keyword, position, source);
20126     position += keyword.width;
20127     let left_angle = EditableSyntax.from_json(
20128       json.classname_left_angle, position, source);
20129     position += left_angle.width;
20130     let type = EditableSyntax.from_json(
20131       json.classname_type, position, source);
20132     position += type.width;
20133     let trailing_comma = EditableSyntax.from_json(
20134       json.classname_trailing_comma, position, source);
20135     position += trailing_comma.width;
20136     let right_angle = EditableSyntax.from_json(
20137       json.classname_right_angle, position, source);
20138     position += right_angle.width;
20139     return new ClassnameTypeSpecifier(
20140         keyword,
20141         left_angle,
20142         type,
20143         trailing_comma,
20144         right_angle);
20145   }
20146   get children_keys()
20147   {
20148     if (ClassnameTypeSpecifier._children_keys == null)
20149       ClassnameTypeSpecifier._children_keys = [
20150         'keyword',
20151         'left_angle',
20152         'type',
20153         'trailing_comma',
20154         'right_angle'];
20155     return ClassnameTypeSpecifier._children_keys;
20156   }
20157 }
20158 class FieldSpecifier extends EditableSyntax
20159 {
20160   constructor(
20161     question,
20162     name,
20163     arrow,
20164     type)
20165   {
20166     super('field_specifier', {
20167       question: question,
20168       name: name,
20169       arrow: arrow,
20170       type: type });
20171   }
20172   get question() { return this.children.question; }
20173   get name() { return this.children.name; }
20174   get arrow() { return this.children.arrow; }
20175   get type() { return this.children.type; }
20176   with_question(question){
20177     return new FieldSpecifier(
20178       question,
20179       this.name,
20180       this.arrow,
20181       this.type);
20182   }
20183   with_name(name){
20184     return new FieldSpecifier(
20185       this.question,
20186       name,
20187       this.arrow,
20188       this.type);
20189   }
20190   with_arrow(arrow){
20191     return new FieldSpecifier(
20192       this.question,
20193       this.name,
20194       arrow,
20195       this.type);
20196   }
20197   with_type(type){
20198     return new FieldSpecifier(
20199       this.question,
20200       this.name,
20201       this.arrow,
20202       type);
20203   }
20204   rewrite(rewriter, parents)
20205   {
20206     if (parents == undefined)
20207       parents = [];
20208     let new_parents = parents.slice();
20209     new_parents.push(this);
20210     var question = this.question.rewrite(rewriter, new_parents);
20211     var name = this.name.rewrite(rewriter, new_parents);
20212     var arrow = this.arrow.rewrite(rewriter, new_parents);
20213     var type = this.type.rewrite(rewriter, new_parents);
20214     if (
20215       question === this.question &&
20216       name === this.name &&
20217       arrow === this.arrow &&
20218       type === this.type)
20219     {
20220       return rewriter(this, parents);
20221     }
20222     else
20223     {
20224       return rewriter(new FieldSpecifier(
20225         question,
20226         name,
20227         arrow,
20228         type), parents);
20229     }
20230   }
20231   static from_json(json, position, source)
20232   {
20233     let question = EditableSyntax.from_json(
20234       json.field_question, position, source);
20235     position += question.width;
20236     let name = EditableSyntax.from_json(
20237       json.field_name, position, source);
20238     position += name.width;
20239     let arrow = EditableSyntax.from_json(
20240       json.field_arrow, position, source);
20241     position += arrow.width;
20242     let type = EditableSyntax.from_json(
20243       json.field_type, position, source);
20244     position += type.width;
20245     return new FieldSpecifier(
20246         question,
20247         name,
20248         arrow,
20249         type);
20250   }
20251   get children_keys()
20252   {
20253     if (FieldSpecifier._children_keys == null)
20254       FieldSpecifier._children_keys = [
20255         'question',
20256         'name',
20257         'arrow',
20258         'type'];
20259     return FieldSpecifier._children_keys;
20260   }
20261 }
20262 class FieldInitializer extends EditableSyntax
20263 {
20264   constructor(
20265     name,
20266     arrow,
20267     value)
20268   {
20269     super('field_initializer', {
20270       name: name,
20271       arrow: arrow,
20272       value: value });
20273   }
20274   get name() { return this.children.name; }
20275   get arrow() { return this.children.arrow; }
20276   get value() { return this.children.value; }
20277   with_name(name){
20278     return new FieldInitializer(
20279       name,
20280       this.arrow,
20281       this.value);
20282   }
20283   with_arrow(arrow){
20284     return new FieldInitializer(
20285       this.name,
20286       arrow,
20287       this.value);
20288   }
20289   with_value(value){
20290     return new FieldInitializer(
20291       this.name,
20292       this.arrow,
20293       value);
20294   }
20295   rewrite(rewriter, parents)
20296   {
20297     if (parents == undefined)
20298       parents = [];
20299     let new_parents = parents.slice();
20300     new_parents.push(this);
20301     var name = this.name.rewrite(rewriter, new_parents);
20302     var arrow = this.arrow.rewrite(rewriter, new_parents);
20303     var value = this.value.rewrite(rewriter, new_parents);
20304     if (
20305       name === this.name &&
20306       arrow === this.arrow &&
20307       value === this.value)
20308     {
20309       return rewriter(this, parents);
20310     }
20311     else
20312     {
20313       return rewriter(new FieldInitializer(
20314         name,
20315         arrow,
20316         value), parents);
20317     }
20318   }
20319   static from_json(json, position, source)
20320   {
20321     let name = EditableSyntax.from_json(
20322       json.field_initializer_name, position, source);
20323     position += name.width;
20324     let arrow = EditableSyntax.from_json(
20325       json.field_initializer_arrow, position, source);
20326     position += arrow.width;
20327     let value = EditableSyntax.from_json(
20328       json.field_initializer_value, position, source);
20329     position += value.width;
20330     return new FieldInitializer(
20331         name,
20332         arrow,
20333         value);
20334   }
20335   get children_keys()
20336   {
20337     if (FieldInitializer._children_keys == null)
20338       FieldInitializer._children_keys = [
20339         'name',
20340         'arrow',
20341         'value'];
20342     return FieldInitializer._children_keys;
20343   }
20344 }
20345 class ShapeTypeSpecifier extends EditableSyntax
20346 {
20347   constructor(
20348     keyword,
20349     left_paren,
20350     fields,
20351     ellipsis,
20352     right_paren)
20353   {
20354     super('shape_type_specifier', {
20355       keyword: keyword,
20356       left_paren: left_paren,
20357       fields: fields,
20358       ellipsis: ellipsis,
20359       right_paren: right_paren });
20360   }
20361   get keyword() { return this.children.keyword; }
20362   get left_paren() { return this.children.left_paren; }
20363   get fields() { return this.children.fields; }
20364   get ellipsis() { return this.children.ellipsis; }
20365   get right_paren() { return this.children.right_paren; }
20366   with_keyword(keyword){
20367     return new ShapeTypeSpecifier(
20368       keyword,
20369       this.left_paren,
20370       this.fields,
20371       this.ellipsis,
20372       this.right_paren);
20373   }
20374   with_left_paren(left_paren){
20375     return new ShapeTypeSpecifier(
20376       this.keyword,
20377       left_paren,
20378       this.fields,
20379       this.ellipsis,
20380       this.right_paren);
20381   }
20382   with_fields(fields){
20383     return new ShapeTypeSpecifier(
20384       this.keyword,
20385       this.left_paren,
20386       fields,
20387       this.ellipsis,
20388       this.right_paren);
20389   }
20390   with_ellipsis(ellipsis){
20391     return new ShapeTypeSpecifier(
20392       this.keyword,
20393       this.left_paren,
20394       this.fields,
20395       ellipsis,
20396       this.right_paren);
20397   }
20398   with_right_paren(right_paren){
20399     return new ShapeTypeSpecifier(
20400       this.keyword,
20401       this.left_paren,
20402       this.fields,
20403       this.ellipsis,
20404       right_paren);
20405   }
20406   rewrite(rewriter, parents)
20407   {
20408     if (parents == undefined)
20409       parents = [];
20410     let new_parents = parents.slice();
20411     new_parents.push(this);
20412     var keyword = this.keyword.rewrite(rewriter, new_parents);
20413     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
20414     var fields = this.fields.rewrite(rewriter, new_parents);
20415     var ellipsis = this.ellipsis.rewrite(rewriter, new_parents);
20416     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
20417     if (
20418       keyword === this.keyword &&
20419       left_paren === this.left_paren &&
20420       fields === this.fields &&
20421       ellipsis === this.ellipsis &&
20422       right_paren === this.right_paren)
20423     {
20424       return rewriter(this, parents);
20425     }
20426     else
20427     {
20428       return rewriter(new ShapeTypeSpecifier(
20429         keyword,
20430         left_paren,
20431         fields,
20432         ellipsis,
20433         right_paren), parents);
20434     }
20435   }
20436   static from_json(json, position, source)
20437   {
20438     let keyword = EditableSyntax.from_json(
20439       json.shape_type_keyword, position, source);
20440     position += keyword.width;
20441     let left_paren = EditableSyntax.from_json(
20442       json.shape_type_left_paren, position, source);
20443     position += left_paren.width;
20444     let fields = EditableSyntax.from_json(
20445       json.shape_type_fields, position, source);
20446     position += fields.width;
20447     let ellipsis = EditableSyntax.from_json(
20448       json.shape_type_ellipsis, position, source);
20449     position += ellipsis.width;
20450     let right_paren = EditableSyntax.from_json(
20451       json.shape_type_right_paren, position, source);
20452     position += right_paren.width;
20453     return new ShapeTypeSpecifier(
20454         keyword,
20455         left_paren,
20456         fields,
20457         ellipsis,
20458         right_paren);
20459   }
20460   get children_keys()
20461   {
20462     if (ShapeTypeSpecifier._children_keys == null)
20463       ShapeTypeSpecifier._children_keys = [
20464         'keyword',
20465         'left_paren',
20466         'fields',
20467         'ellipsis',
20468         'right_paren'];
20469     return ShapeTypeSpecifier._children_keys;
20470   }
20471 }
20472 class ShapeExpression extends EditableSyntax
20473 {
20474   constructor(
20475     keyword,
20476     left_paren,
20477     fields,
20478     right_paren)
20479   {
20480     super('shape_expression', {
20481       keyword: keyword,
20482       left_paren: left_paren,
20483       fields: fields,
20484       right_paren: right_paren });
20485   }
20486   get keyword() { return this.children.keyword; }
20487   get left_paren() { return this.children.left_paren; }
20488   get fields() { return this.children.fields; }
20489   get right_paren() { return this.children.right_paren; }
20490   with_keyword(keyword){
20491     return new ShapeExpression(
20492       keyword,
20493       this.left_paren,
20494       this.fields,
20495       this.right_paren);
20496   }
20497   with_left_paren(left_paren){
20498     return new ShapeExpression(
20499       this.keyword,
20500       left_paren,
20501       this.fields,
20502       this.right_paren);
20503   }
20504   with_fields(fields){
20505     return new ShapeExpression(
20506       this.keyword,
20507       this.left_paren,
20508       fields,
20509       this.right_paren);
20510   }
20511   with_right_paren(right_paren){
20512     return new ShapeExpression(
20513       this.keyword,
20514       this.left_paren,
20515       this.fields,
20516       right_paren);
20517   }
20518   rewrite(rewriter, parents)
20519   {
20520     if (parents == undefined)
20521       parents = [];
20522     let new_parents = parents.slice();
20523     new_parents.push(this);
20524     var keyword = this.keyword.rewrite(rewriter, new_parents);
20525     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
20526     var fields = this.fields.rewrite(rewriter, new_parents);
20527     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
20528     if (
20529       keyword === this.keyword &&
20530       left_paren === this.left_paren &&
20531       fields === this.fields &&
20532       right_paren === this.right_paren)
20533     {
20534       return rewriter(this, parents);
20535     }
20536     else
20537     {
20538       return rewriter(new ShapeExpression(
20539         keyword,
20540         left_paren,
20541         fields,
20542         right_paren), parents);
20543     }
20544   }
20545   static from_json(json, position, source)
20546   {
20547     let keyword = EditableSyntax.from_json(
20548       json.shape_expression_keyword, position, source);
20549     position += keyword.width;
20550     let left_paren = EditableSyntax.from_json(
20551       json.shape_expression_left_paren, position, source);
20552     position += left_paren.width;
20553     let fields = EditableSyntax.from_json(
20554       json.shape_expression_fields, position, source);
20555     position += fields.width;
20556     let right_paren = EditableSyntax.from_json(
20557       json.shape_expression_right_paren, position, source);
20558     position += right_paren.width;
20559     return new ShapeExpression(
20560         keyword,
20561         left_paren,
20562         fields,
20563         right_paren);
20564   }
20565   get children_keys()
20566   {
20567     if (ShapeExpression._children_keys == null)
20568       ShapeExpression._children_keys = [
20569         'keyword',
20570         'left_paren',
20571         'fields',
20572         'right_paren'];
20573     return ShapeExpression._children_keys;
20574   }
20575 }
20576 class TupleExpression extends EditableSyntax
20577 {
20578   constructor(
20579     keyword,
20580     left_paren,
20581     items,
20582     right_paren)
20583   {
20584     super('tuple_expression', {
20585       keyword: keyword,
20586       left_paren: left_paren,
20587       items: items,
20588       right_paren: right_paren });
20589   }
20590   get keyword() { return this.children.keyword; }
20591   get left_paren() { return this.children.left_paren; }
20592   get items() { return this.children.items; }
20593   get right_paren() { return this.children.right_paren; }
20594   with_keyword(keyword){
20595     return new TupleExpression(
20596       keyword,
20597       this.left_paren,
20598       this.items,
20599       this.right_paren);
20600   }
20601   with_left_paren(left_paren){
20602     return new TupleExpression(
20603       this.keyword,
20604       left_paren,
20605       this.items,
20606       this.right_paren);
20607   }
20608   with_items(items){
20609     return new TupleExpression(
20610       this.keyword,
20611       this.left_paren,
20612       items,
20613       this.right_paren);
20614   }
20615   with_right_paren(right_paren){
20616     return new TupleExpression(
20617       this.keyword,
20618       this.left_paren,
20619       this.items,
20620       right_paren);
20621   }
20622   rewrite(rewriter, parents)
20623   {
20624     if (parents == undefined)
20625       parents = [];
20626     let new_parents = parents.slice();
20627     new_parents.push(this);
20628     var keyword = this.keyword.rewrite(rewriter, new_parents);
20629     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
20630     var items = this.items.rewrite(rewriter, new_parents);
20631     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
20632     if (
20633       keyword === this.keyword &&
20634       left_paren === this.left_paren &&
20635       items === this.items &&
20636       right_paren === this.right_paren)
20637     {
20638       return rewriter(this, parents);
20639     }
20640     else
20641     {
20642       return rewriter(new TupleExpression(
20643         keyword,
20644         left_paren,
20645         items,
20646         right_paren), parents);
20647     }
20648   }
20649   static from_json(json, position, source)
20650   {
20651     let keyword = EditableSyntax.from_json(
20652       json.tuple_expression_keyword, position, source);
20653     position += keyword.width;
20654     let left_paren = EditableSyntax.from_json(
20655       json.tuple_expression_left_paren, position, source);
20656     position += left_paren.width;
20657     let items = EditableSyntax.from_json(
20658       json.tuple_expression_items, position, source);
20659     position += items.width;
20660     let right_paren = EditableSyntax.from_json(
20661       json.tuple_expression_right_paren, position, source);
20662     position += right_paren.width;
20663     return new TupleExpression(
20664         keyword,
20665         left_paren,
20666         items,
20667         right_paren);
20668   }
20669   get children_keys()
20670   {
20671     if (TupleExpression._children_keys == null)
20672       TupleExpression._children_keys = [
20673         'keyword',
20674         'left_paren',
20675         'items',
20676         'right_paren'];
20677     return TupleExpression._children_keys;
20678   }
20679 }
20680 class GenericTypeSpecifier extends EditableSyntax
20681 {
20682   constructor(
20683     class_type,
20684     argument_list)
20685   {
20686     super('generic_type_specifier', {
20687       class_type: class_type,
20688       argument_list: argument_list });
20689   }
20690   get class_type() { return this.children.class_type; }
20691   get argument_list() { return this.children.argument_list; }
20692   with_class_type(class_type){
20693     return new GenericTypeSpecifier(
20694       class_type,
20695       this.argument_list);
20696   }
20697   with_argument_list(argument_list){
20698     return new GenericTypeSpecifier(
20699       this.class_type,
20700       argument_list);
20701   }
20702   rewrite(rewriter, parents)
20703   {
20704     if (parents == undefined)
20705       parents = [];
20706     let new_parents = parents.slice();
20707     new_parents.push(this);
20708     var class_type = this.class_type.rewrite(rewriter, new_parents);
20709     var argument_list = this.argument_list.rewrite(rewriter, new_parents);
20710     if (
20711       class_type === this.class_type &&
20712       argument_list === this.argument_list)
20713     {
20714       return rewriter(this, parents);
20715     }
20716     else
20717     {
20718       return rewriter(new GenericTypeSpecifier(
20719         class_type,
20720         argument_list), parents);
20721     }
20722   }
20723   static from_json(json, position, source)
20724   {
20725     let class_type = EditableSyntax.from_json(
20726       json.generic_class_type, position, source);
20727     position += class_type.width;
20728     let argument_list = EditableSyntax.from_json(
20729       json.generic_argument_list, position, source);
20730     position += argument_list.width;
20731     return new GenericTypeSpecifier(
20732         class_type,
20733         argument_list);
20734   }
20735   get children_keys()
20736   {
20737     if (GenericTypeSpecifier._children_keys == null)
20738       GenericTypeSpecifier._children_keys = [
20739         'class_type',
20740         'argument_list'];
20741     return GenericTypeSpecifier._children_keys;
20742   }
20743 }
20744 class NullableTypeSpecifier extends EditableSyntax
20745 {
20746   constructor(
20747     question,
20748     type)
20749   {
20750     super('nullable_type_specifier', {
20751       question: question,
20752       type: type });
20753   }
20754   get question() { return this.children.question; }
20755   get type() { return this.children.type; }
20756   with_question(question){
20757     return new NullableTypeSpecifier(
20758       question,
20759       this.type);
20760   }
20761   with_type(type){
20762     return new NullableTypeSpecifier(
20763       this.question,
20764       type);
20765   }
20766   rewrite(rewriter, parents)
20767   {
20768     if (parents == undefined)
20769       parents = [];
20770     let new_parents = parents.slice();
20771     new_parents.push(this);
20772     var question = this.question.rewrite(rewriter, new_parents);
20773     var type = this.type.rewrite(rewriter, new_parents);
20774     if (
20775       question === this.question &&
20776       type === this.type)
20777     {
20778       return rewriter(this, parents);
20779     }
20780     else
20781     {
20782       return rewriter(new NullableTypeSpecifier(
20783         question,
20784         type), parents);
20785     }
20786   }
20787   static from_json(json, position, source)
20788   {
20789     let question = EditableSyntax.from_json(
20790       json.nullable_question, position, source);
20791     position += question.width;
20792     let type = EditableSyntax.from_json(
20793       json.nullable_type, position, source);
20794     position += type.width;
20795     return new NullableTypeSpecifier(
20796         question,
20797         type);
20798   }
20799   get children_keys()
20800   {
20801     if (NullableTypeSpecifier._children_keys == null)
20802       NullableTypeSpecifier._children_keys = [
20803         'question',
20804         'type'];
20805     return NullableTypeSpecifier._children_keys;
20806   }
20807 }
20808 class SoftTypeSpecifier extends EditableSyntax
20809 {
20810   constructor(
20811     at,
20812     type)
20813   {
20814     super('soft_type_specifier', {
20815       at: at,
20816       type: type });
20817   }
20818   get at() { return this.children.at; }
20819   get type() { return this.children.type; }
20820   with_at(at){
20821     return new SoftTypeSpecifier(
20822       at,
20823       this.type);
20824   }
20825   with_type(type){
20826     return new SoftTypeSpecifier(
20827       this.at,
20828       type);
20829   }
20830   rewrite(rewriter, parents)
20831   {
20832     if (parents == undefined)
20833       parents = [];
20834     let new_parents = parents.slice();
20835     new_parents.push(this);
20836     var at = this.at.rewrite(rewriter, new_parents);
20837     var type = this.type.rewrite(rewriter, new_parents);
20838     if (
20839       at === this.at &&
20840       type === this.type)
20841     {
20842       return rewriter(this, parents);
20843     }
20844     else
20845     {
20846       return rewriter(new SoftTypeSpecifier(
20847         at,
20848         type), parents);
20849     }
20850   }
20851   static from_json(json, position, source)
20852   {
20853     let at = EditableSyntax.from_json(
20854       json.soft_at, position, source);
20855     position += at.width;
20856     let type = EditableSyntax.from_json(
20857       json.soft_type, position, source);
20858     position += type.width;
20859     return new SoftTypeSpecifier(
20860         at,
20861         type);
20862   }
20863   get children_keys()
20864   {
20865     if (SoftTypeSpecifier._children_keys == null)
20866       SoftTypeSpecifier._children_keys = [
20867         'at',
20868         'type'];
20869     return SoftTypeSpecifier._children_keys;
20870   }
20871 }
20872 class ReifiedTypeArgument extends EditableSyntax
20873 {
20874   constructor(
20875     reified,
20876     type)
20877   {
20878     super('reified_type_argument', {
20879       reified: reified,
20880       type: type });
20881   }
20882   get reified() { return this.children.reified; }
20883   get type() { return this.children.type; }
20884   with_reified(reified){
20885     return new ReifiedTypeArgument(
20886       reified,
20887       this.type);
20888   }
20889   with_type(type){
20890     return new ReifiedTypeArgument(
20891       this.reified,
20892       type);
20893   }
20894   rewrite(rewriter, parents)
20895   {
20896     if (parents == undefined)
20897       parents = [];
20898     let new_parents = parents.slice();
20899     new_parents.push(this);
20900     var reified = this.reified.rewrite(rewriter, new_parents);
20901     var type = this.type.rewrite(rewriter, new_parents);
20902     if (
20903       reified === this.reified &&
20904       type === this.type)
20905     {
20906       return rewriter(this, parents);
20907     }
20908     else
20909     {
20910       return rewriter(new ReifiedTypeArgument(
20911         reified,
20912         type), parents);
20913     }
20914   }
20915   static from_json(json, position, source)
20916   {
20917     let reified = EditableSyntax.from_json(
20918       json.reified_type_argument_reified, position, source);
20919     position += reified.width;
20920     let type = EditableSyntax.from_json(
20921       json.reified_type_argument_type, position, source);
20922     position += type.width;
20923     return new ReifiedTypeArgument(
20924         reified,
20925         type);
20926   }
20927   get children_keys()
20928   {
20929     if (ReifiedTypeArgument._children_keys == null)
20930       ReifiedTypeArgument._children_keys = [
20931         'reified',
20932         'type'];
20933     return ReifiedTypeArgument._children_keys;
20934   }
20935 }
20936 class TypeArguments extends EditableSyntax
20937 {
20938   constructor(
20939     left_angle,
20940     types,
20941     right_angle)
20942   {
20943     super('type_arguments', {
20944       left_angle: left_angle,
20945       types: types,
20946       right_angle: right_angle });
20947   }
20948   get left_angle() { return this.children.left_angle; }
20949   get types() { return this.children.types; }
20950   get right_angle() { return this.children.right_angle; }
20951   with_left_angle(left_angle){
20952     return new TypeArguments(
20953       left_angle,
20954       this.types,
20955       this.right_angle);
20956   }
20957   with_types(types){
20958     return new TypeArguments(
20959       this.left_angle,
20960       types,
20961       this.right_angle);
20962   }
20963   with_right_angle(right_angle){
20964     return new TypeArguments(
20965       this.left_angle,
20966       this.types,
20967       right_angle);
20968   }
20969   rewrite(rewriter, parents)
20970   {
20971     if (parents == undefined)
20972       parents = [];
20973     let new_parents = parents.slice();
20974     new_parents.push(this);
20975     var left_angle = this.left_angle.rewrite(rewriter, new_parents);
20976     var types = this.types.rewrite(rewriter, new_parents);
20977     var right_angle = this.right_angle.rewrite(rewriter, new_parents);
20978     if (
20979       left_angle === this.left_angle &&
20980       types === this.types &&
20981       right_angle === this.right_angle)
20982     {
20983       return rewriter(this, parents);
20984     }
20985     else
20986     {
20987       return rewriter(new TypeArguments(
20988         left_angle,
20989         types,
20990         right_angle), parents);
20991     }
20992   }
20993   static from_json(json, position, source)
20994   {
20995     let left_angle = EditableSyntax.from_json(
20996       json.type_arguments_left_angle, position, source);
20997     position += left_angle.width;
20998     let types = EditableSyntax.from_json(
20999       json.type_arguments_types, position, source);
21000     position += types.width;
21001     let right_angle = EditableSyntax.from_json(
21002       json.type_arguments_right_angle, position, source);
21003     position += right_angle.width;
21004     return new TypeArguments(
21005         left_angle,
21006         types,
21007         right_angle);
21008   }
21009   get children_keys()
21010   {
21011     if (TypeArguments._children_keys == null)
21012       TypeArguments._children_keys = [
21013         'left_angle',
21014         'types',
21015         'right_angle'];
21016     return TypeArguments._children_keys;
21017   }
21018 }
21019 class TypeParameters extends EditableSyntax
21020 {
21021   constructor(
21022     left_angle,
21023     parameters,
21024     right_angle)
21025   {
21026     super('type_parameters', {
21027       left_angle: left_angle,
21028       parameters: parameters,
21029       right_angle: right_angle });
21030   }
21031   get left_angle() { return this.children.left_angle; }
21032   get parameters() { return this.children.parameters; }
21033   get right_angle() { return this.children.right_angle; }
21034   with_left_angle(left_angle){
21035     return new TypeParameters(
21036       left_angle,
21037       this.parameters,
21038       this.right_angle);
21039   }
21040   with_parameters(parameters){
21041     return new TypeParameters(
21042       this.left_angle,
21043       parameters,
21044       this.right_angle);
21045   }
21046   with_right_angle(right_angle){
21047     return new TypeParameters(
21048       this.left_angle,
21049       this.parameters,
21050       right_angle);
21051   }
21052   rewrite(rewriter, parents)
21053   {
21054     if (parents == undefined)
21055       parents = [];
21056     let new_parents = parents.slice();
21057     new_parents.push(this);
21058     var left_angle = this.left_angle.rewrite(rewriter, new_parents);
21059     var parameters = this.parameters.rewrite(rewriter, new_parents);
21060     var right_angle = this.right_angle.rewrite(rewriter, new_parents);
21061     if (
21062       left_angle === this.left_angle &&
21063       parameters === this.parameters &&
21064       right_angle === this.right_angle)
21065     {
21066       return rewriter(this, parents);
21067     }
21068     else
21069     {
21070       return rewriter(new TypeParameters(
21071         left_angle,
21072         parameters,
21073         right_angle), parents);
21074     }
21075   }
21076   static from_json(json, position, source)
21077   {
21078     let left_angle = EditableSyntax.from_json(
21079       json.type_parameters_left_angle, position, source);
21080     position += left_angle.width;
21081     let parameters = EditableSyntax.from_json(
21082       json.type_parameters_parameters, position, source);
21083     position += parameters.width;
21084     let right_angle = EditableSyntax.from_json(
21085       json.type_parameters_right_angle, position, source);
21086     position += right_angle.width;
21087     return new TypeParameters(
21088         left_angle,
21089         parameters,
21090         right_angle);
21091   }
21092   get children_keys()
21093   {
21094     if (TypeParameters._children_keys == null)
21095       TypeParameters._children_keys = [
21096         'left_angle',
21097         'parameters',
21098         'right_angle'];
21099     return TypeParameters._children_keys;
21100   }
21101 }
21102 class TupleTypeSpecifier extends EditableSyntax
21103 {
21104   constructor(
21105     left_paren,
21106     types,
21107     right_paren)
21108   {
21109     super('tuple_type_specifier', {
21110       left_paren: left_paren,
21111       types: types,
21112       right_paren: right_paren });
21113   }
21114   get left_paren() { return this.children.left_paren; }
21115   get types() { return this.children.types; }
21116   get right_paren() { return this.children.right_paren; }
21117   with_left_paren(left_paren){
21118     return new TupleTypeSpecifier(
21119       left_paren,
21120       this.types,
21121       this.right_paren);
21122   }
21123   with_types(types){
21124     return new TupleTypeSpecifier(
21125       this.left_paren,
21126       types,
21127       this.right_paren);
21128   }
21129   with_right_paren(right_paren){
21130     return new TupleTypeSpecifier(
21131       this.left_paren,
21132       this.types,
21133       right_paren);
21134   }
21135   rewrite(rewriter, parents)
21136   {
21137     if (parents == undefined)
21138       parents = [];
21139     let new_parents = parents.slice();
21140     new_parents.push(this);
21141     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
21142     var types = this.types.rewrite(rewriter, new_parents);
21143     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
21144     if (
21145       left_paren === this.left_paren &&
21146       types === this.types &&
21147       right_paren === this.right_paren)
21148     {
21149       return rewriter(this, parents);
21150     }
21151     else
21152     {
21153       return rewriter(new TupleTypeSpecifier(
21154         left_paren,
21155         types,
21156         right_paren), parents);
21157     }
21158   }
21159   static from_json(json, position, source)
21160   {
21161     let left_paren = EditableSyntax.from_json(
21162       json.tuple_left_paren, position, source);
21163     position += left_paren.width;
21164     let types = EditableSyntax.from_json(
21165       json.tuple_types, position, source);
21166     position += types.width;
21167     let right_paren = EditableSyntax.from_json(
21168       json.tuple_right_paren, position, source);
21169     position += right_paren.width;
21170     return new TupleTypeSpecifier(
21171         left_paren,
21172         types,
21173         right_paren);
21174   }
21175   get children_keys()
21176   {
21177     if (TupleTypeSpecifier._children_keys == null)
21178       TupleTypeSpecifier._children_keys = [
21179         'left_paren',
21180         'types',
21181         'right_paren'];
21182     return TupleTypeSpecifier._children_keys;
21183   }
21184 }
21185 class ErrorSyntax extends EditableSyntax
21186 {
21187   constructor(
21188     error)
21189   {
21190     super('error', {
21191       error: error });
21192   }
21193   get error() { return this.children.error; }
21194   with_error(error){
21195     return new ErrorSyntax(
21196       error);
21197   }
21198   rewrite(rewriter, parents)
21199   {
21200     if (parents == undefined)
21201       parents = [];
21202     let new_parents = parents.slice();
21203     new_parents.push(this);
21204     var error = this.error.rewrite(rewriter, new_parents);
21205     if (
21206       error === this.error)
21207     {
21208       return rewriter(this, parents);
21209     }
21210     else
21211     {
21212       return rewriter(new ErrorSyntax(
21213         error), parents);
21214     }
21215   }
21216   static from_json(json, position, source)
21217   {
21218     let error = EditableSyntax.from_json(
21219       json.error_error, position, source);
21220     position += error.width;
21221     return new ErrorSyntax(
21222         error);
21223   }
21224   get children_keys()
21225   {
21226     if (ErrorSyntax._children_keys == null)
21227       ErrorSyntax._children_keys = [
21228         'error'];
21229     return ErrorSyntax._children_keys;
21230   }
21231 }
21232 class ListItem extends EditableSyntax
21233 {
21234   constructor(
21235     item,
21236     separator)
21237   {
21238     super('list_item', {
21239       item: item,
21240       separator: separator });
21241   }
21242   get item() { return this.children.item; }
21243   get separator() { return this.children.separator; }
21244   with_item(item){
21245     return new ListItem(
21246       item,
21247       this.separator);
21248   }
21249   with_separator(separator){
21250     return new ListItem(
21251       this.item,
21252       separator);
21253   }
21254   rewrite(rewriter, parents)
21255   {
21256     if (parents == undefined)
21257       parents = [];
21258     let new_parents = parents.slice();
21259     new_parents.push(this);
21260     var item = this.item.rewrite(rewriter, new_parents);
21261     var separator = this.separator.rewrite(rewriter, new_parents);
21262     if (
21263       item === this.item &&
21264       separator === this.separator)
21265     {
21266       return rewriter(this, parents);
21267     }
21268     else
21269     {
21270       return rewriter(new ListItem(
21271         item,
21272         separator), parents);
21273     }
21274   }
21275   static from_json(json, position, source)
21276   {
21277     let item = EditableSyntax.from_json(
21278       json.list_item, position, source);
21279     position += item.width;
21280     let separator = EditableSyntax.from_json(
21281       json.list_separator, position, source);
21282     position += separator.width;
21283     return new ListItem(
21284         item,
21285         separator);
21286   }
21287   get children_keys()
21288   {
21289     if (ListItem._children_keys == null)
21290       ListItem._children_keys = [
21291         'item',
21292         'separator'];
21293     return ListItem._children_keys;
21294   }
21295 }
21296 class PocketAtomExpression extends EditableSyntax
21297 {
21298   constructor(
21299     glyph,
21300     expression)
21301   {
21302     super('pocket_atom', {
21303       glyph: glyph,
21304       expression: expression });
21305   }
21306   get glyph() { return this.children.glyph; }
21307   get expression() { return this.children.expression; }
21308   with_glyph(glyph){
21309     return new PocketAtomExpression(
21310       glyph,
21311       this.expression);
21312   }
21313   with_expression(expression){
21314     return new PocketAtomExpression(
21315       this.glyph,
21316       expression);
21317   }
21318   rewrite(rewriter, parents)
21319   {
21320     if (parents == undefined)
21321       parents = [];
21322     let new_parents = parents.slice();
21323     new_parents.push(this);
21324     var glyph = this.glyph.rewrite(rewriter, new_parents);
21325     var expression = this.expression.rewrite(rewriter, new_parents);
21326     if (
21327       glyph === this.glyph &&
21328       expression === this.expression)
21329     {
21330       return rewriter(this, parents);
21331     }
21332     else
21333     {
21334       return rewriter(new PocketAtomExpression(
21335         glyph,
21336         expression), parents);
21337     }
21338   }
21339   static from_json(json, position, source)
21340   {
21341     let glyph = EditableSyntax.from_json(
21342       json.pocket_atom_glyph, position, source);
21343     position += glyph.width;
21344     let expression = EditableSyntax.from_json(
21345       json.pocket_atom_expression, position, source);
21346     position += expression.width;
21347     return new PocketAtomExpression(
21348         glyph,
21349         expression);
21350   }
21351   get children_keys()
21352   {
21353     if (PocketAtomExpression._children_keys == null)
21354       PocketAtomExpression._children_keys = [
21355         'glyph',
21356         'expression'];
21357     return PocketAtomExpression._children_keys;
21358   }
21359 }
21360 class PocketIdentifierExpression extends EditableSyntax
21361 {
21362   constructor(
21363     qualifier,
21364     pu_operator,
21365     field,
21366     operator,
21367     name)
21368   {
21369     super('pocket_identifier', {
21370       qualifier: qualifier,
21371       pu_operator: pu_operator,
21372       field: field,
21373       operator: operator,
21374       name: name });
21375   }
21376   get qualifier() { return this.children.qualifier; }
21377   get pu_operator() { return this.children.pu_operator; }
21378   get field() { return this.children.field; }
21379   get operator() { return this.children.operator; }
21380   get name() { return this.children.name; }
21381   with_qualifier(qualifier){
21382     return new PocketIdentifierExpression(
21383       qualifier,
21384       this.pu_operator,
21385       this.field,
21386       this.operator,
21387       this.name);
21388   }
21389   with_pu_operator(pu_operator){
21390     return new PocketIdentifierExpression(
21391       this.qualifier,
21392       pu_operator,
21393       this.field,
21394       this.operator,
21395       this.name);
21396   }
21397   with_field(field){
21398     return new PocketIdentifierExpression(
21399       this.qualifier,
21400       this.pu_operator,
21401       field,
21402       this.operator,
21403       this.name);
21404   }
21405   with_operator(operator){
21406     return new PocketIdentifierExpression(
21407       this.qualifier,
21408       this.pu_operator,
21409       this.field,
21410       operator,
21411       this.name);
21412   }
21413   with_name(name){
21414     return new PocketIdentifierExpression(
21415       this.qualifier,
21416       this.pu_operator,
21417       this.field,
21418       this.operator,
21419       name);
21420   }
21421   rewrite(rewriter, parents)
21422   {
21423     if (parents == undefined)
21424       parents = [];
21425     let new_parents = parents.slice();
21426     new_parents.push(this);
21427     var qualifier = this.qualifier.rewrite(rewriter, new_parents);
21428     var pu_operator = this.pu_operator.rewrite(rewriter, new_parents);
21429     var field = this.field.rewrite(rewriter, new_parents);
21430     var operator = this.operator.rewrite(rewriter, new_parents);
21431     var name = this.name.rewrite(rewriter, new_parents);
21432     if (
21433       qualifier === this.qualifier &&
21434       pu_operator === this.pu_operator &&
21435       field === this.field &&
21436       operator === this.operator &&
21437       name === this.name)
21438     {
21439       return rewriter(this, parents);
21440     }
21441     else
21442     {
21443       return rewriter(new PocketIdentifierExpression(
21444         qualifier,
21445         pu_operator,
21446         field,
21447         operator,
21448         name), parents);
21449     }
21450   }
21451   static from_json(json, position, source)
21452   {
21453     let qualifier = EditableSyntax.from_json(
21454       json.pocket_identifier_qualifier, position, source);
21455     position += qualifier.width;
21456     let pu_operator = EditableSyntax.from_json(
21457       json.pocket_identifier_pu_operator, position, source);
21458     position += pu_operator.width;
21459     let field = EditableSyntax.from_json(
21460       json.pocket_identifier_field, position, source);
21461     position += field.width;
21462     let operator = EditableSyntax.from_json(
21463       json.pocket_identifier_operator, position, source);
21464     position += operator.width;
21465     let name = EditableSyntax.from_json(
21466       json.pocket_identifier_name, position, source);
21467     position += name.width;
21468     return new PocketIdentifierExpression(
21469         qualifier,
21470         pu_operator,
21471         field,
21472         operator,
21473         name);
21474   }
21475   get children_keys()
21476   {
21477     if (PocketIdentifierExpression._children_keys == null)
21478       PocketIdentifierExpression._children_keys = [
21479         'qualifier',
21480         'pu_operator',
21481         'field',
21482         'operator',
21483         'name'];
21484     return PocketIdentifierExpression._children_keys;
21485   }
21486 }
21487 class PocketAtomMappingDeclaration extends EditableSyntax
21488 {
21489   constructor(
21490     glyph,
21491     expression,
21492     left_paren,
21493     mappings,
21494     right_paren,
21495     semicolon)
21496   {
21497     super('pocket_atom_mapping', {
21498       glyph: glyph,
21499       expression: expression,
21500       left_paren: left_paren,
21501       mappings: mappings,
21502       right_paren: right_paren,
21503       semicolon: semicolon });
21504   }
21505   get glyph() { return this.children.glyph; }
21506   get expression() { return this.children.expression; }
21507   get left_paren() { return this.children.left_paren; }
21508   get mappings() { return this.children.mappings; }
21509   get right_paren() { return this.children.right_paren; }
21510   get semicolon() { return this.children.semicolon; }
21511   with_glyph(glyph){
21512     return new PocketAtomMappingDeclaration(
21513       glyph,
21514       this.expression,
21515       this.left_paren,
21516       this.mappings,
21517       this.right_paren,
21518       this.semicolon);
21519   }
21520   with_expression(expression){
21521     return new PocketAtomMappingDeclaration(
21522       this.glyph,
21523       expression,
21524       this.left_paren,
21525       this.mappings,
21526       this.right_paren,
21527       this.semicolon);
21528   }
21529   with_left_paren(left_paren){
21530     return new PocketAtomMappingDeclaration(
21531       this.glyph,
21532       this.expression,
21533       left_paren,
21534       this.mappings,
21535       this.right_paren,
21536       this.semicolon);
21537   }
21538   with_mappings(mappings){
21539     return new PocketAtomMappingDeclaration(
21540       this.glyph,
21541       this.expression,
21542       this.left_paren,
21543       mappings,
21544       this.right_paren,
21545       this.semicolon);
21546   }
21547   with_right_paren(right_paren){
21548     return new PocketAtomMappingDeclaration(
21549       this.glyph,
21550       this.expression,
21551       this.left_paren,
21552       this.mappings,
21553       right_paren,
21554       this.semicolon);
21555   }
21556   with_semicolon(semicolon){
21557     return new PocketAtomMappingDeclaration(
21558       this.glyph,
21559       this.expression,
21560       this.left_paren,
21561       this.mappings,
21562       this.right_paren,
21563       semicolon);
21564   }
21565   rewrite(rewriter, parents)
21566   {
21567     if (parents == undefined)
21568       parents = [];
21569     let new_parents = parents.slice();
21570     new_parents.push(this);
21571     var glyph = this.glyph.rewrite(rewriter, new_parents);
21572     var expression = this.expression.rewrite(rewriter, new_parents);
21573     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
21574     var mappings = this.mappings.rewrite(rewriter, new_parents);
21575     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
21576     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
21577     if (
21578       glyph === this.glyph &&
21579       expression === this.expression &&
21580       left_paren === this.left_paren &&
21581       mappings === this.mappings &&
21582       right_paren === this.right_paren &&
21583       semicolon === this.semicolon)
21584     {
21585       return rewriter(this, parents);
21586     }
21587     else
21588     {
21589       return rewriter(new PocketAtomMappingDeclaration(
21590         glyph,
21591         expression,
21592         left_paren,
21593         mappings,
21594         right_paren,
21595         semicolon), parents);
21596     }
21597   }
21598   static from_json(json, position, source)
21599   {
21600     let glyph = EditableSyntax.from_json(
21601       json.pocket_atom_mapping_glyph, position, source);
21602     position += glyph.width;
21603     let expression = EditableSyntax.from_json(
21604       json.pocket_atom_mapping_expression, position, source);
21605     position += expression.width;
21606     let left_paren = EditableSyntax.from_json(
21607       json.pocket_atom_mapping_left_paren, position, source);
21608     position += left_paren.width;
21609     let mappings = EditableSyntax.from_json(
21610       json.pocket_atom_mapping_mappings, position, source);
21611     position += mappings.width;
21612     let right_paren = EditableSyntax.from_json(
21613       json.pocket_atom_mapping_right_paren, position, source);
21614     position += right_paren.width;
21615     let semicolon = EditableSyntax.from_json(
21616       json.pocket_atom_mapping_semicolon, position, source);
21617     position += semicolon.width;
21618     return new PocketAtomMappingDeclaration(
21619         glyph,
21620         expression,
21621         left_paren,
21622         mappings,
21623         right_paren,
21624         semicolon);
21625   }
21626   get children_keys()
21627   {
21628     if (PocketAtomMappingDeclaration._children_keys == null)
21629       PocketAtomMappingDeclaration._children_keys = [
21630         'glyph',
21631         'expression',
21632         'left_paren',
21633         'mappings',
21634         'right_paren',
21635         'semicolon'];
21636     return PocketAtomMappingDeclaration._children_keys;
21637   }
21638 }
21639 class PocketEnumDeclaration extends EditableSyntax
21640 {
21641   constructor(
21642     modifiers,
21643     enum,
21644     name,
21645     left_brace,
21646     fields,
21647     right_brace)
21648   {
21649     super('pocket_enum_declaration', {
21650       modifiers: modifiers,
21651       enum: enum,
21652       name: name,
21653       left_brace: left_brace,
21654       fields: fields,
21655       right_brace: right_brace });
21656   }
21657   get modifiers() { return this.children.modifiers; }
21658   get enum() { return this.children.enum; }
21659   get name() { return this.children.name; }
21660   get left_brace() { return this.children.left_brace; }
21661   get fields() { return this.children.fields; }
21662   get right_brace() { return this.children.right_brace; }
21663   with_modifiers(modifiers){
21664     return new PocketEnumDeclaration(
21665       modifiers,
21666       this.enum,
21667       this.name,
21668       this.left_brace,
21669       this.fields,
21670       this.right_brace);
21671   }
21672   with_enum(enum){
21673     return new PocketEnumDeclaration(
21674       this.modifiers,
21675       enum,
21676       this.name,
21677       this.left_brace,
21678       this.fields,
21679       this.right_brace);
21680   }
21681   with_name(name){
21682     return new PocketEnumDeclaration(
21683       this.modifiers,
21684       this.enum,
21685       name,
21686       this.left_brace,
21687       this.fields,
21688       this.right_brace);
21689   }
21690   with_left_brace(left_brace){
21691     return new PocketEnumDeclaration(
21692       this.modifiers,
21693       this.enum,
21694       this.name,
21695       left_brace,
21696       this.fields,
21697       this.right_brace);
21698   }
21699   with_fields(fields){
21700     return new PocketEnumDeclaration(
21701       this.modifiers,
21702       this.enum,
21703       this.name,
21704       this.left_brace,
21705       fields,
21706       this.right_brace);
21707   }
21708   with_right_brace(right_brace){
21709     return new PocketEnumDeclaration(
21710       this.modifiers,
21711       this.enum,
21712       this.name,
21713       this.left_brace,
21714       this.fields,
21715       right_brace);
21716   }
21717   rewrite(rewriter, parents)
21718   {
21719     if (parents == undefined)
21720       parents = [];
21721     let new_parents = parents.slice();
21722     new_parents.push(this);
21723     var modifiers = this.modifiers.rewrite(rewriter, new_parents);
21724     var enum = this.enum.rewrite(rewriter, new_parents);
21725     var name = this.name.rewrite(rewriter, new_parents);
21726     var left_brace = this.left_brace.rewrite(rewriter, new_parents);
21727     var fields = this.fields.rewrite(rewriter, new_parents);
21728     var right_brace = this.right_brace.rewrite(rewriter, new_parents);
21729     if (
21730       modifiers === this.modifiers &&
21731       enum === this.enum &&
21732       name === this.name &&
21733       left_brace === this.left_brace &&
21734       fields === this.fields &&
21735       right_brace === this.right_brace)
21736     {
21737       return rewriter(this, parents);
21738     }
21739     else
21740     {
21741       return rewriter(new PocketEnumDeclaration(
21742         modifiers,
21743         enum,
21744         name,
21745         left_brace,
21746         fields,
21747         right_brace), parents);
21748     }
21749   }
21750   static from_json(json, position, source)
21751   {
21752     let modifiers = EditableSyntax.from_json(
21753       json.pocket_enum_modifiers, position, source);
21754     position += modifiers.width;
21755     let enum = EditableSyntax.from_json(
21756       json.pocket_enum_enum, position, source);
21757     position += enum.width;
21758     let name = EditableSyntax.from_json(
21759       json.pocket_enum_name, position, source);
21760     position += name.width;
21761     let left_brace = EditableSyntax.from_json(
21762       json.pocket_enum_left_brace, position, source);
21763     position += left_brace.width;
21764     let fields = EditableSyntax.from_json(
21765       json.pocket_enum_fields, position, source);
21766     position += fields.width;
21767     let right_brace = EditableSyntax.from_json(
21768       json.pocket_enum_right_brace, position, source);
21769     position += right_brace.width;
21770     return new PocketEnumDeclaration(
21771         modifiers,
21772         enum,
21773         name,
21774         left_brace,
21775         fields,
21776         right_brace);
21777   }
21778   get children_keys()
21779   {
21780     if (PocketEnumDeclaration._children_keys == null)
21781       PocketEnumDeclaration._children_keys = [
21782         'modifiers',
21783         'enum',
21784         'name',
21785         'left_brace',
21786         'fields',
21787         'right_brace'];
21788     return PocketEnumDeclaration._children_keys;
21789   }
21790 }
21791 class PocketFieldTypeExprDeclaration extends EditableSyntax
21792 {
21793   constructor(
21794     case,
21795     type,
21796     name,
21797     semicolon)
21798   {
21799     super('pocket_field_type_expr_declaration', {
21800       case: case,
21801       type: type,
21802       name: name,
21803       semicolon: semicolon });
21804   }
21805   get case() { return this.children.case; }
21806   get type() { return this.children.type; }
21807   get name() { return this.children.name; }
21808   get semicolon() { return this.children.semicolon; }
21809   with_case(case){
21810     return new PocketFieldTypeExprDeclaration(
21811       case,
21812       this.type,
21813       this.name,
21814       this.semicolon);
21815   }
21816   with_type(type){
21817     return new PocketFieldTypeExprDeclaration(
21818       this.case,
21819       type,
21820       this.name,
21821       this.semicolon);
21822   }
21823   with_name(name){
21824     return new PocketFieldTypeExprDeclaration(
21825       this.case,
21826       this.type,
21827       name,
21828       this.semicolon);
21829   }
21830   with_semicolon(semicolon){
21831     return new PocketFieldTypeExprDeclaration(
21832       this.case,
21833       this.type,
21834       this.name,
21835       semicolon);
21836   }
21837   rewrite(rewriter, parents)
21838   {
21839     if (parents == undefined)
21840       parents = [];
21841     let new_parents = parents.slice();
21842     new_parents.push(this);
21843     var case = this.case.rewrite(rewriter, new_parents);
21844     var type = this.type.rewrite(rewriter, new_parents);
21845     var name = this.name.rewrite(rewriter, new_parents);
21846     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
21847     if (
21848       case === this.case &&
21849       type === this.type &&
21850       name === this.name &&
21851       semicolon === this.semicolon)
21852     {
21853       return rewriter(this, parents);
21854     }
21855     else
21856     {
21857       return rewriter(new PocketFieldTypeExprDeclaration(
21858         case,
21859         type,
21860         name,
21861         semicolon), parents);
21862     }
21863   }
21864   static from_json(json, position, source)
21865   {
21866     let case = EditableSyntax.from_json(
21867       json.pocket_field_type_expr_case, position, source);
21868     position += case.width;
21869     let type = EditableSyntax.from_json(
21870       json.pocket_field_type_expr_type, position, source);
21871     position += type.width;
21872     let name = EditableSyntax.from_json(
21873       json.pocket_field_type_expr_name, position, source);
21874     position += name.width;
21875     let semicolon = EditableSyntax.from_json(
21876       json.pocket_field_type_expr_semicolon, position, source);
21877     position += semicolon.width;
21878     return new PocketFieldTypeExprDeclaration(
21879         case,
21880         type,
21881         name,
21882         semicolon);
21883   }
21884   get children_keys()
21885   {
21886     if (PocketFieldTypeExprDeclaration._children_keys == null)
21887       PocketFieldTypeExprDeclaration._children_keys = [
21888         'case',
21889         'type',
21890         'name',
21891         'semicolon'];
21892     return PocketFieldTypeExprDeclaration._children_keys;
21893   }
21894 }
21895 class PocketFieldTypeDeclaration extends EditableSyntax
21896 {
21897   constructor(
21898     case,
21899     type,
21900     name,
21901     semicolon)
21902   {
21903     super('pocket_field_type_declaration', {
21904       case: case,
21905       type: type,
21906       name: name,
21907       semicolon: semicolon });
21908   }
21909   get case() { return this.children.case; }
21910   get type() { return this.children.type; }
21911   get name() { return this.children.name; }
21912   get semicolon() { return this.children.semicolon; }
21913   with_case(case){
21914     return new PocketFieldTypeDeclaration(
21915       case,
21916       this.type,
21917       this.name,
21918       this.semicolon);
21919   }
21920   with_type(type){
21921     return new PocketFieldTypeDeclaration(
21922       this.case,
21923       type,
21924       this.name,
21925       this.semicolon);
21926   }
21927   with_name(name){
21928     return new PocketFieldTypeDeclaration(
21929       this.case,
21930       this.type,
21931       name,
21932       this.semicolon);
21933   }
21934   with_semicolon(semicolon){
21935     return new PocketFieldTypeDeclaration(
21936       this.case,
21937       this.type,
21938       this.name,
21939       semicolon);
21940   }
21941   rewrite(rewriter, parents)
21942   {
21943     if (parents == undefined)
21944       parents = [];
21945     let new_parents = parents.slice();
21946     new_parents.push(this);
21947     var case = this.case.rewrite(rewriter, new_parents);
21948     var type = this.type.rewrite(rewriter, new_parents);
21949     var name = this.name.rewrite(rewriter, new_parents);
21950     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
21951     if (
21952       case === this.case &&
21953       type === this.type &&
21954       name === this.name &&
21955       semicolon === this.semicolon)
21956     {
21957       return rewriter(this, parents);
21958     }
21959     else
21960     {
21961       return rewriter(new PocketFieldTypeDeclaration(
21962         case,
21963         type,
21964         name,
21965         semicolon), parents);
21966     }
21967   }
21968   static from_json(json, position, source)
21969   {
21970     let case = EditableSyntax.from_json(
21971       json.pocket_field_type_case, position, source);
21972     position += case.width;
21973     let type = EditableSyntax.from_json(
21974       json.pocket_field_type_type, position, source);
21975     position += type.width;
21976     let name = EditableSyntax.from_json(
21977       json.pocket_field_type_name, position, source);
21978     position += name.width;
21979     let semicolon = EditableSyntax.from_json(
21980       json.pocket_field_type_semicolon, position, source);
21981     position += semicolon.width;
21982     return new PocketFieldTypeDeclaration(
21983         case,
21984         type,
21985         name,
21986         semicolon);
21987   }
21988   get children_keys()
21989   {
21990     if (PocketFieldTypeDeclaration._children_keys == null)
21991       PocketFieldTypeDeclaration._children_keys = [
21992         'case',
21993         'type',
21994         'name',
21995         'semicolon'];
21996     return PocketFieldTypeDeclaration._children_keys;
21997   }
21998 }
21999 class PocketMappingIdDeclaration extends EditableSyntax
22000 {
22001   constructor(
22002     name,
22003     initializer)
22004   {
22005     super('pocket_mapping_id_declaration', {
22006       name: name,
22007       initializer: initializer });
22008   }
22009   get name() { return this.children.name; }
22010   get initializer() { return this.children.initializer; }
22011   with_name(name){
22012     return new PocketMappingIdDeclaration(
22013       name,
22014       this.initializer);
22015   }
22016   with_initializer(initializer){
22017     return new PocketMappingIdDeclaration(
22018       this.name,
22019       initializer);
22020   }
22021   rewrite(rewriter, parents)
22022   {
22023     if (parents == undefined)
22024       parents = [];
22025     let new_parents = parents.slice();
22026     new_parents.push(this);
22027     var name = this.name.rewrite(rewriter, new_parents);
22028     var initializer = this.initializer.rewrite(rewriter, new_parents);
22029     if (
22030       name === this.name &&
22031       initializer === this.initializer)
22032     {
22033       return rewriter(this, parents);
22034     }
22035     else
22036     {
22037       return rewriter(new PocketMappingIdDeclaration(
22038         name,
22039         initializer), parents);
22040     }
22041   }
22042   static from_json(json, position, source)
22043   {
22044     let name = EditableSyntax.from_json(
22045       json.pocket_mapping_id_name, position, source);
22046     position += name.width;
22047     let initializer = EditableSyntax.from_json(
22048       json.pocket_mapping_id_initializer, position, source);
22049     position += initializer.width;
22050     return new PocketMappingIdDeclaration(
22051         name,
22052         initializer);
22053   }
22054   get children_keys()
22055   {
22056     if (PocketMappingIdDeclaration._children_keys == null)
22057       PocketMappingIdDeclaration._children_keys = [
22058         'name',
22059         'initializer'];
22060     return PocketMappingIdDeclaration._children_keys;
22061   }
22062 }
22063 class PocketMappingTypeDeclaration extends EditableSyntax
22064 {
22065   constructor(
22066     keyword,
22067     name,
22068     equal,
22069     type)
22070   {
22071     super('pocket_mapping_type_declaration', {
22072       keyword: keyword,
22073       name: name,
22074       equal: equal,
22075       type: type });
22076   }
22077   get keyword() { return this.children.keyword; }
22078   get name() { return this.children.name; }
22079   get equal() { return this.children.equal; }
22080   get type() { return this.children.type; }
22081   with_keyword(keyword){
22082     return new PocketMappingTypeDeclaration(
22083       keyword,
22084       this.name,
22085       this.equal,
22086       this.type);
22087   }
22088   with_name(name){
22089     return new PocketMappingTypeDeclaration(
22090       this.keyword,
22091       name,
22092       this.equal,
22093       this.type);
22094   }
22095   with_equal(equal){
22096     return new PocketMappingTypeDeclaration(
22097       this.keyword,
22098       this.name,
22099       equal,
22100       this.type);
22101   }
22102   with_type(type){
22103     return new PocketMappingTypeDeclaration(
22104       this.keyword,
22105       this.name,
22106       this.equal,
22107       type);
22108   }
22109   rewrite(rewriter, parents)
22110   {
22111     if (parents == undefined)
22112       parents = [];
22113     let new_parents = parents.slice();
22114     new_parents.push(this);
22115     var keyword = this.keyword.rewrite(rewriter, new_parents);
22116     var name = this.name.rewrite(rewriter, new_parents);
22117     var equal = this.equal.rewrite(rewriter, new_parents);
22118     var type = this.type.rewrite(rewriter, new_parents);
22119     if (
22120       keyword === this.keyword &&
22121       name === this.name &&
22122       equal === this.equal &&
22123       type === this.type)
22124     {
22125       return rewriter(this, parents);
22126     }
22127     else
22128     {
22129       return rewriter(new PocketMappingTypeDeclaration(
22130         keyword,
22131         name,
22132         equal,
22133         type), parents);
22134     }
22135   }
22136   static from_json(json, position, source)
22137   {
22138     let keyword = EditableSyntax.from_json(
22139       json.pocket_mapping_type_keyword, position, source);
22140     position += keyword.width;
22141     let name = EditableSyntax.from_json(
22142       json.pocket_mapping_type_name, position, source);
22143     position += name.width;
22144     let equal = EditableSyntax.from_json(
22145       json.pocket_mapping_type_equal, position, source);
22146     position += equal.width;
22147     let type = EditableSyntax.from_json(
22148       json.pocket_mapping_type_type, position, source);
22149     position += type.width;
22150     return new PocketMappingTypeDeclaration(
22151         keyword,
22152         name,
22153         equal,
22154         type);
22155   }
22156   get children_keys()
22157   {
22158     if (PocketMappingTypeDeclaration._children_keys == null)
22159       PocketMappingTypeDeclaration._children_keys = [
22160         'keyword',
22161         'name',
22162         'equal',
22163         'type'];
22164     return PocketMappingTypeDeclaration._children_keys;
22165   }
22166 }
22167
22168
22169 function from_json(json)
22170 {
22171   return EditableSyntax.from_json(json.parse_tree, 0, json.program_text);
22172 }
22173
22174 exports.from_json = from_json;
22175 exports.EditableSyntax = EditableSyntax;
22176 exports.EditableList = EditableList;
22177 exports.EditableToken = EditableToken;
22178 exports.EndOfFileToken = EndOfFileToken;
22179
22180 exports.AbstractToken = AbstractToken;
22181 exports.AndToken = AndToken;
22182 exports.ArrayToken = ArrayToken;
22183 exports.ArraykeyToken = ArraykeyToken;
22184 exports.AsToken = AsToken;
22185 exports.AsyncToken = AsyncToken;
22186 exports.AttributeToken = AttributeToken;
22187 exports.AwaitToken = AwaitToken;
22188 exports.BackslashToken = BackslashToken;
22189 exports.BinaryToken = BinaryToken;
22190 exports.BoolToken = BoolToken;
22191 exports.BooleanToken = BooleanToken;
22192 exports.BreakToken = BreakToken;
22193 exports.CaseToken = CaseToken;
22194 exports.CatchToken = CatchToken;
22195 exports.CategoryToken = CategoryToken;
22196 exports.ChildrenToken = ChildrenToken;
22197 exports.ClassToken = ClassToken;
22198 exports.ClassnameToken = ClassnameToken;
22199 exports.CloneToken = CloneToken;
22200 exports.ConstToken = ConstToken;
22201 exports.ConstructToken = ConstructToken;
22202 exports.ContinueToken = ContinueToken;
22203 exports.CoroutineToken = CoroutineToken;
22204 exports.DarrayToken = DarrayToken;
22205 exports.DeclareToken = DeclareToken;
22206 exports.DefaultToken = DefaultToken;
22207 exports.DefineToken = DefineToken;
22208 exports.DestructToken = DestructToken;
22209 exports.DictToken = DictToken;
22210 exports.DoToken = DoToken;
22211 exports.DoubleToken = DoubleToken;
22212 exports.EchoToken = EchoToken;
22213 exports.ElseToken = ElseToken;
22214 exports.ElseifToken = ElseifToken;
22215 exports.EmptyToken = EmptyToken;
22216 exports.EndforToken = EndforToken;
22217 exports.EndforeachToken = EndforeachToken;
22218 exports.EnddeclareToken = EnddeclareToken;
22219 exports.EndifToken = EndifToken;
22220 exports.EndswitchToken = EndswitchToken;
22221 exports.EndwhileToken = EndwhileToken;
22222 exports.EnumToken = EnumToken;
22223 exports.EvalToken = EvalToken;
22224 exports.ExtendsToken = ExtendsToken;
22225 exports.FallthroughToken = FallthroughToken;
22226 exports.FloatToken = FloatToken;
22227 exports.FileToken = FileToken;
22228 exports.FinalToken = FinalToken;
22229 exports.FinallyToken = FinallyToken;
22230 exports.ForToken = ForToken;
22231 exports.ForeachToken = ForeachToken;
22232 exports.FromToken = FromToken;
22233 exports.FunctionToken = FunctionToken;
22234 exports.GlobalToken = GlobalToken;
22235 exports.ConcurrentToken = ConcurrentToken;
22236 exports.GotoToken = GotoToken;
22237 exports.HaltCompilerToken = HaltCompilerToken;
22238 exports.IfToken = IfToken;
22239 exports.ImplementsToken = ImplementsToken;
22240 exports.IncludeToken = IncludeToken;
22241 exports.Include_onceToken = Include_onceToken;
22242 exports.InoutToken = InoutToken;
22243 exports.InstanceofToken = InstanceofToken;
22244 exports.InsteadofToken = InsteadofToken;
22245 exports.IntToken = IntToken;
22246 exports.IntegerToken = IntegerToken;
22247 exports.InterfaceToken = InterfaceToken;
22248 exports.IsToken = IsToken;
22249 exports.IssetToken = IssetToken;
22250 exports.KeysetToken = KeysetToken;
22251 exports.LetToken = LetToken;
22252 exports.ListToken = ListToken;
22253 exports.MixedToken = MixedToken;
22254 exports.NamespaceToken = NamespaceToken;
22255 exports.NewToken = NewToken;
22256 exports.NewtypeToken = NewtypeToken;
22257 exports.NoreturnToken = NoreturnToken;
22258 exports.NumToken = NumToken;
22259 exports.ObjectToken = ObjectToken;
22260 exports.OrToken = OrToken;
22261 exports.ParentToken = ParentToken;
22262 exports.PrintToken = PrintToken;
22263 exports.PrivateToken = PrivateToken;
22264 exports.ProtectedToken = ProtectedToken;
22265 exports.PublicToken = PublicToken;
22266 exports.RealToken = RealToken;
22267 exports.ReifyToken = ReifyToken;
22268 exports.RequireToken = RequireToken;
22269 exports.Require_onceToken = Require_onceToken;
22270 exports.RequiredToken = RequiredToken;
22271 exports.ResourceToken = ResourceToken;
22272 exports.ReturnToken = ReturnToken;
22273 exports.SelfToken = SelfToken;
22274 exports.ShapeToken = ShapeToken;
22275 exports.StaticToken = StaticToken;
22276 exports.StringToken = StringToken;
22277 exports.SuperToken = SuperToken;
22278 exports.SuspendToken = SuspendToken;
22279 exports.SwitchToken = SwitchToken;
22280 exports.ThisToken = ThisToken;
22281 exports.ThrowToken = ThrowToken;
22282 exports.TraitToken = TraitToken;
22283 exports.TryToken = TryToken;
22284 exports.TupleToken = TupleToken;
22285 exports.TypeToken = TypeToken;
22286 exports.UnsetToken = UnsetToken;
22287 exports.UseToken = UseToken;
22288 exports.UsingToken = UsingToken;
22289 exports.VarToken = VarToken;
22290 exports.VarrayToken = VarrayToken;
22291 exports.VecToken = VecToken;
22292 exports.VoidToken = VoidToken;
22293 exports.WhereToken = WhereToken;
22294 exports.WhileToken = WhileToken;
22295 exports.XorToken = XorToken;
22296 exports.YieldToken = YieldToken;
22297 exports.NullLiteralToken = NullLiteralToken;
22298 exports.LeftBracketToken = LeftBracketToken;
22299 exports.RightBracketToken = RightBracketToken;
22300 exports.LeftParenToken = LeftParenToken;
22301 exports.RightParenToken = RightParenToken;
22302 exports.LeftBraceToken = LeftBraceToken;
22303 exports.RightBraceToken = RightBraceToken;
22304 exports.DotToken = DotToken;
22305 exports.MinusGreaterThanToken = MinusGreaterThanToken;
22306 exports.PlusPlusToken = PlusPlusToken;
22307 exports.MinusMinusToken = MinusMinusToken;
22308 exports.StarStarToken = StarStarToken;
22309 exports.StarToken = StarToken;
22310 exports.PlusToken = PlusToken;
22311 exports.MinusToken = MinusToken;
22312 exports.TildeToken = TildeToken;
22313 exports.ExclamationToken = ExclamationToken;
22314 exports.DollarToken = DollarToken;
22315 exports.SlashToken = SlashToken;
22316 exports.PercentToken = PercentToken;
22317 exports.LessThanGreaterThanToken = LessThanGreaterThanToken;
22318 exports.LessThanEqualGreaterThanToken = LessThanEqualGreaterThanToken;
22319 exports.LessThanLessThanToken = LessThanLessThanToken;
22320 exports.GreaterThanGreaterThanToken = GreaterThanGreaterThanToken;
22321 exports.LessThanToken = LessThanToken;
22322 exports.GreaterThanToken = GreaterThanToken;
22323 exports.LessThanEqualToken = LessThanEqualToken;
22324 exports.GreaterThanEqualToken = GreaterThanEqualToken;
22325 exports.EqualEqualToken = EqualEqualToken;
22326 exports.EqualEqualEqualToken = EqualEqualEqualToken;
22327 exports.ExclamationEqualToken = ExclamationEqualToken;
22328 exports.ExclamationEqualEqualToken = ExclamationEqualEqualToken;
22329 exports.CaratToken = CaratToken;
22330 exports.BarToken = BarToken;
22331 exports.AmpersandToken = AmpersandToken;
22332 exports.AmpersandAmpersandToken = AmpersandAmpersandToken;
22333 exports.BarBarToken = BarBarToken;
22334 exports.QuestionToken = QuestionToken;
22335 exports.QuestionAsToken = QuestionAsToken;
22336 exports.QuestionColonToken = QuestionColonToken;
22337 exports.QuestionQuestionToken = QuestionQuestionToken;
22338 exports.QuestionQuestionEqualToken = QuestionQuestionEqualToken;
22339 exports.ColonToken = ColonToken;
22340 exports.SemicolonToken = SemicolonToken;
22341 exports.EqualToken = EqualToken;
22342 exports.StarStarEqualToken = StarStarEqualToken;
22343 exports.StarEqualToken = StarEqualToken;
22344 exports.SlashEqualToken = SlashEqualToken;
22345 exports.PercentEqualToken = PercentEqualToken;
22346 exports.PlusEqualToken = PlusEqualToken;
22347 exports.MinusEqualToken = MinusEqualToken;
22348 exports.DotEqualToken = DotEqualToken;
22349 exports.LessThanLessThanEqualToken = LessThanLessThanEqualToken;
22350 exports.GreaterThanGreaterThanEqualToken = GreaterThanGreaterThanEqualToken;
22351 exports.AmpersandEqualToken = AmpersandEqualToken;
22352 exports.CaratEqualToken = CaratEqualToken;
22353 exports.BarEqualToken = BarEqualToken;
22354 exports.CommaToken = CommaToken;
22355 exports.AtToken = AtToken;
22356 exports.ColonColonToken = ColonColonToken;
22357 exports.EqualGreaterThanToken = EqualGreaterThanToken;
22358 exports.EqualEqualGreaterThanToken = EqualEqualGreaterThanToken;
22359 exports.QuestionMinusGreaterThanToken = QuestionMinusGreaterThanToken;
22360 exports.DotDotDotToken = DotDotDotToken;
22361 exports.DollarDollarToken = DollarDollarToken;
22362 exports.BarGreaterThanToken = BarGreaterThanToken;
22363 exports.SlashGreaterThanToken = SlashGreaterThanToken;
22364 exports.LessThanSlashToken = LessThanSlashToken;
22365 exports.LessThanQuestionToken = LessThanQuestionToken;
22366 exports.QuestionGreaterThanToken = QuestionGreaterThanToken;
22367 exports.ColonAtToken = ColonAtToken;
22368
22369 exports.ErrorTokenToken = ErrorTokenToken;
22370 exports.NameToken = NameToken;
22371 exports.VariableToken = VariableToken;
22372 exports.DecimalLiteralToken = DecimalLiteralToken;
22373 exports.OctalLiteralToken = OctalLiteralToken;
22374 exports.HexadecimalLiteralToken = HexadecimalLiteralToken;
22375 exports.BinaryLiteralToken = BinaryLiteralToken;
22376 exports.FloatingLiteralToken = FloatingLiteralToken;
22377 exports.SingleQuotedStringLiteralToken = SingleQuotedStringLiteralToken;
22378 exports.DoubleQuotedStringLiteralToken = DoubleQuotedStringLiteralToken;
22379 exports.DoubleQuotedStringLiteralHeadToken = DoubleQuotedStringLiteralHeadToken;
22380 exports.StringLiteralBodyToken = StringLiteralBodyToken;
22381 exports.DoubleQuotedStringLiteralTailToken = DoubleQuotedStringLiteralTailToken;
22382 exports.HeredocStringLiteralToken = HeredocStringLiteralToken;
22383 exports.HeredocStringLiteralHeadToken = HeredocStringLiteralHeadToken;
22384 exports.HeredocStringLiteralTailToken = HeredocStringLiteralTailToken;
22385 exports.NowdocStringLiteralToken = NowdocStringLiteralToken;
22386 exports.BooleanLiteralToken = BooleanLiteralToken;
22387 exports.XHPCategoryNameToken = XHPCategoryNameToken;
22388 exports.XHPElementNameToken = XHPElementNameToken;
22389 exports.XHPClassNameToken = XHPClassNameToken;
22390 exports.XHPStringLiteralToken = XHPStringLiteralToken;
22391 exports.XHPBodyToken = XHPBodyToken;
22392 exports.XHPCommentToken = XHPCommentToken;
22393 exports.MarkupToken = MarkupToken;
22394
22395 exports.EditableTrivia = EditableTrivia;
22396 exports.WhiteSpace = WhiteSpace;
22397 exports.EndOfLine = EndOfLine;
22398 exports.DelimitedComment = DelimitedComment;
22399 exports.SingleLineComment = SingleLineComment;
22400 exports.Unsafe = Unsafe;
22401 exports.UnsafeExpression = UnsafeExpression;
22402 exports.FixMe = FixMe;
22403 exports.IgnoreError = IgnoreError;
22404 exports.FallThrough = FallThrough;
22405 exports.ExtraTokenError = ExtraTokenError;
22406 exports.AfterHaltCompiler = AfterHaltCompiler;
22407
22408 exports.EndOfFile = EndOfFile;
22409 exports.Script = Script;
22410 exports.QualifiedName = QualifiedName;
22411 exports.SimpleTypeSpecifier = SimpleTypeSpecifier;
22412 exports.LiteralExpression = LiteralExpression;
22413 exports.PrefixedStringExpression = PrefixedStringExpression;
22414 exports.VariableExpression = VariableExpression;
22415 exports.PipeVariableExpression = PipeVariableExpression;
22416 exports.FileAttributeSpecification = FileAttributeSpecification;
22417 exports.EnumDeclaration = EnumDeclaration;
22418 exports.Enumerator = Enumerator;
22419 exports.AliasDeclaration = AliasDeclaration;
22420 exports.PropertyDeclaration = PropertyDeclaration;
22421 exports.PropertyDeclarator = PropertyDeclarator;
22422 exports.NamespaceDeclaration = NamespaceDeclaration;
22423 exports.NamespaceBody = NamespaceBody;
22424 exports.NamespaceEmptyBody = NamespaceEmptyBody;
22425 exports.NamespaceUseDeclaration = NamespaceUseDeclaration;
22426 exports.NamespaceGroupUseDeclaration = NamespaceGroupUseDeclaration;
22427 exports.NamespaceUseClause = NamespaceUseClause;
22428 exports.FunctionDeclaration = FunctionDeclaration;
22429 exports.FunctionDeclarationHeader = FunctionDeclarationHeader;
22430 exports.WhereClause = WhereClause;
22431 exports.WhereConstraint = WhereConstraint;
22432 exports.MethodishDeclaration = MethodishDeclaration;
22433 exports.MethodishTraitResolution = MethodishTraitResolution;
22434 exports.ClassishDeclaration = ClassishDeclaration;
22435 exports.ClassishBody = ClassishBody;
22436 exports.TraitUsePrecedenceItem = TraitUsePrecedenceItem;
22437 exports.TraitUseAliasItem = TraitUseAliasItem;
22438 exports.TraitUseConflictResolution = TraitUseConflictResolution;
22439 exports.TraitUse = TraitUse;
22440 exports.RequireClause = RequireClause;
22441 exports.ConstDeclaration = ConstDeclaration;
22442 exports.ConstantDeclarator = ConstantDeclarator;
22443 exports.TypeConstDeclaration = TypeConstDeclaration;
22444 exports.DecoratedExpression = DecoratedExpression;
22445 exports.ParameterDeclaration = ParameterDeclaration;
22446 exports.VariadicParameter = VariadicParameter;
22447 exports.AttributeSpecification = AttributeSpecification;
22448 exports.InclusionExpression = InclusionExpression;
22449 exports.InclusionDirective = InclusionDirective;
22450 exports.CompoundStatement = CompoundStatement;
22451 exports.AlternateLoopStatement = AlternateLoopStatement;
22452 exports.ExpressionStatement = ExpressionStatement;
22453 exports.MarkupSection = MarkupSection;
22454 exports.MarkupSuffix = MarkupSuffix;
22455 exports.UnsetStatement = UnsetStatement;
22456 exports.LetStatement = LetStatement;
22457 exports.UsingStatementBlockScoped = UsingStatementBlockScoped;
22458 exports.UsingStatementFunctionScoped = UsingStatementFunctionScoped;
22459 exports.DeclareDirectiveStatement = DeclareDirectiveStatement;
22460 exports.DeclareBlockStatement = DeclareBlockStatement;
22461 exports.WhileStatement = WhileStatement;
22462 exports.IfStatement = IfStatement;
22463 exports.ElseifClause = ElseifClause;
22464 exports.ElseClause = ElseClause;
22465 exports.AlternateIfStatement = AlternateIfStatement;
22466 exports.AlternateElseifClause = AlternateElseifClause;
22467 exports.AlternateElseClause = AlternateElseClause;
22468 exports.TryStatement = TryStatement;
22469 exports.CatchClause = CatchClause;
22470 exports.FinallyClause = FinallyClause;
22471 exports.DoStatement = DoStatement;
22472 exports.ForStatement = ForStatement;
22473 exports.ForeachStatement = ForeachStatement;
22474 exports.SwitchStatement = SwitchStatement;
22475 exports.AlternateSwitchStatement = AlternateSwitchStatement;
22476 exports.SwitchSection = SwitchSection;
22477 exports.SwitchFallthrough = SwitchFallthrough;
22478 exports.CaseLabel = CaseLabel;
22479 exports.DefaultLabel = DefaultLabel;
22480 exports.ReturnStatement = ReturnStatement;
22481 exports.GotoLabel = GotoLabel;
22482 exports.GotoStatement = GotoStatement;
22483 exports.ThrowStatement = ThrowStatement;
22484 exports.BreakStatement = BreakStatement;
22485 exports.ContinueStatement = ContinueStatement;
22486 exports.EchoStatement = EchoStatement;
22487 exports.GlobalStatement = GlobalStatement;
22488 exports.ConcurrentStatement = ConcurrentStatement;
22489 exports.SimpleInitializer = SimpleInitializer;
22490 exports.AnonymousClass = AnonymousClass;
22491 exports.AnonymousFunction = AnonymousFunction;
22492 exports.Php7AnonymousFunction = Php7AnonymousFunction;
22493 exports.AnonymousFunctionUseClause = AnonymousFunctionUseClause;
22494 exports.LambdaExpression = LambdaExpression;
22495 exports.LambdaSignature = LambdaSignature;
22496 exports.CastExpression = CastExpression;
22497 exports.ScopeResolutionExpression = ScopeResolutionExpression;
22498 exports.MemberSelectionExpression = MemberSelectionExpression;
22499 exports.SafeMemberSelectionExpression = SafeMemberSelectionExpression;
22500 exports.EmbeddedMemberSelectionExpression = EmbeddedMemberSelectionExpression;
22501 exports.YieldExpression = YieldExpression;
22502 exports.YieldFromExpression = YieldFromExpression;
22503 exports.PrefixUnaryExpression = PrefixUnaryExpression;
22504 exports.PostfixUnaryExpression = PostfixUnaryExpression;
22505 exports.BinaryExpression = BinaryExpression;
22506 exports.InstanceofExpression = InstanceofExpression;
22507 exports.IsExpression = IsExpression;
22508 exports.AsExpression = AsExpression;
22509 exports.NullableAsExpression = NullableAsExpression;
22510 exports.ConditionalExpression = ConditionalExpression;
22511 exports.EvalExpression = EvalExpression;
22512 exports.EmptyExpression = EmptyExpression;
22513 exports.DefineExpression = DefineExpression;
22514 exports.HaltCompilerExpression = HaltCompilerExpression;
22515 exports.IssetExpression = IssetExpression;
22516 exports.FunctionCallExpression = FunctionCallExpression;
22517 exports.FunctionCallWithTypeArgumentsExpression = FunctionCallWithTypeArgumentsExpression;
22518 exports.ParenthesizedExpression = ParenthesizedExpression;
22519 exports.BracedExpression = BracedExpression;
22520 exports.EmbeddedBracedExpression = EmbeddedBracedExpression;
22521 exports.ListExpression = ListExpression;
22522 exports.CollectionLiteralExpression = CollectionLiteralExpression;
22523 exports.ObjectCreationExpression = ObjectCreationExpression;
22524 exports.ConstructorCall = ConstructorCall;
22525 exports.ArrayCreationExpression = ArrayCreationExpression;
22526 exports.ArrayIntrinsicExpression = ArrayIntrinsicExpression;
22527 exports.DarrayIntrinsicExpression = DarrayIntrinsicExpression;
22528 exports.DictionaryIntrinsicExpression = DictionaryIntrinsicExpression;
22529 exports.KeysetIntrinsicExpression = KeysetIntrinsicExpression;
22530 exports.VarrayIntrinsicExpression = VarrayIntrinsicExpression;
22531 exports.VectorIntrinsicExpression = VectorIntrinsicExpression;
22532 exports.ElementInitializer = ElementInitializer;
22533 exports.SubscriptExpression = SubscriptExpression;
22534 exports.EmbeddedSubscriptExpression = EmbeddedSubscriptExpression;
22535 exports.AwaitableCreationExpression = AwaitableCreationExpression;
22536 exports.XHPChildrenDeclaration = XHPChildrenDeclaration;
22537 exports.XHPChildrenParenthesizedList = XHPChildrenParenthesizedList;
22538 exports.XHPCategoryDeclaration = XHPCategoryDeclaration;
22539 exports.XHPEnumType = XHPEnumType;
22540 exports.XHPRequired = XHPRequired;
22541 exports.XHPClassAttributeDeclaration = XHPClassAttributeDeclaration;
22542 exports.XHPClassAttribute = XHPClassAttribute;
22543 exports.XHPSimpleClassAttribute = XHPSimpleClassAttribute;
22544 exports.XHPSimpleAttribute = XHPSimpleAttribute;
22545 exports.XHPSpreadAttribute = XHPSpreadAttribute;
22546 exports.XHPOpen = XHPOpen;
22547 exports.XHPExpression = XHPExpression;
22548 exports.XHPClose = XHPClose;
22549 exports.TypeConstant = TypeConstant;
22550 exports.VectorTypeSpecifier = VectorTypeSpecifier;
22551 exports.KeysetTypeSpecifier = KeysetTypeSpecifier;
22552 exports.TupleTypeExplicitSpecifier = TupleTypeExplicitSpecifier;
22553 exports.VarrayTypeSpecifier = VarrayTypeSpecifier;
22554 exports.VectorArrayTypeSpecifier = VectorArrayTypeSpecifier;
22555 exports.TypeParameter = TypeParameter;
22556 exports.TypeConstraint = TypeConstraint;
22557 exports.DarrayTypeSpecifier = DarrayTypeSpecifier;
22558 exports.MapArrayTypeSpecifier = MapArrayTypeSpecifier;
22559 exports.DictionaryTypeSpecifier = DictionaryTypeSpecifier;
22560 exports.ClosureTypeSpecifier = ClosureTypeSpecifier;
22561 exports.ClosureParameterTypeSpecifier = ClosureParameterTypeSpecifier;
22562 exports.ClassnameTypeSpecifier = ClassnameTypeSpecifier;
22563 exports.FieldSpecifier = FieldSpecifier;
22564 exports.FieldInitializer = FieldInitializer;
22565 exports.ShapeTypeSpecifier = ShapeTypeSpecifier;
22566 exports.ShapeExpression = ShapeExpression;
22567 exports.TupleExpression = TupleExpression;
22568 exports.GenericTypeSpecifier = GenericTypeSpecifier;
22569 exports.NullableTypeSpecifier = NullableTypeSpecifier;
22570 exports.SoftTypeSpecifier = SoftTypeSpecifier;
22571 exports.ReifiedTypeArgument = ReifiedTypeArgument;
22572 exports.TypeArguments = TypeArguments;
22573 exports.TypeParameters = TypeParameters;
22574 exports.TupleTypeSpecifier = TupleTypeSpecifier;
22575 exports.ErrorSyntax = ErrorSyntax;
22576 exports.ListItem = ListItem;
22577 exports.PocketAtomExpression = PocketAtomExpression;
22578 exports.PocketIdentifierExpression = PocketIdentifierExpression;
22579 exports.PocketAtomMappingDeclaration = PocketAtomMappingDeclaration;
22580 exports.PocketEnumDeclaration = PocketEnumDeclaration;
22581 exports.PocketFieldTypeExprDeclaration = PocketFieldTypeExprDeclaration;
22582 exports.PocketFieldTypeDeclaration = PocketFieldTypeDeclaration;
22583 exports.PocketMappingIdDeclaration = PocketMappingIdDeclaration;
22584 exports.PocketMappingTypeDeclaration = PocketMappingTypeDeclaration;