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 BSD-style license found in the
   6  * LICENSE file in the "hack" directory of this source tree. An additional
   7  * grant of patent rights can be found in the PATENTS file in the same
   8  * directory.
   9  *
  10  **
  11  *
  12  * THIS FILE IS @generated; DO NOT EDIT IT
  13  * To regenerate this file, run
  14  *
  15  *   buck run //hphp/hack/src:generate_full_fidelity
  16  *
  17  **
  18  *
  19  */
  20
  21 "use strict";
  22
  23 let utils = require('./full_fidelity_utils.js');
  24 let array_map_reduce = utils.array_map_reduce;
  25 let array_sum = utils.array_sum;
  26
  27 class EditableSyntax
  28 {
  29   constructor(syntax_kind, children)
  30   {
  31     this._syntax_kind = syntax_kind;
  32     this._children = children;
  33     let width = 0;
  34     for(let child in children)
  35       width += children[child].width;
  36     this._children_width = width;
  37   }
  38   get syntax_kind() { return this._syntax_kind; }
  39   get children() { return this._children; }
  40   get is_token() { return false; }
  41   get is_trivia() { return false; }
  42   get is_list() { return false; }
  43   get is_missing() { return false; }
  44
  45   get width() { return this._children_width; }
  46
  47   get full_text()
  48   {
  49     let s = '';
  50     for(let key of this.children_keys)
  51       s += this.children[key].full_text;
  52     return s;
  53   }
  54
  55   static from_json(json, position, source)
  56   {
  57     switch(json.kind)
  58     {
  59     case 'token':
  60       return EditableToken.from_json(json.token, position, source);
  61     case 'list':
  62       return EditableList.from_json(json, position, source);
  63     case 'whitespace':
  64       return WhiteSpace.from_json(json, position, source);
  65     case 'end_of_line':
  66       return EndOfLine.from_json(json, position, source);
  67     case 'delimited_comment':
  68       return DelimitedComment.from_json(json, position, source);
  69     case 'single_line_comment':
  70       return SingleLineComment.from_json(json, position, source);
  71     case 'unsafe':
  72       return Unsafe.from_json(json, position, source);
  73     case 'unsafe_expression':
  74       return UnsafeExpression.from_json(json, position, source);
  75     case 'fix_me':
  76       return FixMe.from_json(json, position, source);
  77     case 'ignore_error':
  78       return IgnoreError.from_json(json, position, source);
  79     case 'fall_through':
  80       return FallThrough.from_json(json, position, source);
  81     case 'extra_token_error':
  82       return ExtraTokenError.from_json(json, position, source);
  83     case 'after_halt_compiler':
  84       return AfterHaltCompiler.from_json(json, position, source);
  85
  86     case 'missing':
  87       return Missing.missing;
  88     case 'end_of_file':
  89       return EndOfFile.from_json(json, position, source);
  90     case 'script':
  91       return Script.from_json(json, position, source);
  92     case 'qualified_name':
  93       return QualifiedName.from_json(json, position, source);
  94     case 'simple_type_specifier':
  95       return SimpleTypeSpecifier.from_json(json, position, source);
  96     case 'literal':
  97       return LiteralExpression.from_json(json, position, source);
  98     case 'variable':
  99       return VariableExpression.from_json(json, position, source);
 100     case 'pipe_variable':
 101       return PipeVariableExpression.from_json(json, position, source);
 102     case 'enum_declaration':
 103       return EnumDeclaration.from_json(json, position, source);
 104     case 'enumerator':
 105       return Enumerator.from_json(json, position, source);
 106     case 'alias_declaration':
 107       return AliasDeclaration.from_json(json, position, source);
 108     case 'property_declaration':
 109       return PropertyDeclaration.from_json(json, position, source);
 110     case 'property_declarator':
 111       return PropertyDeclarator.from_json(json, position, source);
 112     case 'namespace_declaration':
 113       return NamespaceDeclaration.from_json(json, position, source);
 114     case 'namespace_body':
 115       return NamespaceBody.from_json(json, position, source);
 116     case 'namespace_empty_body':
 117       return NamespaceEmptyBody.from_json(json, position, source);
 118     case 'namespace_use_declaration':
 119       return NamespaceUseDeclaration.from_json(json, position, source);
 120     case 'namespace_group_use_declaration':
 121       return NamespaceGroupUseDeclaration.from_json(json, position, source);
 122     case 'namespace_use_clause':
 123       return NamespaceUseClause.from_json(json, position, source);
 124     case 'function_declaration':
 125       return FunctionDeclaration.from_json(json, position, source);
 126     case 'function_declaration_header':
 127       return FunctionDeclarationHeader.from_json(json, position, source);
 128     case 'where_clause':
 129       return WhereClause.from_json(json, position, source);
 130     case 'where_constraint':
 131       return WhereConstraint.from_json(json, position, source);
 132     case 'methodish_declaration':
 133       return MethodishDeclaration.from_json(json, position, source);
 134     case 'classish_declaration':
 135       return ClassishDeclaration.from_json(json, position, source);
 136     case 'classish_body':
 137       return ClassishBody.from_json(json, position, source);
 138     case 'trait_use_precedence_item':
 139       return TraitUsePrecedenceItem.from_json(json, position, source);
 140     case 'trait_use_alias_item':
 141       return TraitUseAliasItem.from_json(json, position, source);
 142     case 'trait_use_conflict_resolution':
 143       return TraitUseConflictResolution.from_json(json, position, source);
 144     case 'trait_use':
 145       return TraitUse.from_json(json, position, source);
 146     case 'require_clause':
 147       return RequireClause.from_json(json, position, source);
 148     case 'const_declaration':
 149       return ConstDeclaration.from_json(json, position, source);
 150     case 'constant_declarator':
 151       return ConstantDeclarator.from_json(json, position, source);
 152     case 'type_const_declaration':
 153       return TypeConstDeclaration.from_json(json, position, source);
 154     case 'decorated_expression':
 155       return DecoratedExpression.from_json(json, position, source);
 156     case 'parameter_declaration':
 157       return ParameterDeclaration.from_json(json, position, source);
 158     case 'variadic_parameter':
 159       return VariadicParameter.from_json(json, position, source);
 160     case 'attribute_specification':
 161       return AttributeSpecification.from_json(json, position, source);
 162     case 'attribute':
 163       return Attribute.from_json(json, position, source);
 164     case 'inclusion_expression':
 165       return InclusionExpression.from_json(json, position, source);
 166     case 'inclusion_directive':
 167       return InclusionDirective.from_json(json, position, source);
 168     case 'compound_statement':
 169       return CompoundStatement.from_json(json, position, source);
 170     case 'alternate_loop_statement':
 171       return AlternateLoopStatement.from_json(json, position, source);
 172     case 'expression_statement':
 173       return ExpressionStatement.from_json(json, position, source);
 174     case 'markup_section':
 175       return MarkupSection.from_json(json, position, source);
 176     case 'markup_suffix':
 177       return MarkupSuffix.from_json(json, position, source);
 178     case 'unset_statement':
 179       return UnsetStatement.from_json(json, position, source);
 180     case 'using_statement_block_scoped':
 181       return UsingStatementBlockScoped.from_json(json, position, source);
 182     case 'using_statement_function_scoped':
 183       return UsingStatementFunctionScoped.from_json(json, position, source);
 184     case 'declare_directive_statement':
 185       return DeclareDirectiveStatement.from_json(json, position, source);
 186     case 'declare_block_statement':
 187       return DeclareBlockStatement.from_json(json, position, source);
 188     case 'while_statement':
 189       return WhileStatement.from_json(json, position, source);
 190     case 'if_statement':
 191       return IfStatement.from_json(json, position, source);
 192     case 'elseif_clause':
 193       return ElseifClause.from_json(json, position, source);
 194     case 'else_clause':
 195       return ElseClause.from_json(json, position, source);
 196     case 'if_endif_statement':
 197       return IfEndIfStatement.from_json(json, position, source);
 198     case 'elseif_colon_clause':
 199       return ElseifColonClause.from_json(json, position, source);
 200     case 'else_colon_clause':
 201       return ElseColonClause.from_json(json, position, source);
 202     case 'try_statement':
 203       return TryStatement.from_json(json, position, source);
 204     case 'catch_clause':
 205       return CatchClause.from_json(json, position, source);
 206     case 'finally_clause':
 207       return FinallyClause.from_json(json, position, source);
 208     case 'do_statement':
 209       return DoStatement.from_json(json, position, source);
 210     case 'for_statement':
 211       return ForStatement.from_json(json, position, source);
 212     case 'foreach_statement':
 213       return ForeachStatement.from_json(json, position, source);
 214     case 'switch_statement':
 215       return SwitchStatement.from_json(json, position, source);
 216     case 'alternate_switch_statement':
 217       return AlternateSwitchStatement.from_json(json, position, source);
 218     case 'switch_section':
 219       return SwitchSection.from_json(json, position, source);
 220     case 'switch_fallthrough':
 221       return SwitchFallthrough.from_json(json, position, source);
 222     case 'case_label':
 223       return CaseLabel.from_json(json, position, source);
 224     case 'default_label':
 225       return DefaultLabel.from_json(json, position, source);
 226     case 'return_statement':
 227       return ReturnStatement.from_json(json, position, source);
 228     case 'goto_label':
 229       return GotoLabel.from_json(json, position, source);
 230     case 'goto_statement':
 231       return GotoStatement.from_json(json, position, source);
 232     case 'throw_statement':
 233       return ThrowStatement.from_json(json, position, source);
 234     case 'break_statement':
 235       return BreakStatement.from_json(json, position, source);
 236     case 'continue_statement':
 237       return ContinueStatement.from_json(json, position, source);
 238     case 'function_static_statement':
 239       return FunctionStaticStatement.from_json(json, position, source);
 240     case 'static_declarator':
 241       return StaticDeclarator.from_json(json, position, source);
 242     case 'echo_statement':
 243       return EchoStatement.from_json(json, position, source);
 244     case 'global_statement':
 245       return GlobalStatement.from_json(json, position, source);
 246     case 'simple_initializer':
 247       return SimpleInitializer.from_json(json, position, source);
 248     case 'anonymous_class':
 249       return AnonymousClass.from_json(json, position, source);
 250     case 'anonymous_function':
 251       return AnonymousFunction.from_json(json, position, source);
 252     case 'php7_anonymous_function':
 253       return Php7AnonymousFunction.from_json(json, position, source);
 254     case 'anonymous_function_use_clause':
 255       return AnonymousFunctionUseClause.from_json(json, position, source);
 256     case 'lambda_expression':
 257       return LambdaExpression.from_json(json, position, source);
 258     case 'lambda_signature':
 259       return LambdaSignature.from_json(json, position, source);
 260     case 'cast_expression':
 261       return CastExpression.from_json(json, position, source);
 262     case 'scope_resolution_expression':
 263       return ScopeResolutionExpression.from_json(json, position, source);
 264     case 'member_selection_expression':
 265       return MemberSelectionExpression.from_json(json, position, source);
 266     case 'safe_member_selection_expression':
 267       return SafeMemberSelectionExpression.from_json(json, position, source);
 268     case 'embedded_member_selection_expression':
 269       return EmbeddedMemberSelectionExpression.from_json(json, position, source);
 270     case 'yield_expression':
 271       return YieldExpression.from_json(json, position, source);
 272     case 'yield_from_expression':
 273       return YieldFromExpression.from_json(json, position, source);
 274     case 'prefix_unary_expression':
 275       return PrefixUnaryExpression.from_json(json, position, source);
 276     case 'postfix_unary_expression':
 277       return PostfixUnaryExpression.from_json(json, position, source);
 278     case 'binary_expression':
 279       return BinaryExpression.from_json(json, position, source);
 280     case 'instanceof_expression':
 281       return InstanceofExpression.from_json(json, position, source);
 282     case 'is_expression':
 283       return IsExpression.from_json(json, position, source);
 284     case 'conditional_expression':
 285       return ConditionalExpression.from_json(json, position, source);
 286     case 'eval_expression':
 287       return EvalExpression.from_json(json, position, source);
 288     case 'empty_expression':
 289       return EmptyExpression.from_json(json, position, source);
 290     case 'define_expression':
 291       return DefineExpression.from_json(json, position, source);
 292     case 'halt_compiler_expression':
 293       return HaltCompilerExpression.from_json(json, position, source);
 294     case 'isset_expression':
 295       return IssetExpression.from_json(json, position, source);
 296     case 'function_call_expression':
 297       return FunctionCallExpression.from_json(json, position, source);
 298     case 'function_call_with_type_arguments_expression':
 299       return FunctionCallWithTypeArgumentsExpression.from_json(json, position, source);
 300     case 'parenthesized_expression':
 301       return ParenthesizedExpression.from_json(json, position, source);
 302     case 'braced_expression':
 303       return BracedExpression.from_json(json, position, source);
 304     case 'embedded_braced_expression':
 305       return EmbeddedBracedExpression.from_json(json, position, source);
 306     case 'list_expression':
 307       return ListExpression.from_json(json, position, source);
 308     case 'collection_literal_expression':
 309       return CollectionLiteralExpression.from_json(json, position, source);
 310     case 'object_creation_expression':
 311       return ObjectCreationExpression.from_json(json, position, source);
 312     case 'constructor_call':
 313       return ConstructorCall.from_json(json, position, source);
 314     case 'array_creation_expression':
 315       return ArrayCreationExpression.from_json(json, position, source);
 316     case 'array_intrinsic_expression':
 317       return ArrayIntrinsicExpression.from_json(json, position, source);
 318     case 'darray_intrinsic_expression':
 319       return DarrayIntrinsicExpression.from_json(json, position, source);
 320     case 'dictionary_intrinsic_expression':
 321       return DictionaryIntrinsicExpression.from_json(json, position, source);
 322     case 'keyset_intrinsic_expression':
 323       return KeysetIntrinsicExpression.from_json(json, position, source);
 324     case 'varray_intrinsic_expression':
 325       return VarrayIntrinsicExpression.from_json(json, position, source);
 326     case 'vector_intrinsic_expression':
 327       return VectorIntrinsicExpression.from_json(json, position, source);
 328     case 'element_initializer':
 329       return ElementInitializer.from_json(json, position, source);
 330     case 'subscript_expression':
 331       return SubscriptExpression.from_json(json, position, source);
 332     case 'embedded_subscript_expression':
 333       return EmbeddedSubscriptExpression.from_json(json, position, source);
 334     case 'awaitable_creation_expression':
 335       return AwaitableCreationExpression.from_json(json, position, source);
 336     case 'xhp_children_declaration':
 337       return XHPChildrenDeclaration.from_json(json, position, source);
 338     case 'xhp_children_parenthesized_list':
 339       return XHPChildrenParenthesizedList.from_json(json, position, source);
 340     case 'xhp_category_declaration':
 341       return XHPCategoryDeclaration.from_json(json, position, source);
 342     case 'xhp_enum_type':
 343       return XHPEnumType.from_json(json, position, source);
 344     case 'xhp_required':
 345       return XHPRequired.from_json(json, position, source);
 346     case 'xhp_class_attribute_declaration':
 347       return XHPClassAttributeDeclaration.from_json(json, position, source);
 348     case 'xhp_class_attribute':
 349       return XHPClassAttribute.from_json(json, position, source);
 350     case 'xhp_simple_class_attribute':
 351       return XHPSimpleClassAttribute.from_json(json, position, source);
 352     case 'xhp_simple_attribute':
 353       return XHPSimpleAttribute.from_json(json, position, source);
 354     case 'xhp_spread_attribute':
 355       return XHPSpreadAttribute.from_json(json, position, source);
 356     case 'xhp_open':
 357       return XHPOpen.from_json(json, position, source);
 358     case 'xhp_expression':
 359       return XHPExpression.from_json(json, position, source);
 360     case 'xhp_close':
 361       return XHPClose.from_json(json, position, source);
 362     case 'type_constant':
 363       return TypeConstant.from_json(json, position, source);
 364     case 'vector_type_specifier':
 365       return VectorTypeSpecifier.from_json(json, position, source);
 366     case 'keyset_type_specifier':
 367       return KeysetTypeSpecifier.from_json(json, position, source);
 368     case 'tuple_type_explicit_specifier':
 369       return TupleTypeExplicitSpecifier.from_json(json, position, source);
 370     case 'varray_type_specifier':
 371       return VarrayTypeSpecifier.from_json(json, position, source);
 372     case 'vector_array_type_specifier':
 373       return VectorArrayTypeSpecifier.from_json(json, position, source);
 374     case 'type_parameter':
 375       return TypeParameter.from_json(json, position, source);
 376     case 'type_constraint':
 377       return TypeConstraint.from_json(json, position, source);
 378     case 'darray_type_specifier':
 379       return DarrayTypeSpecifier.from_json(json, position, source);
 380     case 'map_array_type_specifier':
 381       return MapArrayTypeSpecifier.from_json(json, position, source);
 382     case 'dictionary_type_specifier':
 383       return DictionaryTypeSpecifier.from_json(json, position, source);
 384     case 'closure_type_specifier':
 385       return ClosureTypeSpecifier.from_json(json, position, source);
 386     case 'closure_parameter_type_specifier':
 387       return ClosureParameterTypeSpecifier.from_json(json, position, source);
 388     case 'classname_type_specifier':
 389       return ClassnameTypeSpecifier.from_json(json, position, source);
 390     case 'field_specifier':
 391       return FieldSpecifier.from_json(json, position, source);
 392     case 'field_initializer':
 393       return FieldInitializer.from_json(json, position, source);
 394     case 'shape_type_specifier':
 395       return ShapeTypeSpecifier.from_json(json, position, source);
 396     case 'shape_expression':
 397       return ShapeExpression.from_json(json, position, source);
 398     case 'tuple_expression':
 399       return TupleExpression.from_json(json, position, source);
 400     case 'generic_type_specifier':
 401       return GenericTypeSpecifier.from_json(json, position, source);
 402     case 'nullable_type_specifier':
 403       return NullableTypeSpecifier.from_json(json, position, source);
 404     case 'soft_type_specifier':
 405       return SoftTypeSpecifier.from_json(json, position, source);
 406     case 'type_arguments':
 407       return TypeArguments.from_json(json, position, source);
 408     case 'type_parameters':
 409       return TypeParameters.from_json(json, position, source);
 410     case 'tuple_type_specifier':
 411       return TupleTypeSpecifier.from_json(json, position, source);
 412     case 'error':
 413       return ErrorSyntax.from_json(json, position, source);
 414     case 'list_item':
 415       return ListItem.from_json(json, position, source);
 416
 417     default:
 418       throw 'unexpected json kind: ' + json.kind; // TODO: Better exception
 419     }
 420   }
 421
 422   reduce(reducer, accumulator, parents)
 423   {
 424     if (parents == undefined)
 425       parents = [];
 426     let new_parents = parents.slice();
 427     new_parents.push(this);
 428     for(let key of this.children_keys)
 429     {
 430       accumulator = this.children[key].reduce(
 431         reducer, accumulator, new_parents);
 432     }
 433     return reducer(this, accumulator, parents);
 434   }
 435
 436   // Returns all the parents (and the node itself) of the first node
 437   // that matches a predicate, or [] if there is no such node.
 438   find(predicate, parents)
 439   {
 440     if (parents == undefined)
 441       parents = [];
 442     let new_parents = parents.slice();
 443     new_parents.push(this);
 444     if (predicate(this))
 445       return new_parents;
 446     for(let key of this.children_keys)
 447     {
 448       let result = this.children[key].find(predicate, new_parents);
 449       if (result.length != 0)
 450         return result;
 451     }
 452     return [];
 453   }
 454
 455   // Returns a list of nodes that match a predicate.
 456   filter(predicate)
 457   {
 458     let reducer = (node, acc, parents) => {
 459       if (predicate(node))
 460         acc.push(node);
 461       return acc;
 462     };
 463     return this.reduce(reducer, []);
 464   }
 465
 466   of_syntax_kind(kind)
 467   {
 468     return this.filter((node) => node.syntax_kind == kind);
 469   }
 470
 471   remove_where(predicate)
 472   {
 473     return this.rewrite(
 474       (node, parents) => predicate(node) ? Missing.missing : node);
 475   }
 476
 477   without(target)
 478   {
 479     return this.remove_where((node) => node === target);
 480   }
 481
 482   replace(new_node, target)
 483   {
 484     return this.rewrite((node, parents) => node === target ? new_node : node);
 485   }
 486
 487   pre_order(action, parents)
 488   {
 489     if (parents == undefined)
 490       parents = [];
 491     action(this, parents);
 492     let new_parents = parents.slice();
 493     new_parents.push(this);
 494     for(let key of this.children_keys)
 495       this.children[key].pre_order(action, new_parents);
 496   }
 497
 498   get leftmost_token()
 499   {
 500     if (this.is_token)
 501       return this;
 502
 503     for(let key of this.children_keys)
 504     {
 505       if (!this.children[key].is_missing)
 506         return this.children[key].leftmost_token;
 507     }
 508     return null;
 509   }
 510
 511   get rightmost_token()
 512   {
 513     if (this.is_token)
 514       return this;
 515
 516     for (let i = this.children_keys.length - 1; i >= 0; i--)
 517     {
 518       if (!this.children[this.children_keys[i]].is_missing)
 519         return this.children[key].rightmost_token;
 520     }
 521     return null;
 522   }
 523
 524   insert_before(new_node, target)
 525   {
 526     // Inserting before missing is an error.
 527     if (target.is_missing)
 528       throw 'Target must not be missing in insert_before.';
 529
 530     // Inserting missing is a no-op
 531     if (new_node.is_missing)
 532       return this;
 533
 534     if (new_node.is_trivia && !target.is_trivia)
 535     {
 536       let token = target.is_token ? target : target.leftmost_token;
 537       if (token == null)
 538         throw 'Unable to find token to insert trivia.';
 539
 540       // Inserting trivia before token is inserting to the right end of
 541       // the leading trivia.
 542       let new_leading = EditableSyntax.concatenate_lists(
 543         token.leading, new_node);
 544       let new_token = token.with_leading(new_leading);
 545       return this.replace(new_token, token);
 546     }
 547
 548     return this.replace(
 549       EditableSyntax.concatenate_lists(new_node, target), target);
 550   }
 551
 552   insert_after(new_node, target)
 553   {
 554     // Inserting after missing is an error.
 555     if (target.is_missing)
 556       throw 'Target must not be missing in insert_after.';
 557
 558     // Inserting missing is a no-op
 559     if (new_node.is_missing)
 560       return this;
 561
 562     if (new_node.is_trivia && !target.is_trivia)
 563     {
 564       let token = target.is_token ? target : target.rightmost_token;
 565       if (token == null)
 566         throw 'Unable to find token to insert trivia.';
 567
 568       // Inserting trivia after token is inserting to the left end of
 569       // the trailing trivia.
 570       let new_trailing = EditableSyntax.concatenate_lists(
 571         new_node, token.trailing);
 572       let new_token = token.with_trailing(new_trailing);
 573       return this.replace(new_token, token);
 574     }
 575
 576     return this.replace(
 577       EditableSyntax.concatenate_lists(target, new_node), target);
 578   }
 579
 580   static to_list(syntax_list)
 581   {
 582     if (syntax_list.length == 0)
 583       return Missing.missing;
 584     else
 585       return new EditableList(syntax_list);
 586   }
 587
 588   static concatenate_lists(left, right)
 589   {
 590     if (left.is_missing)
 591       return right;
 592     if (right.is_missing)
 593       return left;
 594     if (left.is_list && right.is_list)
 595       return new EditableList(left.children.concat(right.children));
 596     if (left.is_list)
 597       return new EditableList(left.children.splice().push(right));
 598     if (right.is_list)
 599       return new EditableList([right].concat(left.children));
 600     return new EditableList([left, right]);
 601   }
 602 }
 603
 604 class EditableList extends EditableSyntax
 605 {
 606   constructor(children)
 607   {
 608     super('list', children);
 609   }
 610   get is_list() { return true; }
 611
 612   static from_json(json, position, source)
 613   {
 614     let children = [];
 615     let current_position = position;
 616     for(let element of json.elements)
 617     {
 618       let child = EditableSyntax.from_json(element, current_position, source);
 619       children.push(child);
 620       current_position += child.width;
 621     }
 622     return new EditableList(children);
 623   }
 624
 625   rewrite(rewriter, parents)
 626   {
 627     let dirty = false;
 628     let new_children = [];
 629     let new_parents = parents.slice();
 630     new_parents.push(this);
 631     for (let key of this.children_keys)
 632     {
 633       let child = this.children[key];
 634       let new_child = child.rewrite(rewriter, new_parents);
 635       if (new_child != child)
 636         dirty = true;
 637       if (new_child != null)
 638       {
 639         if (new_child.is_list)
 640         {
 641           for(let n of new_child.children)
 642             new_children.push(n);
 643         }
 644         else
 645           new_children.push(new_child);
 646       }
 647     }
 648     let result = this;
 649     if (dirty)
 650     {
 651       if (new_children.length === 0)
 652         result = Missing.missing;
 653       else if (new_children.length === 1)
 654         result = new_children[0];
 655       else
 656         result = new EditableList(new_children);
 657     }
 658     return rewriter(result, parents);
 659   }
 660   get children_keys()
 661   {
 662     return Object.keys(this.children);
 663   }
 664 }
 665
 666 class EditableToken extends EditableSyntax
 667 {
 668   constructor(token_kind, leading, trailing, text)
 669   {
 670     super('token', { leading : leading, trailing : trailing });
 671     this._token_kind = token_kind;
 672     this._text = text;
 673   }
 674
 675   get token_kind() { return this._token_kind; }
 676   get text() { return this._text; }
 677   get leading() { return this.children.leading; }
 678   get trailing() { return this.children.trailing; }
 679   get width()
 680   {
 681     return this.text.length + this.leading.width + this.trailing.width;
 682   }
 683   get is_token() { return true; }
 684   get full_text()
 685   {
 686     return this.leading.full_text + this.text + this.trailing.full_text;
 687   }
 688   with_leading(leading)
 689   {
 690     return EditableToken.factory(
 691       this.token_kind, leading, this.trailing, this.text);
 692   }
 693   with_trailing(trailing)
 694   {
 695     return EditableToken.factory(
 696       this.token_kind, this.leading, trailing, this.text);
 697   }
 698   static factory(token_kind, leading, trailing, token_text)
 699   {
 700     switch(token_kind)
 701     {
 702     case 'end_of_file':
 703        return new EndOfFileToken(leading, trailing);
 704
 705     case 'abstract':
 706        return new AbstractToken(leading, trailing);
 707     case 'and':
 708        return new AndToken(leading, trailing);
 709     case 'array':
 710        return new ArrayToken(leading, trailing);
 711     case 'arraykey':
 712        return new ArraykeyToken(leading, trailing);
 713     case 'as':
 714        return new AsToken(leading, trailing);
 715     case 'async':
 716        return new AsyncToken(leading, trailing);
 717     case 'attribute':
 718        return new AttributeToken(leading, trailing);
 719     case 'await':
 720        return new AwaitToken(leading, trailing);
 721     case '\':
 722        return new BackslashToken(leading, trailing);
 723     case 'bool':
 724        return new BoolToken(leading, trailing);
 725     case 'break':
 726        return new BreakToken(leading, trailing);
 727     case 'case':
 728        return new CaseToken(leading, trailing);
 729     case 'catch':
 730        return new CatchToken(leading, trailing);
 731     case 'category':
 732        return new CategoryToken(leading, trailing);
 733     case 'children':
 734        return new ChildrenToken(leading, trailing);
 735     case 'class':
 736        return new ClassToken(leading, trailing);
 737     case 'classname':
 738        return new ClassnameToken(leading, trailing);
 739     case 'clone':
 740        return new CloneToken(leading, trailing);
 741     case 'const':
 742        return new ConstToken(leading, trailing);
 743     case '__construct':
 744        return new ConstructToken(leading, trailing);
 745     case 'continue':
 746        return new ContinueToken(leading, trailing);
 747     case 'coroutine':
 748        return new CoroutineToken(leading, trailing);
 749     case 'darray':
 750        return new DarrayToken(leading, trailing);
 751     case 'declare':
 752        return new DeclareToken(leading, trailing);
 753     case 'default':
 754        return new DefaultToken(leading, trailing);
 755     case 'define':
 756        return new DefineToken(leading, trailing);
 757     case '__destruct':
 758        return new DestructToken(leading, trailing);
 759     case 'dict':
 760        return new DictToken(leading, trailing);
 761     case 'do':
 762        return new DoToken(leading, trailing);
 763     case 'double':
 764        return new DoubleToken(leading, trailing);
 765     case 'echo':
 766        return new EchoToken(leading, trailing);
 767     case 'else':
 768        return new ElseToken(leading, trailing);
 769     case 'elseif':
 770        return new ElseifToken(leading, trailing);
 771     case 'empty':
 772        return new EmptyToken(leading, trailing);
 773     case 'endfor':
 774        return new EndforToken(leading, trailing);
 775     case 'endforeach':
 776        return new EndforeachToken(leading, trailing);
 777     case 'enddeclare':
 778        return new EnddeclareToken(leading, trailing);
 779     case 'endif':
 780        return new EndifToken(leading, trailing);
 781     case 'endswitch':
 782        return new EndswitchToken(leading, trailing);
 783     case 'endwhile':
 784        return new EndwhileToken(leading, trailing);
 785     case 'enum':
 786        return new EnumToken(leading, trailing);
 787     case 'eval':
 788        return new EvalToken(leading, trailing);
 789     case 'extends':
 790        return new ExtendsToken(leading, trailing);
 791     case 'fallthrough':
 792        return new FallthroughToken(leading, trailing);
 793     case 'float':
 794        return new FloatToken(leading, trailing);
 795     case 'final':
 796        return new FinalToken(leading, trailing);
 797     case 'finally':
 798        return new FinallyToken(leading, trailing);
 799     case 'for':
 800        return new ForToken(leading, trailing);
 801     case 'foreach':
 802        return new ForeachToken(leading, trailing);
 803     case 'from':
 804        return new FromToken(leading, trailing);
 805     case 'function':
 806        return new FunctionToken(leading, trailing);
 807     case 'global':
 808        return new GlobalToken(leading, trailing);
 809     case 'goto':
 810        return new GotoToken(leading, trailing);
 811     case 'if':
 812        return new IfToken(leading, trailing);
 813     case 'implements':
 814        return new ImplementsToken(leading, trailing);
 815     case 'include':
 816        return new IncludeToken(leading, trailing);
 817     case 'include_once':
 818        return new Include_onceToken(leading, trailing);
 819     case 'inout':
 820        return new InoutToken(leading, trailing);
 821     case 'instanceof':
 822        return new InstanceofToken(leading, trailing);
 823     case 'insteadof':
 824        return new InsteadofToken(leading, trailing);
 825     case 'int':
 826        return new IntToken(leading, trailing);
 827     case 'interface':
 828        return new InterfaceToken(leading, trailing);
 829     case 'is':
 830        return new IsToken(leading, trailing);
 831     case 'isset':
 832        return new IssetToken(leading, trailing);
 833     case 'keyset':
 834        return new KeysetToken(leading, trailing);
 835     case 'list':
 836        return new ListToken(leading, trailing);
 837     case 'mixed':
 838        return new MixedToken(leading, trailing);
 839     case 'namespace':
 840        return new NamespaceToken(leading, trailing);
 841     case 'new':
 842        return new NewToken(leading, trailing);
 843     case 'newtype':
 844        return new NewtypeToken(leading, trailing);
 845     case 'noreturn':
 846        return new NoreturnToken(leading, trailing);
 847     case 'num':
 848        return new NumToken(leading, trailing);
 849     case 'object':
 850        return new ObjectToken(leading, trailing);
 851     case 'or':
 852        return new OrToken(leading, trailing);
 853     case 'parent':
 854        return new ParentToken(leading, trailing);
 855     case 'print':
 856        return new PrintToken(leading, trailing);
 857     case 'private':
 858        return new PrivateToken(leading, trailing);
 859     case 'protected':
 860        return new ProtectedToken(leading, trailing);
 861     case 'public':
 862        return new PublicToken(leading, trailing);
 863     case 'require':
 864        return new RequireToken(leading, trailing);
 865     case 'require_once':
 866        return new Require_onceToken(leading, trailing);
 867     case 'required':
 868        return new RequiredToken(leading, trailing);
 869     case 'resource':
 870        return new ResourceToken(leading, trailing);
 871     case 'return':
 872        return new ReturnToken(leading, trailing);
 873     case 'self':
 874        return new SelfToken(leading, trailing);
 875     case 'shape':
 876        return new ShapeToken(leading, trailing);
 877     case 'static':
 878        return new StaticToken(leading, trailing);
 879     case 'string':
 880        return new StringToken(leading, trailing);
 881     case 'super':
 882        return new SuperToken(leading, trailing);
 883     case 'suspend':
 884        return new SuspendToken(leading, trailing);
 885     case 'switch':
 886        return new SwitchToken(leading, trailing);
 887     case 'this':
 888        return new ThisToken(leading, trailing);
 889     case 'throw':
 890        return new ThrowToken(leading, trailing);
 891     case 'trait':
 892        return new TraitToken(leading, trailing);
 893     case 'try':
 894        return new TryToken(leading, trailing);
 895     case 'tuple':
 896        return new TupleToken(leading, trailing);
 897     case 'type':
 898        return new TypeToken(leading, trailing);
 899     case 'unset':
 900        return new UnsetToken(leading, trailing);
 901     case 'use':
 902        return new UseToken(leading, trailing);
 903     case 'using':
 904        return new UsingToken(leading, trailing);
 905     case 'var':
 906        return new VarToken(leading, trailing);
 907     case 'varray':
 908        return new VarrayToken(leading, trailing);
 909     case 'vec':
 910        return new VecToken(leading, trailing);
 911     case 'void':
 912        return new VoidToken(leading, trailing);
 913     case 'where':
 914        return new WhereToken(leading, trailing);
 915     case 'while':
 916        return new WhileToken(leading, trailing);
 917     case 'xor':
 918        return new XorToken(leading, trailing);
 919     case 'yield':
 920        return new YieldToken(leading, trailing);
 921     case '[':
 922        return new LeftBracketToken(leading, trailing);
 923     case ']':
 924        return new RightBracketToken(leading, trailing);
 925     case '(':
 926        return new LeftParenToken(leading, trailing);
 927     case ')':
 928        return new RightParenToken(leading, trailing);
 929     case '{':
 930        return new LeftBraceToken(leading, trailing);
 931     case '}':
 932        return new RightBraceToken(leading, trailing);
 933     case '.':
 934        return new DotToken(leading, trailing);
 935     case '->':
 936        return new MinusGreaterThanToken(leading, trailing);
 937     case '++':
 938        return new PlusPlusToken(leading, trailing);
 939     case '--':
 940        return new MinusMinusToken(leading, trailing);
 941     case '**':
 942        return new StarStarToken(leading, trailing);
 943     case '*':
 944        return new StarToken(leading, trailing);
 945     case '+':
 946        return new PlusToken(leading, trailing);
 947     case '-':
 948        return new MinusToken(leading, trailing);
 949     case '~':
 950        return new TildeToken(leading, trailing);
 951     case '!':
 952        return new ExclamationToken(leading, trailing);
 953     case '$':
 954        return new DollarToken(leading, trailing);
 955     case '/':
 956        return new SlashToken(leading, trailing);
 957     case '%':
 958        return new PercentToken(leading, trailing);
 959     case '<>':
 960        return new LessThanGreaterThanToken(leading, trailing);
 961     case '<=>':
 962        return new LessThanEqualGreaterThanToken(leading, trailing);
 963     case '<<':
 964        return new LessThanLessThanToken(leading, trailing);
 965     case '>>':
 966        return new GreaterThanGreaterThanToken(leading, trailing);
 967     case '<':
 968        return new LessThanToken(leading, trailing);
 969     case '>':
 970        return new GreaterThanToken(leading, trailing);
 971     case '<=':
 972        return new LessThanEqualToken(leading, trailing);
 973     case '>=':
 974        return new GreaterThanEqualToken(leading, trailing);
 975     case '==':
 976        return new EqualEqualToken(leading, trailing);
 977     case '===':
 978        return new EqualEqualEqualToken(leading, trailing);
 979     case '!=':
 980        return new ExclamationEqualToken(leading, trailing);
 981     case '!==':
 982        return new ExclamationEqualEqualToken(leading, trailing);
 983     case '^':
 984        return new CaratToken(leading, trailing);
 985     case '|':
 986        return new BarToken(leading, trailing);
 987     case '&':
 988        return new AmpersandToken(leading, trailing);
 989     case '&&':
 990        return new AmpersandAmpersandToken(leading, trailing);
 991     case '||':
 992        return new BarBarToken(leading, trailing);
 993     case '?':
 994        return new QuestionToken(leading, trailing);
 995     case '?:':
 996        return new QuestionColonToken(leading, trailing);
 997     case '??':
 998        return new QuestionQuestionToken(leading, trailing);
 999     case ':':
1000        return new ColonToken(leading, trailing);
1001     case ';':
1002        return new SemicolonToken(leading, trailing);
1003     case '=':
1004        return new EqualToken(leading, trailing);
1005     case '**=':
1006        return new StarStarEqualToken(leading, trailing);
1007     case '*=':
1008        return new StarEqualToken(leading, trailing);
1009     case '/=':
1010        return new SlashEqualToken(leading, trailing);
1011     case '%=':
1012        return new PercentEqualToken(leading, trailing);
1013     case '+=':
1014        return new PlusEqualToken(leading, trailing);
1015     case '-=':
1016        return new MinusEqualToken(leading, trailing);
1017     case '.=':
1018        return new DotEqualToken(leading, trailing);
1019     case '<<=':
1020        return new LessThanLessThanEqualToken(leading, trailing);
1021     case '>>=':
1022        return new GreaterThanGreaterThanEqualToken(leading, trailing);
1023     case '&=':
1024        return new AmpersandEqualToken(leading, trailing);
1025     case '^=':
1026        return new CaratEqualToken(leading, trailing);
1027     case '|=':
1028        return new BarEqualToken(leading, trailing);
1029     case ',':
1030        return new CommaToken(leading, trailing);
1031     case '@':
1032        return new AtToken(leading, trailing);
1033     case '::':
1034        return new ColonColonToken(leading, trailing);
1035     case '=>':
1036        return new EqualGreaterThanToken(leading, trailing);
1037     case '==>':
1038        return new EqualEqualGreaterThanToken(leading, trailing);
1039     case '?->':
1040        return new QuestionMinusGreaterThanToken(leading, trailing);
1041     case '...':
1042        return new DotDotDotToken(leading, trailing);
1043     case '$$':
1044        return new DollarDollarToken(leading, trailing);
1045     case '|>':
1046        return new BarGreaterThanToken(leading, trailing);
1047     case 'null':
1048        return new NullLiteralToken(leading, trailing);
1049     case '/>':
1050        return new SlashGreaterThanToken(leading, trailing);
1051     case '</':
1052        return new LessThanSlashToken(leading, trailing);
1053     case '<?':
1054        return new LessThanQuestionToken(leading, trailing);
1055     case '?>':
1056        return new QuestionGreaterThanToken(leading, trailing);
1057     case '__halt_compiler':
1058        return new HaltCompilerToken(leading, trailing);
1059
1060     case 'error_token':
1061        return new ErrorTokenToken(leading, trailing, token_text);
1062     case 'name':
1063        return new NameToken(leading, trailing, token_text);
1064     case 'variable':
1065        return new VariableToken(leading, trailing, token_text);
1066     case 'decimal_literal':
1067        return new DecimalLiteralToken(leading, trailing, token_text);
1068     case 'octal_literal':
1069        return new OctalLiteralToken(leading, trailing, token_text);
1070     case 'hexadecimal_literal':
1071        return new HexadecimalLiteralToken(leading, trailing, token_text);
1072     case 'binary_literal':
1073        return new BinaryLiteralToken(leading, trailing, token_text);
1074     case 'floating_literal':
1075        return new FloatingLiteralToken(leading, trailing, token_text);
1076     case 'execution_string_literal':
1077        return new ExecutionStringLiteralToken(leading, trailing, token_text);
1078     case 'execution_string_literal_head':
1079        return new ExecutionStringLiteralHeadToken(leading, trailing, token_text);
1080     case 'execution_string_literal_tail':
1081        return new ExecutionStringLiteralTailToken(leading, trailing, token_text);
1082     case 'single_quoted_string_literal':
1083        return new SingleQuotedStringLiteralToken(leading, trailing, token_text);
1084     case 'double_quoted_string_literal':
1085        return new DoubleQuotedStringLiteralToken(leading, trailing, token_text);
1086     case 'double_quoted_string_literal_head':
1087        return new DoubleQuotedStringLiteralHeadToken(leading, trailing, token_text);
1088     case 'string_literal_body':
1089        return new StringLiteralBodyToken(leading, trailing, token_text);
1090     case 'double_quoted_string_literal_tail':
1091        return new DoubleQuotedStringLiteralTailToken(leading, trailing, token_text);
1092     case 'heredoc_string_literal':
1093        return new HeredocStringLiteralToken(leading, trailing, token_text);
1094     case 'heredoc_string_literal_head':
1095        return new HeredocStringLiteralHeadToken(leading, trailing, token_text);
1096     case 'heredoc_string_literal_tail':
1097        return new HeredocStringLiteralTailToken(leading, trailing, token_text);
1098     case 'nowdoc_string_literal':
1099        return new NowdocStringLiteralToken(leading, trailing, token_text);
1100     case 'boolean_literal':
1101        return new BooleanLiteralToken(leading, trailing, token_text);
1102     case 'XHP_category_name':
1103        return new XHPCategoryNameToken(leading, trailing, token_text);
1104     case 'XHP_element_name':
1105        return new XHPElementNameToken(leading, trailing, token_text);
1106     case 'XHP_class_name':
1107        return new XHPClassNameToken(leading, trailing, token_text);
1108     case 'XHP_string_literal':
1109        return new XHPStringLiteralToken(leading, trailing, token_text);
1110     case 'XHP_body':
1111        return new XHPBodyToken(leading, trailing, token_text);
1112     case 'XHP_comment':
1113        return new XHPCommentToken(leading, trailing, token_text);
1114     case 'markup':
1115        return new MarkupToken(leading, trailing, token_text);
1116
1117       default: throw 'unexpected token kind; ' + token_kind;
1118       // TODO: Better error
1119     }
1120   }
1121
1122   rewrite(rewriter, parents)
1123   {
1124     let new_parents = parents.slice();
1125     new_parents.push(this);
1126     let leading = this.leading.rewrite(rewriter, new_parents);
1127     let trailing = this.trailing.rewrite(rewriter, new_parents);
1128     if (leading === this.leading && trailing === this.trailing)
1129       return rewriter(this, parents);
1130     else
1131       return rewriter(EditableToken.factory(
1132         this.token_kind, leading, trailing, this.text), parents);
1133   }
1134
1135   reduce(reducer, accumulator)
1136   {
1137     accumulator = this.leading.reduce(reducer, accumulator);
1138     accumulator = reducer(this, accumulator);
1139     accumulator = this.trailing.reduce(reducer, accumulator);
1140     return accumulator;
1141   }
1142
1143   static from_json(json, position, source)
1144   {
1145     let leading_list = array_map_reduce(
1146       json.leading,
1147       (json, position) => EditableSyntax.from_json(json, position, source),
1148       (json, position) => json.width + position,
1149       position);
1150     let leading = EditableSyntax.to_list(leading_list);
1151     let token_position = position + leading.width;
1152     let token_text = source.substring(
1153       token_position, token_position + json.width);
1154     let trailing_position = token_position + json.width;
1155     let trailing_list = array_map_reduce(
1156       json.trailing,
1157       (json, position) => EditableSyntax.from_json(json, position, source),
1158       (json, position) => json.width + position,
1159       trailing_position);
1160     let trailing = EditableSyntax.to_list(trailing_list);
1161     return EditableToken.factory(json.kind, leading, trailing, token_text);
1162   }
1163
1164   get children_keys()
1165   {
1166     if (EditableToken._children_keys == null)
1167       EditableToken._children_keys = ['leading', 'trailing'];
1168     return EditableToken._children_keys;
1169   }
1170 }
1171
1172 class EndOfFileToken extends EditableToken
1173 {
1174   constructor(leading, trailing)
1175   {
1176     super('end_of_file', leading, trailing, '');
1177   }
1178 }
1179
1180 class AbstractToken extends EditableToken
1181 {
1182   constructor(leading, trailing)
1183   {
1184     super('abstract', leading, trailing, 'abstract');
1185   }
1186 }
1187 class AndToken extends EditableToken
1188 {
1189   constructor(leading, trailing)
1190   {
1191     super('and', leading, trailing, 'and');
1192   }
1193 }
1194 class ArrayToken extends EditableToken
1195 {
1196   constructor(leading, trailing)
1197   {
1198     super('array', leading, trailing, 'array');
1199   }
1200 }
1201 class ArraykeyToken extends EditableToken
1202 {
1203   constructor(leading, trailing)
1204   {
1205     super('arraykey', leading, trailing, 'arraykey');
1206   }
1207 }
1208 class AsToken extends EditableToken
1209 {
1210   constructor(leading, trailing)
1211   {
1212     super('as', leading, trailing, 'as');
1213   }
1214 }
1215 class AsyncToken extends EditableToken
1216 {
1217   constructor(leading, trailing)
1218   {
1219     super('async', leading, trailing, 'async');
1220   }
1221 }
1222 class AttributeToken extends EditableToken
1223 {
1224   constructor(leading, trailing)
1225   {
1226     super('attribute', leading, trailing, 'attribute');
1227   }
1228 }
1229 class AwaitToken extends EditableToken
1230 {
1231   constructor(leading, trailing)
1232   {
1233     super('await', leading, trailing, 'await');
1234   }
1235 }
1236 class BackslashToken extends EditableToken
1237 {
1238   constructor(leading, trailing)
1239   {
1240     super('\', leading, trailing, '\');
1241   }
1242 }
1243 class BoolToken extends EditableToken
1244 {
1245   constructor(leading, trailing)
1246   {
1247     super('bool', leading, trailing, 'bool');
1248   }
1249 }
1250 class BreakToken extends EditableToken
1251 {
1252   constructor(leading, trailing)
1253   {
1254     super('break', leading, trailing, 'break');
1255   }
1256 }
1257 class CaseToken extends EditableToken
1258 {
1259   constructor(leading, trailing)
1260   {
1261     super('case', leading, trailing, 'case');
1262   }
1263 }
1264 class CatchToken extends EditableToken
1265 {
1266   constructor(leading, trailing)
1267   {
1268     super('catch', leading, trailing, 'catch');
1269   }
1270 }
1271 class CategoryToken extends EditableToken
1272 {
1273   constructor(leading, trailing)
1274   {
1275     super('category', leading, trailing, 'category');
1276   }
1277 }
1278 class ChildrenToken extends EditableToken
1279 {
1280   constructor(leading, trailing)
1281   {
1282     super('children', leading, trailing, 'children');
1283   }
1284 }
1285 class ClassToken extends EditableToken
1286 {
1287   constructor(leading, trailing)
1288   {
1289     super('class', leading, trailing, 'class');
1290   }
1291 }
1292 class ClassnameToken extends EditableToken
1293 {
1294   constructor(leading, trailing)
1295   {
1296     super('classname', leading, trailing, 'classname');
1297   }
1298 }
1299 class CloneToken extends EditableToken
1300 {
1301   constructor(leading, trailing)
1302   {
1303     super('clone', leading, trailing, 'clone');
1304   }
1305 }
1306 class ConstToken extends EditableToken
1307 {
1308   constructor(leading, trailing)
1309   {
1310     super('const', leading, trailing, 'const');
1311   }
1312 }
1313 class ConstructToken extends EditableToken
1314 {
1315   constructor(leading, trailing)
1316   {
1317     super('__construct', leading, trailing, '__construct');
1318   }
1319 }
1320 class ContinueToken extends EditableToken
1321 {
1322   constructor(leading, trailing)
1323   {
1324     super('continue', leading, trailing, 'continue');
1325   }
1326 }
1327 class CoroutineToken extends EditableToken
1328 {
1329   constructor(leading, trailing)
1330   {
1331     super('coroutine', leading, trailing, 'coroutine');
1332   }
1333 }
1334 class DarrayToken extends EditableToken
1335 {
1336   constructor(leading, trailing)
1337   {
1338     super('darray', leading, trailing, 'darray');
1339   }
1340 }
1341 class DeclareToken extends EditableToken
1342 {
1343   constructor(leading, trailing)
1344   {
1345     super('declare', leading, trailing, 'declare');
1346   }
1347 }
1348 class DefaultToken extends EditableToken
1349 {
1350   constructor(leading, trailing)
1351   {
1352     super('default', leading, trailing, 'default');
1353   }
1354 }
1355 class DefineToken extends EditableToken
1356 {
1357   constructor(leading, trailing)
1358   {
1359     super('define', leading, trailing, 'define');
1360   }
1361 }
1362 class DestructToken extends EditableToken
1363 {
1364   constructor(leading, trailing)
1365   {
1366     super('__destruct', leading, trailing, '__destruct');
1367   }
1368 }
1369 class DictToken extends EditableToken
1370 {
1371   constructor(leading, trailing)
1372   {
1373     super('dict', leading, trailing, 'dict');
1374   }
1375 }
1376 class DoToken extends EditableToken
1377 {
1378   constructor(leading, trailing)
1379   {
1380     super('do', leading, trailing, 'do');
1381   }
1382 }
1383 class DoubleToken extends EditableToken
1384 {
1385   constructor(leading, trailing)
1386   {
1387     super('double', leading, trailing, 'double');
1388   }
1389 }
1390 class EchoToken extends EditableToken
1391 {
1392   constructor(leading, trailing)
1393   {
1394     super('echo', leading, trailing, 'echo');
1395   }
1396 }
1397 class ElseToken extends EditableToken
1398 {
1399   constructor(leading, trailing)
1400   {
1401     super('else', leading, trailing, 'else');
1402   }
1403 }
1404 class ElseifToken extends EditableToken
1405 {
1406   constructor(leading, trailing)
1407   {
1408     super('elseif', leading, trailing, 'elseif');
1409   }
1410 }
1411 class EmptyToken extends EditableToken
1412 {
1413   constructor(leading, trailing)
1414   {
1415     super('empty', leading, trailing, 'empty');
1416   }
1417 }
1418 class EndforToken extends EditableToken
1419 {
1420   constructor(leading, trailing)
1421   {
1422     super('endfor', leading, trailing, 'endfor');
1423   }
1424 }
1425 class EndforeachToken extends EditableToken
1426 {
1427   constructor(leading, trailing)
1428   {
1429     super('endforeach', leading, trailing, 'endforeach');
1430   }
1431 }
1432 class EnddeclareToken extends EditableToken
1433 {
1434   constructor(leading, trailing)
1435   {
1436     super('enddeclare', leading, trailing, 'enddeclare');
1437   }
1438 }
1439 class EndifToken extends EditableToken
1440 {
1441   constructor(leading, trailing)
1442   {
1443     super('endif', leading, trailing, 'endif');
1444   }
1445 }
1446 class EndswitchToken extends EditableToken
1447 {
1448   constructor(leading, trailing)
1449   {
1450     super('endswitch', leading, trailing, 'endswitch');
1451   }
1452 }
1453 class EndwhileToken extends EditableToken
1454 {
1455   constructor(leading, trailing)
1456   {
1457     super('endwhile', leading, trailing, 'endwhile');
1458   }
1459 }
1460 class EnumToken extends EditableToken
1461 {
1462   constructor(leading, trailing)
1463   {
1464     super('enum', leading, trailing, 'enum');
1465   }
1466 }
1467 class EvalToken extends EditableToken
1468 {
1469   constructor(leading, trailing)
1470   {
1471     super('eval', leading, trailing, 'eval');
1472   }
1473 }
1474 class ExtendsToken extends EditableToken
1475 {
1476   constructor(leading, trailing)
1477   {
1478     super('extends', leading, trailing, 'extends');
1479   }
1480 }
1481 class FallthroughToken extends EditableToken
1482 {
1483   constructor(leading, trailing)
1484   {
1485     super('fallthrough', leading, trailing, 'fallthrough');
1486   }
1487 }
1488 class FloatToken extends EditableToken
1489 {
1490   constructor(leading, trailing)
1491   {
1492     super('float', leading, trailing, 'float');
1493   }
1494 }
1495 class FinalToken extends EditableToken
1496 {
1497   constructor(leading, trailing)
1498   {
1499     super('final', leading, trailing, 'final');
1500   }
1501 }
1502 class FinallyToken extends EditableToken
1503 {
1504   constructor(leading, trailing)
1505   {
1506     super('finally', leading, trailing, 'finally');
1507   }
1508 }
1509 class ForToken extends EditableToken
1510 {
1511   constructor(leading, trailing)
1512   {
1513     super('for', leading, trailing, 'for');
1514   }
1515 }
1516 class ForeachToken extends EditableToken
1517 {
1518   constructor(leading, trailing)
1519   {
1520     super('foreach', leading, trailing, 'foreach');
1521   }
1522 }
1523 class FromToken extends EditableToken
1524 {
1525   constructor(leading, trailing)
1526   {
1527     super('from', leading, trailing, 'from');
1528   }
1529 }
1530 class FunctionToken extends EditableToken
1531 {
1532   constructor(leading, trailing)
1533   {
1534     super('function', leading, trailing, 'function');
1535   }
1536 }
1537 class GlobalToken extends EditableToken
1538 {
1539   constructor(leading, trailing)
1540   {
1541     super('global', leading, trailing, 'global');
1542   }
1543 }
1544 class GotoToken extends EditableToken
1545 {
1546   constructor(leading, trailing)
1547   {
1548     super('goto', leading, trailing, 'goto');
1549   }
1550 }
1551 class IfToken extends EditableToken
1552 {
1553   constructor(leading, trailing)
1554   {
1555     super('if', leading, trailing, 'if');
1556   }
1557 }
1558 class ImplementsToken extends EditableToken
1559 {
1560   constructor(leading, trailing)
1561   {
1562     super('implements', leading, trailing, 'implements');
1563   }
1564 }
1565 class IncludeToken extends EditableToken
1566 {
1567   constructor(leading, trailing)
1568   {
1569     super('include', leading, trailing, 'include');
1570   }
1571 }
1572 class Include_onceToken extends EditableToken
1573 {
1574   constructor(leading, trailing)
1575   {
1576     super('include_once', leading, trailing, 'include_once');
1577   }
1578 }
1579 class InoutToken extends EditableToken
1580 {
1581   constructor(leading, trailing)
1582   {
1583     super('inout', leading, trailing, 'inout');
1584   }
1585 }
1586 class InstanceofToken extends EditableToken
1587 {
1588   constructor(leading, trailing)
1589   {
1590     super('instanceof', leading, trailing, 'instanceof');
1591   }
1592 }
1593 class InsteadofToken extends EditableToken
1594 {
1595   constructor(leading, trailing)
1596   {
1597     super('insteadof', leading, trailing, 'insteadof');
1598   }
1599 }
1600 class IntToken extends EditableToken
1601 {
1602   constructor(leading, trailing)
1603   {
1604     super('int', leading, trailing, 'int');
1605   }
1606 }
1607 class InterfaceToken extends EditableToken
1608 {
1609   constructor(leading, trailing)
1610   {
1611     super('interface', leading, trailing, 'interface');
1612   }
1613 }
1614 class IsToken extends EditableToken
1615 {
1616   constructor(leading, trailing)
1617   {
1618     super('is', leading, trailing, 'is');
1619   }
1620 }
1621 class IssetToken extends EditableToken
1622 {
1623   constructor(leading, trailing)
1624   {
1625     super('isset', leading, trailing, 'isset');
1626   }
1627 }
1628 class KeysetToken extends EditableToken
1629 {
1630   constructor(leading, trailing)
1631   {
1632     super('keyset', leading, trailing, 'keyset');
1633   }
1634 }
1635 class ListToken extends EditableToken
1636 {
1637   constructor(leading, trailing)
1638   {
1639     super('list', leading, trailing, 'list');
1640   }
1641 }
1642 class MixedToken extends EditableToken
1643 {
1644   constructor(leading, trailing)
1645   {
1646     super('mixed', leading, trailing, 'mixed');
1647   }
1648 }
1649 class NamespaceToken extends EditableToken
1650 {
1651   constructor(leading, trailing)
1652   {
1653     super('namespace', leading, trailing, 'namespace');
1654   }
1655 }
1656 class NewToken extends EditableToken
1657 {
1658   constructor(leading, trailing)
1659   {
1660     super('new', leading, trailing, 'new');
1661   }
1662 }
1663 class NewtypeToken extends EditableToken
1664 {
1665   constructor(leading, trailing)
1666   {
1667     super('newtype', leading, trailing, 'newtype');
1668   }
1669 }
1670 class NoreturnToken extends EditableToken
1671 {
1672   constructor(leading, trailing)
1673   {
1674     super('noreturn', leading, trailing, 'noreturn');
1675   }
1676 }
1677 class NumToken extends EditableToken
1678 {
1679   constructor(leading, trailing)
1680   {
1681     super('num', leading, trailing, 'num');
1682   }
1683 }
1684 class ObjectToken extends EditableToken
1685 {
1686   constructor(leading, trailing)
1687   {
1688     super('object', leading, trailing, 'object');
1689   }
1690 }
1691 class OrToken extends EditableToken
1692 {
1693   constructor(leading, trailing)
1694   {
1695     super('or', leading, trailing, 'or');
1696   }
1697 }
1698 class ParentToken extends EditableToken
1699 {
1700   constructor(leading, trailing)
1701   {
1702     super('parent', leading, trailing, 'parent');
1703   }
1704 }
1705 class PrintToken extends EditableToken
1706 {
1707   constructor(leading, trailing)
1708   {
1709     super('print', leading, trailing, 'print');
1710   }
1711 }
1712 class PrivateToken extends EditableToken
1713 {
1714   constructor(leading, trailing)
1715   {
1716     super('private', leading, trailing, 'private');
1717   }
1718 }
1719 class ProtectedToken extends EditableToken
1720 {
1721   constructor(leading, trailing)
1722   {
1723     super('protected', leading, trailing, 'protected');
1724   }
1725 }
1726 class PublicToken extends EditableToken
1727 {
1728   constructor(leading, trailing)
1729   {
1730     super('public', leading, trailing, 'public');
1731   }
1732 }
1733 class RequireToken extends EditableToken
1734 {
1735   constructor(leading, trailing)
1736   {
1737     super('require', leading, trailing, 'require');
1738   }
1739 }
1740 class Require_onceToken extends EditableToken
1741 {
1742   constructor(leading, trailing)
1743   {
1744     super('require_once', leading, trailing, 'require_once');
1745   }
1746 }
1747 class RequiredToken extends EditableToken
1748 {
1749   constructor(leading, trailing)
1750   {
1751     super('required', leading, trailing, 'required');
1752   }
1753 }
1754 class ResourceToken extends EditableToken
1755 {
1756   constructor(leading, trailing)
1757   {
1758     super('resource', leading, trailing, 'resource');
1759   }
1760 }
1761 class ReturnToken extends EditableToken
1762 {
1763   constructor(leading, trailing)
1764   {
1765     super('return', leading, trailing, 'return');
1766   }
1767 }
1768 class SelfToken extends EditableToken
1769 {
1770   constructor(leading, trailing)
1771   {
1772     super('self', leading, trailing, 'self');
1773   }
1774 }
1775 class ShapeToken extends EditableToken
1776 {
1777   constructor(leading, trailing)
1778   {
1779     super('shape', leading, trailing, 'shape');
1780   }
1781 }
1782 class StaticToken extends EditableToken
1783 {
1784   constructor(leading, trailing)
1785   {
1786     super('static', leading, trailing, 'static');
1787   }
1788 }
1789 class StringToken extends EditableToken
1790 {
1791   constructor(leading, trailing)
1792   {
1793     super('string', leading, trailing, 'string');
1794   }
1795 }
1796 class SuperToken extends EditableToken
1797 {
1798   constructor(leading, trailing)
1799   {
1800     super('super', leading, trailing, 'super');
1801   }
1802 }
1803 class SuspendToken extends EditableToken
1804 {
1805   constructor(leading, trailing)
1806   {
1807     super('suspend', leading, trailing, 'suspend');
1808   }
1809 }
1810 class SwitchToken extends EditableToken
1811 {
1812   constructor(leading, trailing)
1813   {
1814     super('switch', leading, trailing, 'switch');
1815   }
1816 }
1817 class ThisToken extends EditableToken
1818 {
1819   constructor(leading, trailing)
1820   {
1821     super('this', leading, trailing, 'this');
1822   }
1823 }
1824 class ThrowToken extends EditableToken
1825 {
1826   constructor(leading, trailing)
1827   {
1828     super('throw', leading, trailing, 'throw');
1829   }
1830 }
1831 class TraitToken extends EditableToken
1832 {
1833   constructor(leading, trailing)
1834   {
1835     super('trait', leading, trailing, 'trait');
1836   }
1837 }
1838 class TryToken extends EditableToken
1839 {
1840   constructor(leading, trailing)
1841   {
1842     super('try', leading, trailing, 'try');
1843   }
1844 }
1845 class TupleToken extends EditableToken
1846 {
1847   constructor(leading, trailing)
1848   {
1849     super('tuple', leading, trailing, 'tuple');
1850   }
1851 }
1852 class TypeToken extends EditableToken
1853 {
1854   constructor(leading, trailing)
1855   {
1856     super('type', leading, trailing, 'type');
1857   }
1858 }
1859 class UnsetToken extends EditableToken
1860 {
1861   constructor(leading, trailing)
1862   {
1863     super('unset', leading, trailing, 'unset');
1864   }
1865 }
1866 class UseToken extends EditableToken
1867 {
1868   constructor(leading, trailing)
1869   {
1870     super('use', leading, trailing, 'use');
1871   }
1872 }
1873 class UsingToken extends EditableToken
1874 {
1875   constructor(leading, trailing)
1876   {
1877     super('using', leading, trailing, 'using');
1878   }
1879 }
1880 class VarToken extends EditableToken
1881 {
1882   constructor(leading, trailing)
1883   {
1884     super('var', leading, trailing, 'var');
1885   }
1886 }
1887 class VarrayToken extends EditableToken
1888 {
1889   constructor(leading, trailing)
1890   {
1891     super('varray', leading, trailing, 'varray');
1892   }
1893 }
1894 class VecToken extends EditableToken
1895 {
1896   constructor(leading, trailing)
1897   {
1898     super('vec', leading, trailing, 'vec');
1899   }
1900 }
1901 class VoidToken extends EditableToken
1902 {
1903   constructor(leading, trailing)
1904   {
1905     super('void', leading, trailing, 'void');
1906   }
1907 }
1908 class WhereToken extends EditableToken
1909 {
1910   constructor(leading, trailing)
1911   {
1912     super('where', leading, trailing, 'where');
1913   }
1914 }
1915 class WhileToken extends EditableToken
1916 {
1917   constructor(leading, trailing)
1918   {
1919     super('while', leading, trailing, 'while');
1920   }
1921 }
1922 class XorToken extends EditableToken
1923 {
1924   constructor(leading, trailing)
1925   {
1926     super('xor', leading, trailing, 'xor');
1927   }
1928 }
1929 class YieldToken extends EditableToken
1930 {
1931   constructor(leading, trailing)
1932   {
1933     super('yield', leading, trailing, 'yield');
1934   }
1935 }
1936 class LeftBracketToken extends EditableToken
1937 {
1938   constructor(leading, trailing)
1939   {
1940     super('[', leading, trailing, '[');
1941   }
1942 }
1943 class RightBracketToken extends EditableToken
1944 {
1945   constructor(leading, trailing)
1946   {
1947     super(']', leading, trailing, ']');
1948   }
1949 }
1950 class LeftParenToken extends EditableToken
1951 {
1952   constructor(leading, trailing)
1953   {
1954     super('(', leading, trailing, '(');
1955   }
1956 }
1957 class RightParenToken extends EditableToken
1958 {
1959   constructor(leading, trailing)
1960   {
1961     super(')', leading, trailing, ')');
1962   }
1963 }
1964 class LeftBraceToken extends EditableToken
1965 {
1966   constructor(leading, trailing)
1967   {
1968     super('{', leading, trailing, '{');
1969   }
1970 }
1971 class RightBraceToken extends EditableToken
1972 {
1973   constructor(leading, trailing)
1974   {
1975     super('}', leading, trailing, '}');
1976   }
1977 }
1978 class DotToken extends EditableToken
1979 {
1980   constructor(leading, trailing)
1981   {
1982     super('.', leading, trailing, '.');
1983   }
1984 }
1985 class MinusGreaterThanToken extends EditableToken
1986 {
1987   constructor(leading, trailing)
1988   {
1989     super('->', leading, trailing, '->');
1990   }
1991 }
1992 class PlusPlusToken extends EditableToken
1993 {
1994   constructor(leading, trailing)
1995   {
1996     super('++', leading, trailing, '++');
1997   }
1998 }
1999 class MinusMinusToken extends EditableToken
2000 {
2001   constructor(leading, trailing)
2002   {
2003     super('--', leading, trailing, '--');
2004   }
2005 }
2006 class StarStarToken extends EditableToken
2007 {
2008   constructor(leading, trailing)
2009   {
2010     super('**', leading, trailing, '**');
2011   }
2012 }
2013 class StarToken extends EditableToken
2014 {
2015   constructor(leading, trailing)
2016   {
2017     super('*', leading, trailing, '*');
2018   }
2019 }
2020 class PlusToken extends EditableToken
2021 {
2022   constructor(leading, trailing)
2023   {
2024     super('+', leading, trailing, '+');
2025   }
2026 }
2027 class MinusToken extends EditableToken
2028 {
2029   constructor(leading, trailing)
2030   {
2031     super('-', leading, trailing, '-');
2032   }
2033 }
2034 class TildeToken extends EditableToken
2035 {
2036   constructor(leading, trailing)
2037   {
2038     super('~', leading, trailing, '~');
2039   }
2040 }
2041 class ExclamationToken extends EditableToken
2042 {
2043   constructor(leading, trailing)
2044   {
2045     super('!', leading, trailing, '!');
2046   }
2047 }
2048 class DollarToken extends EditableToken
2049 {
2050   constructor(leading, trailing)
2051   {
2052     super('$', leading, trailing, '$');
2053   }
2054 }
2055 class SlashToken extends EditableToken
2056 {
2057   constructor(leading, trailing)
2058   {
2059     super('/', leading, trailing, '/');
2060   }
2061 }
2062 class PercentToken extends EditableToken
2063 {
2064   constructor(leading, trailing)
2065   {
2066     super('%', leading, trailing, '%');
2067   }
2068 }
2069 class LessThanGreaterThanToken extends EditableToken
2070 {
2071   constructor(leading, trailing)
2072   {
2073     super('<>', leading, trailing, '<>');
2074   }
2075 }
2076 class LessThanEqualGreaterThanToken extends EditableToken
2077 {
2078   constructor(leading, trailing)
2079   {
2080     super('<=>', leading, trailing, '<=>');
2081   }
2082 }
2083 class LessThanLessThanToken extends EditableToken
2084 {
2085   constructor(leading, trailing)
2086   {
2087     super('<<', leading, trailing, '<<');
2088   }
2089 }
2090 class GreaterThanGreaterThanToken extends EditableToken
2091 {
2092   constructor(leading, trailing)
2093   {
2094     super('>>', leading, trailing, '>>');
2095   }
2096 }
2097 class LessThanToken extends EditableToken
2098 {
2099   constructor(leading, trailing)
2100   {
2101     super('<', leading, trailing, '<');
2102   }
2103 }
2104 class GreaterThanToken extends EditableToken
2105 {
2106   constructor(leading, trailing)
2107   {
2108     super('>', leading, trailing, '>');
2109   }
2110 }
2111 class LessThanEqualToken extends EditableToken
2112 {
2113   constructor(leading, trailing)
2114   {
2115     super('<=', leading, trailing, '<=');
2116   }
2117 }
2118 class GreaterThanEqualToken extends EditableToken
2119 {
2120   constructor(leading, trailing)
2121   {
2122     super('>=', leading, trailing, '>=');
2123   }
2124 }
2125 class EqualEqualToken extends EditableToken
2126 {
2127   constructor(leading, trailing)
2128   {
2129     super('==', leading, trailing, '==');
2130   }
2131 }
2132 class EqualEqualEqualToken extends EditableToken
2133 {
2134   constructor(leading, trailing)
2135   {
2136     super('===', leading, trailing, '===');
2137   }
2138 }
2139 class ExclamationEqualToken extends EditableToken
2140 {
2141   constructor(leading, trailing)
2142   {
2143     super('!=', leading, trailing, '!=');
2144   }
2145 }
2146 class ExclamationEqualEqualToken extends EditableToken
2147 {
2148   constructor(leading, trailing)
2149   {
2150     super('!==', leading, trailing, '!==');
2151   }
2152 }
2153 class CaratToken extends EditableToken
2154 {
2155   constructor(leading, trailing)
2156   {
2157     super('^', leading, trailing, '^');
2158   }
2159 }
2160 class BarToken extends EditableToken
2161 {
2162   constructor(leading, trailing)
2163   {
2164     super('|', leading, trailing, '|');
2165   }
2166 }
2167 class AmpersandToken extends EditableToken
2168 {
2169   constructor(leading, trailing)
2170   {
2171     super('&', leading, trailing, '&');
2172   }
2173 }
2174 class AmpersandAmpersandToken extends EditableToken
2175 {
2176   constructor(leading, trailing)
2177   {
2178     super('&&', leading, trailing, '&&');
2179   }
2180 }
2181 class BarBarToken extends EditableToken
2182 {
2183   constructor(leading, trailing)
2184   {
2185     super('||', leading, trailing, '||');
2186   }
2187 }
2188 class QuestionToken extends EditableToken
2189 {
2190   constructor(leading, trailing)
2191   {
2192     super('?', leading, trailing, '?');
2193   }
2194 }
2195 class QuestionColonToken extends EditableToken
2196 {
2197   constructor(leading, trailing)
2198   {
2199     super('?:', leading, trailing, '?:');
2200   }
2201 }
2202 class QuestionQuestionToken extends EditableToken
2203 {
2204   constructor(leading, trailing)
2205   {
2206     super('??', leading, trailing, '??');
2207   }
2208 }
2209 class ColonToken extends EditableToken
2210 {
2211   constructor(leading, trailing)
2212   {
2213     super(':', leading, trailing, ':');
2214   }
2215 }
2216 class SemicolonToken extends EditableToken
2217 {
2218   constructor(leading, trailing)
2219   {
2220     super(';', leading, trailing, ';');
2221   }
2222 }
2223 class EqualToken extends EditableToken
2224 {
2225   constructor(leading, trailing)
2226   {
2227     super('=', leading, trailing, '=');
2228   }
2229 }
2230 class StarStarEqualToken extends EditableToken
2231 {
2232   constructor(leading, trailing)
2233   {
2234     super('**=', leading, trailing, '**=');
2235   }
2236 }
2237 class StarEqualToken extends EditableToken
2238 {
2239   constructor(leading, trailing)
2240   {
2241     super('*=', leading, trailing, '*=');
2242   }
2243 }
2244 class SlashEqualToken extends EditableToken
2245 {
2246   constructor(leading, trailing)
2247   {
2248     super('/=', leading, trailing, '/=');
2249   }
2250 }
2251 class PercentEqualToken extends EditableToken
2252 {
2253   constructor(leading, trailing)
2254   {
2255     super('%=', leading, trailing, '%=');
2256   }
2257 }
2258 class PlusEqualToken extends EditableToken
2259 {
2260   constructor(leading, trailing)
2261   {
2262     super('+=', leading, trailing, '+=');
2263   }
2264 }
2265 class MinusEqualToken extends EditableToken
2266 {
2267   constructor(leading, trailing)
2268   {
2269     super('-=', leading, trailing, '-=');
2270   }
2271 }
2272 class DotEqualToken extends EditableToken
2273 {
2274   constructor(leading, trailing)
2275   {
2276     super('.=', leading, trailing, '.=');
2277   }
2278 }
2279 class LessThanLessThanEqualToken extends EditableToken
2280 {
2281   constructor(leading, trailing)
2282   {
2283     super('<<=', leading, trailing, '<<=');
2284   }
2285 }
2286 class GreaterThanGreaterThanEqualToken extends EditableToken
2287 {
2288   constructor(leading, trailing)
2289   {
2290     super('>>=', leading, trailing, '>>=');
2291   }
2292 }
2293 class AmpersandEqualToken extends EditableToken
2294 {
2295   constructor(leading, trailing)
2296   {
2297     super('&=', leading, trailing, '&=');
2298   }
2299 }
2300 class CaratEqualToken extends EditableToken
2301 {
2302   constructor(leading, trailing)
2303   {
2304     super('^=', leading, trailing, '^=');
2305   }
2306 }
2307 class BarEqualToken extends EditableToken
2308 {
2309   constructor(leading, trailing)
2310   {
2311     super('|=', leading, trailing, '|=');
2312   }
2313 }
2314 class CommaToken extends EditableToken
2315 {
2316   constructor(leading, trailing)
2317   {
2318     super(',', leading, trailing, ',');
2319   }
2320 }
2321 class AtToken extends EditableToken
2322 {
2323   constructor(leading, trailing)
2324   {
2325     super('@', leading, trailing, '@');
2326   }
2327 }
2328 class ColonColonToken extends EditableToken
2329 {
2330   constructor(leading, trailing)
2331   {
2332     super('::', leading, trailing, '::');
2333   }
2334 }
2335 class EqualGreaterThanToken extends EditableToken
2336 {
2337   constructor(leading, trailing)
2338   {
2339     super('=>', leading, trailing, '=>');
2340   }
2341 }
2342 class EqualEqualGreaterThanToken extends EditableToken
2343 {
2344   constructor(leading, trailing)
2345   {
2346     super('==>', leading, trailing, '==>');
2347   }
2348 }
2349 class QuestionMinusGreaterThanToken extends EditableToken
2350 {
2351   constructor(leading, trailing)
2352   {
2353     super('?->', leading, trailing, '?->');
2354   }
2355 }
2356 class DotDotDotToken extends EditableToken
2357 {
2358   constructor(leading, trailing)
2359   {
2360     super('...', leading, trailing, '...');
2361   }
2362 }
2363 class DollarDollarToken extends EditableToken
2364 {
2365   constructor(leading, trailing)
2366   {
2367     super('$$', leading, trailing, '$$');
2368   }
2369 }
2370 class BarGreaterThanToken extends EditableToken
2371 {
2372   constructor(leading, trailing)
2373   {
2374     super('|>', leading, trailing, '|>');
2375   }
2376 }
2377 class NullLiteralToken extends EditableToken
2378 {
2379   constructor(leading, trailing)
2380   {
2381     super('null', leading, trailing, 'null');
2382   }
2383 }
2384 class SlashGreaterThanToken extends EditableToken
2385 {
2386   constructor(leading, trailing)
2387   {
2388     super('/>', leading, trailing, '/>');
2389   }
2390 }
2391 class LessThanSlashToken extends EditableToken
2392 {
2393   constructor(leading, trailing)
2394   {
2395     super('</', leading, trailing, '</');
2396   }
2397 }
2398 class LessThanQuestionToken extends EditableToken
2399 {
2400   constructor(leading, trailing)
2401   {
2402     super('<?', leading, trailing, '<?');
2403   }
2404 }
2405 class QuestionGreaterThanToken extends EditableToken
2406 {
2407   constructor(leading, trailing)
2408   {
2409     super('?>', leading, trailing, '?>');
2410   }
2411 }
2412 class HaltCompilerToken extends EditableToken
2413 {
2414   constructor(leading, trailing)
2415   {
2416     super('__halt_compiler', leading, trailing, '__halt_compiler');
2417   }
2418 }
2419
2420 class ErrorTokenToken extends EditableToken
2421 {
2422   constructor(leading, trailing, text)
2423   {
2424     super('error_token', leading, trailing, text);
2425   }
2426   with_text(text)
2427   {
2428     return new ErrorTokenToken(this.leading, this.trailing, text);
2429   }
2430
2431 }
2432 class NameToken extends EditableToken
2433 {
2434   constructor(leading, trailing, text)
2435   {
2436     super('name', leading, trailing, text);
2437   }
2438   with_text(text)
2439   {
2440     return new NameToken(this.leading, this.trailing, text);
2441   }
2442
2443 }
2444 class VariableToken extends EditableToken
2445 {
2446   constructor(leading, trailing, text)
2447   {
2448     super('variable', leading, trailing, text);
2449   }
2450   with_text(text)
2451   {
2452     return new VariableToken(this.leading, this.trailing, text);
2453   }
2454
2455 }
2456 class DecimalLiteralToken extends EditableToken
2457 {
2458   constructor(leading, trailing, text)
2459   {
2460     super('decimal_literal', leading, trailing, text);
2461   }
2462   with_text(text)
2463   {
2464     return new DecimalLiteralToken(this.leading, this.trailing, text);
2465   }
2466
2467 }
2468 class OctalLiteralToken extends EditableToken
2469 {
2470   constructor(leading, trailing, text)
2471   {
2472     super('octal_literal', leading, trailing, text);
2473   }
2474   with_text(text)
2475   {
2476     return new OctalLiteralToken(this.leading, this.trailing, text);
2477   }
2478
2479 }
2480 class HexadecimalLiteralToken extends EditableToken
2481 {
2482   constructor(leading, trailing, text)
2483   {
2484     super('hexadecimal_literal', leading, trailing, text);
2485   }
2486   with_text(text)
2487   {
2488     return new HexadecimalLiteralToken(this.leading, this.trailing, text);
2489   }
2490
2491 }
2492 class BinaryLiteralToken extends EditableToken
2493 {
2494   constructor(leading, trailing, text)
2495   {
2496     super('binary_literal', leading, trailing, text);
2497   }
2498   with_text(text)
2499   {
2500     return new BinaryLiteralToken(this.leading, this.trailing, text);
2501   }
2502
2503 }
2504 class FloatingLiteralToken extends EditableToken
2505 {
2506   constructor(leading, trailing, text)
2507   {
2508     super('floating_literal', leading, trailing, text);
2509   }
2510   with_text(text)
2511   {
2512     return new FloatingLiteralToken(this.leading, this.trailing, text);
2513   }
2514
2515 }
2516 class ExecutionStringLiteralToken extends EditableToken
2517 {
2518   constructor(leading, trailing, text)
2519   {
2520     super('execution_string_literal', leading, trailing, text);
2521   }
2522   with_text(text)
2523   {
2524     return new ExecutionStringLiteralToken(this.leading, this.trailing, text);
2525   }
2526
2527 }
2528 class ExecutionStringLiteralHeadToken extends EditableToken
2529 {
2530   constructor(leading, trailing, text)
2531   {
2532     super('execution_string_literal_head', leading, trailing, text);
2533   }
2534   with_text(text)
2535   {
2536     return new ExecutionStringLiteralHeadToken(this.leading, this.trailing, text);
2537   }
2538
2539 }
2540 class ExecutionStringLiteralTailToken extends EditableToken
2541 {
2542   constructor(leading, trailing, text)
2543   {
2544     super('execution_string_literal_tail', leading, trailing, text);
2545   }
2546   with_text(text)
2547   {
2548     return new ExecutionStringLiteralTailToken(this.leading, this.trailing, text);
2549   }
2550
2551 }
2552 class SingleQuotedStringLiteralToken extends EditableToken
2553 {
2554   constructor(leading, trailing, text)
2555   {
2556     super('single_quoted_string_literal', leading, trailing, text);
2557   }
2558   with_text(text)
2559   {
2560     return new SingleQuotedStringLiteralToken(this.leading, this.trailing, text);
2561   }
2562
2563 }
2564 class DoubleQuotedStringLiteralToken extends EditableToken
2565 {
2566   constructor(leading, trailing, text)
2567   {
2568     super('double_quoted_string_literal', leading, trailing, text);
2569   }
2570   with_text(text)
2571   {
2572     return new DoubleQuotedStringLiteralToken(this.leading, this.trailing, text);
2573   }
2574
2575 }
2576 class DoubleQuotedStringLiteralHeadToken extends EditableToken
2577 {
2578   constructor(leading, trailing, text)
2579   {
2580     super('double_quoted_string_literal_head', leading, trailing, text);
2581   }
2582   with_text(text)
2583   {
2584     return new DoubleQuotedStringLiteralHeadToken(this.leading, this.trailing, text);
2585   }
2586
2587 }
2588 class StringLiteralBodyToken extends EditableToken
2589 {
2590   constructor(leading, trailing, text)
2591   {
2592     super('string_literal_body', leading, trailing, text);
2593   }
2594   with_text(text)
2595   {
2596     return new StringLiteralBodyToken(this.leading, this.trailing, text);
2597   }
2598
2599 }
2600 class DoubleQuotedStringLiteralTailToken extends EditableToken
2601 {
2602   constructor(leading, trailing, text)
2603   {
2604     super('double_quoted_string_literal_tail', leading, trailing, text);
2605   }
2606   with_text(text)
2607   {
2608     return new DoubleQuotedStringLiteralTailToken(this.leading, this.trailing, text);
2609   }
2610
2611 }
2612 class HeredocStringLiteralToken extends EditableToken
2613 {
2614   constructor(leading, trailing, text)
2615   {
2616     super('heredoc_string_literal', leading, trailing, text);
2617   }
2618   with_text(text)
2619   {
2620     return new HeredocStringLiteralToken(this.leading, this.trailing, text);
2621   }
2622
2623 }
2624 class HeredocStringLiteralHeadToken extends EditableToken
2625 {
2626   constructor(leading, trailing, text)
2627   {
2628     super('heredoc_string_literal_head', leading, trailing, text);
2629   }
2630   with_text(text)
2631   {
2632     return new HeredocStringLiteralHeadToken(this.leading, this.trailing, text);
2633   }
2634
2635 }
2636 class HeredocStringLiteralTailToken extends EditableToken
2637 {
2638   constructor(leading, trailing, text)
2639   {
2640     super('heredoc_string_literal_tail', leading, trailing, text);
2641   }
2642   with_text(text)
2643   {
2644     return new HeredocStringLiteralTailToken(this.leading, this.trailing, text);
2645   }
2646
2647 }
2648 class NowdocStringLiteralToken extends EditableToken
2649 {
2650   constructor(leading, trailing, text)
2651   {
2652     super('nowdoc_string_literal', leading, trailing, text);
2653   }
2654   with_text(text)
2655   {
2656     return new NowdocStringLiteralToken(this.leading, this.trailing, text);
2657   }
2658
2659 }
2660 class BooleanLiteralToken extends EditableToken
2661 {
2662   constructor(leading, trailing, text)
2663   {
2664     super('boolean_literal', leading, trailing, text);
2665   }
2666   with_text(text)
2667   {
2668     return new BooleanLiteralToken(this.leading, this.trailing, text);
2669   }
2670
2671 }
2672 class XHPCategoryNameToken extends EditableToken
2673 {
2674   constructor(leading, trailing, text)
2675   {
2676     super('XHP_category_name', leading, trailing, text);
2677   }
2678   with_text(text)
2679   {
2680     return new XHPCategoryNameToken(this.leading, this.trailing, text);
2681   }
2682
2683 }
2684 class XHPElementNameToken extends EditableToken
2685 {
2686   constructor(leading, trailing, text)
2687   {
2688     super('XHP_element_name', leading, trailing, text);
2689   }
2690   with_text(text)
2691   {
2692     return new XHPElementNameToken(this.leading, this.trailing, text);
2693   }
2694
2695 }
2696 class XHPClassNameToken extends EditableToken
2697 {
2698   constructor(leading, trailing, text)
2699   {
2700     super('XHP_class_name', leading, trailing, text);
2701   }
2702   with_text(text)
2703   {
2704     return new XHPClassNameToken(this.leading, this.trailing, text);
2705   }
2706
2707 }
2708 class XHPStringLiteralToken extends EditableToken
2709 {
2710   constructor(leading, trailing, text)
2711   {
2712     super('XHP_string_literal', leading, trailing, text);
2713   }
2714   with_text(text)
2715   {
2716     return new XHPStringLiteralToken(this.leading, this.trailing, text);
2717   }
2718
2719 }
2720 class XHPBodyToken extends EditableToken
2721 {
2722   constructor(leading, trailing, text)
2723   {
2724     super('XHP_body', leading, trailing, text);
2725   }
2726   with_text(text)
2727   {
2728     return new XHPBodyToken(this.leading, this.trailing, text);
2729   }
2730
2731 }
2732 class XHPCommentToken extends EditableToken
2733 {
2734   constructor(leading, trailing, text)
2735   {
2736     super('XHP_comment', leading, trailing, text);
2737   }
2738   with_text(text)
2739   {
2740     return new XHPCommentToken(this.leading, this.trailing, text);
2741   }
2742
2743 }
2744 class MarkupToken extends EditableToken
2745 {
2746   constructor(leading, trailing, text)
2747   {
2748     super('markup', leading, trailing, text);
2749   }
2750   with_text(text)
2751   {
2752     return new MarkupToken(this.leading, this.trailing, text);
2753   }
2754
2755 }
2756
2757
2758 class EditableTrivia extends EditableSyntax
2759 {
2760   constructor(trivia_kind, text)
2761   {
2762     super(trivia_kind, {});
2763     this._text = text;
2764   }
2765   get text() { return this._text; }
2766   get full_text() { return this.text; }
2767   get width() { return this.text.length; }
2768   get is_trivia() { return true; }
2769
2770   static from_json(json, position, source)
2771   {
2772     let trivia_text = source.substring(position, position + json.width);
2773     switch(json.kind)
2774     {
2775       case 'whitespace':
2776         return new WhiteSpace(trivia_text);
2777       case 'end_of_line':
2778         return new EndOfLine(trivia_text);
2779       case 'delimited_comment':
2780         return new DelimitedComment(trivia_text);
2781       case 'single_line_comment':
2782         return new SingleLineComment(trivia_text);
2783       case 'unsafe':
2784         return new Unsafe(trivia_text);
2785       case 'unsafe_expression':
2786         return new UnsafeExpression(trivia_text);
2787       case 'fix_me':
2788         return new FixMe(trivia_text);
2789       case 'ignore_error':
2790         return new IgnoreError(trivia_text);
2791       case 'fall_through':
2792         return new FallThrough(trivia_text);
2793       case 'extra_token_error':
2794         return new ExtraTokenError(trivia_text);
2795       case 'after_halt_compiler':
2796         return new AfterHaltCompiler(trivia_text);
2797
2798       default: throw 'unexpected json kind: ' + json.kind; // TODO: Better error
2799     }
2800   }
2801
2802   rewrite(rewriter, parents)
2803   {
2804     return rewriter(this, parents);
2805   }
2806   get children_keys()
2807   {
2808     return [];
2809   }
2810 }
2811
2812 class WhiteSpace extends EditableTrivia
2813 {
2814   constructor(text) { super('whitespace', text); }
2815   with_text(text)
2816   {
2817     return new WhiteSpace(text);
2818   }
2819 }
2820
2821 class EndOfLine extends EditableTrivia
2822 {
2823   constructor(text) { super('end_of_line', text); }
2824   with_text(text)
2825   {
2826     return new EndOfLine(text);
2827   }
2828 }
2829
2830 class DelimitedComment extends EditableTrivia
2831 {
2832   constructor(text) { super('delimited_comment', text); }
2833   with_text(text)
2834   {
2835     return new DelimitedComment(text);
2836   }
2837 }
2838
2839 class SingleLineComment extends EditableTrivia
2840 {
2841   constructor(text) { super('single_line_comment', text); }
2842   with_text(text)
2843   {
2844     return new SingleLineComment(text);
2845   }
2846 }
2847
2848 class Unsafe extends EditableTrivia
2849 {
2850   constructor(text) { super('unsafe', text); }
2851   with_text(text)
2852   {
2853     return new Unsafe(text);
2854   }
2855 }
2856
2857 class UnsafeExpression extends EditableTrivia
2858 {
2859   constructor(text) { super('unsafe_expression', text); }
2860   with_text(text)
2861   {
2862     return new UnsafeExpression(text);
2863   }
2864 }
2865
2866 class FixMe extends EditableTrivia
2867 {
2868   constructor(text) { super('fix_me', text); }
2869   with_text(text)
2870   {
2871     return new FixMe(text);
2872   }
2873 }
2874
2875 class IgnoreError extends EditableTrivia
2876 {
2877   constructor(text) { super('ignore_error', text); }
2878   with_text(text)
2879   {
2880     return new IgnoreError(text);
2881   }
2882 }
2883
2884 class FallThrough extends EditableTrivia
2885 {
2886   constructor(text) { super('fall_through', text); }
2887   with_text(text)
2888   {
2889     return new FallThrough(text);
2890   }
2891 }
2892
2893 class ExtraTokenError extends EditableTrivia
2894 {
2895   constructor(text) { super('extra_token_error', text); }
2896   with_text(text)
2897   {
2898     return new ExtraTokenError(text);
2899   }
2900 }
2901
2902 class AfterHaltCompiler extends EditableTrivia
2903 {
2904   constructor(text) { super('after_halt_compiler', text); }
2905   with_text(text)
2906   {
2907     return new AfterHaltCompiler(text);
2908   }
2909 }
2910
2911
2912
2913 class Missing extends EditableSyntax
2914 {
2915   constructor()
2916   {
2917     super('missing', {});
2918   }
2919   get is_missing() { return true; }
2920   static get missing() { return Missing._missing; }
2921   static from_json(json, position, source)
2922   {
2923     return Missing._missing;
2924   }
2925   rewrite(rewriter, parents)
2926   {
2927     return rewriter(this, parents);
2928   }
2929   get children_keys()
2930   {
2931     return [];
2932   }
2933 }
2934 Missing._missing = new Missing();
2935
2936 class EndOfFile extends EditableSyntax
2937 {
2938   constructor(
2939     token)
2940   {
2941     super('end_of_file', {
2942       token: token });
2943   }
2944   get token() { return this.children.token; }
2945   with_token(token){
2946     return new EndOfFile(
2947       token);
2948   }
2949   rewrite(rewriter, parents)
2950   {
2951     if (parents == undefined)
2952       parents = [];
2953     let new_parents = parents.slice();
2954     new_parents.push(this);
2955     var token = this.token.rewrite(rewriter, new_parents);
2956     if (
2957       token === this.token)
2958     {
2959       return rewriter(this, parents);
2960     }
2961     else
2962     {
2963       return rewriter(new EndOfFile(
2964         token), parents);
2965     }
2966   }
2967   static from_json(json, position, source)
2968   {
2969     let token = EditableSyntax.from_json(
2970       json.end_of_file_token, position, source);
2971     position += token.width;
2972     return new EndOfFile(
2973         token);
2974   }
2975   get children_keys()
2976   {
2977     if (EndOfFile._children_keys == null)
2978       EndOfFile._children_keys = [
2979         'token'];
2980     return EndOfFile._children_keys;
2981   }
2982 }
2983 class Script extends EditableSyntax
2984 {
2985   constructor(
2986     declarations)
2987   {
2988     super('script', {
2989       declarations: declarations });
2990   }
2991   get declarations() { return this.children.declarations; }
2992   with_declarations(declarations){
2993     return new Script(
2994       declarations);
2995   }
2996   rewrite(rewriter, parents)
2997   {
2998     if (parents == undefined)
2999       parents = [];
3000     let new_parents = parents.slice();
3001     new_parents.push(this);
3002     var declarations = this.declarations.rewrite(rewriter, new_parents);
3003     if (
3004       declarations === this.declarations)
3005     {
3006       return rewriter(this, parents);
3007     }
3008     else
3009     {
3010       return rewriter(new Script(
3011         declarations), parents);
3012     }
3013   }
3014   static from_json(json, position, source)
3015   {
3016     let declarations = EditableSyntax.from_json(
3017       json.script_declarations, position, source);
3018     position += declarations.width;
3019     return new Script(
3020         declarations);
3021   }
3022   get children_keys()
3023   {
3024     if (Script._children_keys == null)
3025       Script._children_keys = [
3026         'declarations'];
3027     return Script._children_keys;
3028   }
3029 }
3030 class QualifiedName extends EditableSyntax
3031 {
3032   constructor(
3033     parts)
3034   {
3035     super('qualified_name', {
3036       parts: parts });
3037   }
3038   get parts() { return this.children.parts; }
3039   with_parts(parts){
3040     return new QualifiedName(
3041       parts);
3042   }
3043   rewrite(rewriter, parents)
3044   {
3045     if (parents == undefined)
3046       parents = [];
3047     let new_parents = parents.slice();
3048     new_parents.push(this);
3049     var parts = this.parts.rewrite(rewriter, new_parents);
3050     if (
3051       parts === this.parts)
3052     {
3053       return rewriter(this, parents);
3054     }
3055     else
3056     {
3057       return rewriter(new QualifiedName(
3058         parts), parents);
3059     }
3060   }
3061   static from_json(json, position, source)
3062   {
3063     let parts = EditableSyntax.from_json(
3064       json.qualified_name_parts, position, source);
3065     position += parts.width;
3066     return new QualifiedName(
3067         parts);
3068   }
3069   get children_keys()
3070   {
3071     if (QualifiedName._children_keys == null)
3072       QualifiedName._children_keys = [
3073         'parts'];
3074     return QualifiedName._children_keys;
3075   }
3076 }
3077 class SimpleTypeSpecifier extends EditableSyntax
3078 {
3079   constructor(
3080     specifier)
3081   {
3082     super('simple_type_specifier', {
3083       specifier: specifier });
3084   }
3085   get specifier() { return this.children.specifier; }
3086   with_specifier(specifier){
3087     return new SimpleTypeSpecifier(
3088       specifier);
3089   }
3090   rewrite(rewriter, parents)
3091   {
3092     if (parents == undefined)
3093       parents = [];
3094     let new_parents = parents.slice();
3095     new_parents.push(this);
3096     var specifier = this.specifier.rewrite(rewriter, new_parents);
3097     if (
3098       specifier === this.specifier)
3099     {
3100       return rewriter(this, parents);
3101     }
3102     else
3103     {
3104       return rewriter(new SimpleTypeSpecifier(
3105         specifier), parents);
3106     }
3107   }
3108   static from_json(json, position, source)
3109   {
3110     let specifier = EditableSyntax.from_json(
3111       json.simple_type_specifier, position, source);
3112     position += specifier.width;
3113     return new SimpleTypeSpecifier(
3114         specifier);
3115   }
3116   get children_keys()
3117   {
3118     if (SimpleTypeSpecifier._children_keys == null)
3119       SimpleTypeSpecifier._children_keys = [
3120         'specifier'];
3121     return SimpleTypeSpecifier._children_keys;
3122   }
3123 }
3124 class LiteralExpression extends EditableSyntax
3125 {
3126   constructor(
3127     expression)
3128   {
3129     super('literal', {
3130       expression: expression });
3131   }
3132   get expression() { return this.children.expression; }
3133   with_expression(expression){
3134     return new LiteralExpression(
3135       expression);
3136   }
3137   rewrite(rewriter, parents)
3138   {
3139     if (parents == undefined)
3140       parents = [];
3141     let new_parents = parents.slice();
3142     new_parents.push(this);
3143     var expression = this.expression.rewrite(rewriter, new_parents);
3144     if (
3145       expression === this.expression)
3146     {
3147       return rewriter(this, parents);
3148     }
3149     else
3150     {
3151       return rewriter(new LiteralExpression(
3152         expression), parents);
3153     }
3154   }
3155   static from_json(json, position, source)
3156   {
3157     let expression = EditableSyntax.from_json(
3158       json.literal_expression, position, source);
3159     position += expression.width;
3160     return new LiteralExpression(
3161         expression);
3162   }
3163   get children_keys()
3164   {
3165     if (LiteralExpression._children_keys == null)
3166       LiteralExpression._children_keys = [
3167         'expression'];
3168     return LiteralExpression._children_keys;
3169   }
3170 }
3171 class VariableExpression extends EditableSyntax
3172 {
3173   constructor(
3174     expression)
3175   {
3176     super('variable', {
3177       expression: expression });
3178   }
3179   get expression() { return this.children.expression; }
3180   with_expression(expression){
3181     return new VariableExpression(
3182       expression);
3183   }
3184   rewrite(rewriter, parents)
3185   {
3186     if (parents == undefined)
3187       parents = [];
3188     let new_parents = parents.slice();
3189     new_parents.push(this);
3190     var expression = this.expression.rewrite(rewriter, new_parents);
3191     if (
3192       expression === this.expression)
3193     {
3194       return rewriter(this, parents);
3195     }
3196     else
3197     {
3198       return rewriter(new VariableExpression(
3199         expression), parents);
3200     }
3201   }
3202   static from_json(json, position, source)
3203   {
3204     let expression = EditableSyntax.from_json(
3205       json.variable_expression, position, source);
3206     position += expression.width;
3207     return new VariableExpression(
3208         expression);
3209   }
3210   get children_keys()
3211   {
3212     if (VariableExpression._children_keys == null)
3213       VariableExpression._children_keys = [
3214         'expression'];
3215     return VariableExpression._children_keys;
3216   }
3217 }
3218 class PipeVariableExpression extends EditableSyntax
3219 {
3220   constructor(
3221     expression)
3222   {
3223     super('pipe_variable', {
3224       expression: expression });
3225   }
3226   get expression() { return this.children.expression; }
3227   with_expression(expression){
3228     return new PipeVariableExpression(
3229       expression);
3230   }
3231   rewrite(rewriter, parents)
3232   {
3233     if (parents == undefined)
3234       parents = [];
3235     let new_parents = parents.slice();
3236     new_parents.push(this);
3237     var expression = this.expression.rewrite(rewriter, new_parents);
3238     if (
3239       expression === this.expression)
3240     {
3241       return rewriter(this, parents);
3242     }
3243     else
3244     {
3245       return rewriter(new PipeVariableExpression(
3246         expression), parents);
3247     }
3248   }
3249   static from_json(json, position, source)
3250   {
3251     let expression = EditableSyntax.from_json(
3252       json.pipe_variable_expression, position, source);
3253     position += expression.width;
3254     return new PipeVariableExpression(
3255         expression);
3256   }
3257   get children_keys()
3258   {
3259     if (PipeVariableExpression._children_keys == null)
3260       PipeVariableExpression._children_keys = [
3261         'expression'];
3262     return PipeVariableExpression._children_keys;
3263   }
3264 }
3265 class EnumDeclaration extends EditableSyntax
3266 {
3267   constructor(
3268     attribute_spec,
3269     keyword,
3270     name,
3271     colon,
3272     base,
3273     type,
3274     left_brace,
3275     enumerators,
3276     right_brace)
3277   {
3278     super('enum_declaration', {
3279       attribute_spec: attribute_spec,
3280       keyword: keyword,
3281       name: name,
3282       colon: colon,
3283       base: base,
3284       type: type,
3285       left_brace: left_brace,
3286       enumerators: enumerators,
3287       right_brace: right_brace });
3288   }
3289   get attribute_spec() { return this.children.attribute_spec; }
3290   get keyword() { return this.children.keyword; }
3291   get name() { return this.children.name; }
3292   get colon() { return this.children.colon; }
3293   get base() { return this.children.base; }
3294   get type() { return this.children.type; }
3295   get left_brace() { return this.children.left_brace; }
3296   get enumerators() { return this.children.enumerators; }
3297   get right_brace() { return this.children.right_brace; }
3298   with_attribute_spec(attribute_spec){
3299     return new EnumDeclaration(
3300       attribute_spec,
3301       this.keyword,
3302       this.name,
3303       this.colon,
3304       this.base,
3305       this.type,
3306       this.left_brace,
3307       this.enumerators,
3308       this.right_brace);
3309   }
3310   with_keyword(keyword){
3311     return new EnumDeclaration(
3312       this.attribute_spec,
3313       keyword,
3314       this.name,
3315       this.colon,
3316       this.base,
3317       this.type,
3318       this.left_brace,
3319       this.enumerators,
3320       this.right_brace);
3321   }
3322   with_name(name){
3323     return new EnumDeclaration(
3324       this.attribute_spec,
3325       this.keyword,
3326       name,
3327       this.colon,
3328       this.base,
3329       this.type,
3330       this.left_brace,
3331       this.enumerators,
3332       this.right_brace);
3333   }
3334   with_colon(colon){
3335     return new EnumDeclaration(
3336       this.attribute_spec,
3337       this.keyword,
3338       this.name,
3339       colon,
3340       this.base,
3341       this.type,
3342       this.left_brace,
3343       this.enumerators,
3344       this.right_brace);
3345   }
3346   with_base(base){
3347     return new EnumDeclaration(
3348       this.attribute_spec,
3349       this.keyword,
3350       this.name,
3351       this.colon,
3352       base,
3353       this.type,
3354       this.left_brace,
3355       this.enumerators,
3356       this.right_brace);
3357   }
3358   with_type(type){
3359     return new EnumDeclaration(
3360       this.attribute_spec,
3361       this.keyword,
3362       this.name,
3363       this.colon,
3364       this.base,
3365       type,
3366       this.left_brace,
3367       this.enumerators,
3368       this.right_brace);
3369   }
3370   with_left_brace(left_brace){
3371     return new EnumDeclaration(
3372       this.attribute_spec,
3373       this.keyword,
3374       this.name,
3375       this.colon,
3376       this.base,
3377       this.type,
3378       left_brace,
3379       this.enumerators,
3380       this.right_brace);
3381   }
3382   with_enumerators(enumerators){
3383     return new EnumDeclaration(
3384       this.attribute_spec,
3385       this.keyword,
3386       this.name,
3387       this.colon,
3388       this.base,
3389       this.type,
3390       this.left_brace,
3391       enumerators,
3392       this.right_brace);
3393   }
3394   with_right_brace(right_brace){
3395     return new EnumDeclaration(
3396       this.attribute_spec,
3397       this.keyword,
3398       this.name,
3399       this.colon,
3400       this.base,
3401       this.type,
3402       this.left_brace,
3403       this.enumerators,
3404       right_brace);
3405   }
3406   rewrite(rewriter, parents)
3407   {
3408     if (parents == undefined)
3409       parents = [];
3410     let new_parents = parents.slice();
3411     new_parents.push(this);
3412     var attribute_spec = this.attribute_spec.rewrite(rewriter, new_parents);
3413     var keyword = this.keyword.rewrite(rewriter, new_parents);
3414     var name = this.name.rewrite(rewriter, new_parents);
3415     var colon = this.colon.rewrite(rewriter, new_parents);
3416     var base = this.base.rewrite(rewriter, new_parents);
3417     var type = this.type.rewrite(rewriter, new_parents);
3418     var left_brace = this.left_brace.rewrite(rewriter, new_parents);
3419     var enumerators = this.enumerators.rewrite(rewriter, new_parents);
3420     var right_brace = this.right_brace.rewrite(rewriter, new_parents);
3421     if (
3422       attribute_spec === this.attribute_spec &&
3423       keyword === this.keyword &&
3424       name === this.name &&
3425       colon === this.colon &&
3426       base === this.base &&
3427       type === this.type &&
3428       left_brace === this.left_brace &&
3429       enumerators === this.enumerators &&
3430       right_brace === this.right_brace)
3431     {
3432       return rewriter(this, parents);
3433     }
3434     else
3435     {
3436       return rewriter(new EnumDeclaration(
3437         attribute_spec,
3438         keyword,
3439         name,
3440         colon,
3441         base,
3442         type,
3443         left_brace,
3444         enumerators,
3445         right_brace), parents);
3446     }
3447   }
3448   static from_json(json, position, source)
3449   {
3450     let attribute_spec = EditableSyntax.from_json(
3451       json.enum_attribute_spec, position, source);
3452     position += attribute_spec.width;
3453     let keyword = EditableSyntax.from_json(
3454       json.enum_keyword, position, source);
3455     position += keyword.width;
3456     let name = EditableSyntax.from_json(
3457       json.enum_name, position, source);
3458     position += name.width;
3459     let colon = EditableSyntax.from_json(
3460       json.enum_colon, position, source);
3461     position += colon.width;
3462     let base = EditableSyntax.from_json(
3463       json.enum_base, position, source);
3464     position += base.width;
3465     let type = EditableSyntax.from_json(
3466       json.enum_type, position, source);
3467     position += type.width;
3468     let left_brace = EditableSyntax.from_json(
3469       json.enum_left_brace, position, source);
3470     position += left_brace.width;
3471     let enumerators = EditableSyntax.from_json(
3472       json.enum_enumerators, position, source);
3473     position += enumerators.width;
3474     let right_brace = EditableSyntax.from_json(
3475       json.enum_right_brace, position, source);
3476     position += right_brace.width;
3477     return new EnumDeclaration(
3478         attribute_spec,
3479         keyword,
3480         name,
3481         colon,
3482         base,
3483         type,
3484         left_brace,
3485         enumerators,
3486         right_brace);
3487   }
3488   get children_keys()
3489   {
3490     if (EnumDeclaration._children_keys == null)
3491       EnumDeclaration._children_keys = [
3492         'attribute_spec',
3493         'keyword',
3494         'name',
3495         'colon',
3496         'base',
3497         'type',
3498         'left_brace',
3499         'enumerators',
3500         'right_brace'];
3501     return EnumDeclaration._children_keys;
3502   }
3503 }
3504 class Enumerator extends EditableSyntax
3505 {
3506   constructor(
3507     name,
3508     equal,
3509     value,
3510     semicolon)
3511   {
3512     super('enumerator', {
3513       name: name,
3514       equal: equal,
3515       value: value,
3516       semicolon: semicolon });
3517   }
3518   get name() { return this.children.name; }
3519   get equal() { return this.children.equal; }
3520   get value() { return this.children.value; }
3521   get semicolon() { return this.children.semicolon; }
3522   with_name(name){
3523     return new Enumerator(
3524       name,
3525       this.equal,
3526       this.value,
3527       this.semicolon);
3528   }
3529   with_equal(equal){
3530     return new Enumerator(
3531       this.name,
3532       equal,
3533       this.value,
3534       this.semicolon);
3535   }
3536   with_value(value){
3537     return new Enumerator(
3538       this.name,
3539       this.equal,
3540       value,
3541       this.semicolon);
3542   }
3543   with_semicolon(semicolon){
3544     return new Enumerator(
3545       this.name,
3546       this.equal,
3547       this.value,
3548       semicolon);
3549   }
3550   rewrite(rewriter, parents)
3551   {
3552     if (parents == undefined)
3553       parents = [];
3554     let new_parents = parents.slice();
3555     new_parents.push(this);
3556     var name = this.name.rewrite(rewriter, new_parents);
3557     var equal = this.equal.rewrite(rewriter, new_parents);
3558     var value = this.value.rewrite(rewriter, new_parents);
3559     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
3560     if (
3561       name === this.name &&
3562       equal === this.equal &&
3563       value === this.value &&
3564       semicolon === this.semicolon)
3565     {
3566       return rewriter(this, parents);
3567     }
3568     else
3569     {
3570       return rewriter(new Enumerator(
3571         name,
3572         equal,
3573         value,
3574         semicolon), parents);
3575     }
3576   }
3577   static from_json(json, position, source)
3578   {
3579     let name = EditableSyntax.from_json(
3580       json.enumerator_name, position, source);
3581     position += name.width;
3582     let equal = EditableSyntax.from_json(
3583       json.enumerator_equal, position, source);
3584     position += equal.width;
3585     let value = EditableSyntax.from_json(
3586       json.enumerator_value, position, source);
3587     position += value.width;
3588     let semicolon = EditableSyntax.from_json(
3589       json.enumerator_semicolon, position, source);
3590     position += semicolon.width;
3591     return new Enumerator(
3592         name,
3593         equal,
3594         value,
3595         semicolon);
3596   }
3597   get children_keys()
3598   {
3599     if (Enumerator._children_keys == null)
3600       Enumerator._children_keys = [
3601         'name',
3602         'equal',
3603         'value',
3604         'semicolon'];
3605     return Enumerator._children_keys;
3606   }
3607 }
3608 class AliasDeclaration extends EditableSyntax
3609 {
3610   constructor(
3611     attribute_spec,
3612     keyword,
3613     name,
3614     generic_parameter,
3615     constraint,
3616     equal,
3617     type,
3618     semicolon)
3619   {
3620     super('alias_declaration', {
3621       attribute_spec: attribute_spec,
3622       keyword: keyword,
3623       name: name,
3624       generic_parameter: generic_parameter,
3625       constraint: constraint,
3626       equal: equal,
3627       type: type,
3628       semicolon: semicolon });
3629   }
3630   get attribute_spec() { return this.children.attribute_spec; }
3631   get keyword() { return this.children.keyword; }
3632   get name() { return this.children.name; }
3633   get generic_parameter() { return this.children.generic_parameter; }
3634   get constraint() { return this.children.constraint; }
3635   get equal() { return this.children.equal; }
3636   get type() { return this.children.type; }
3637   get semicolon() { return this.children.semicolon; }
3638   with_attribute_spec(attribute_spec){
3639     return new AliasDeclaration(
3640       attribute_spec,
3641       this.keyword,
3642       this.name,
3643       this.generic_parameter,
3644       this.constraint,
3645       this.equal,
3646       this.type,
3647       this.semicolon);
3648   }
3649   with_keyword(keyword){
3650     return new AliasDeclaration(
3651       this.attribute_spec,
3652       keyword,
3653       this.name,
3654       this.generic_parameter,
3655       this.constraint,
3656       this.equal,
3657       this.type,
3658       this.semicolon);
3659   }
3660   with_name(name){
3661     return new AliasDeclaration(
3662       this.attribute_spec,
3663       this.keyword,
3664       name,
3665       this.generic_parameter,
3666       this.constraint,
3667       this.equal,
3668       this.type,
3669       this.semicolon);
3670   }
3671   with_generic_parameter(generic_parameter){
3672     return new AliasDeclaration(
3673       this.attribute_spec,
3674       this.keyword,
3675       this.name,
3676       generic_parameter,
3677       this.constraint,
3678       this.equal,
3679       this.type,
3680       this.semicolon);
3681   }
3682   with_constraint(constraint){
3683     return new AliasDeclaration(
3684       this.attribute_spec,
3685       this.keyword,
3686       this.name,
3687       this.generic_parameter,
3688       constraint,
3689       this.equal,
3690       this.type,
3691       this.semicolon);
3692   }
3693   with_equal(equal){
3694     return new AliasDeclaration(
3695       this.attribute_spec,
3696       this.keyword,
3697       this.name,
3698       this.generic_parameter,
3699       this.constraint,
3700       equal,
3701       this.type,
3702       this.semicolon);
3703   }
3704   with_type(type){
3705     return new AliasDeclaration(
3706       this.attribute_spec,
3707       this.keyword,
3708       this.name,
3709       this.generic_parameter,
3710       this.constraint,
3711       this.equal,
3712       type,
3713       this.semicolon);
3714   }
3715   with_semicolon(semicolon){
3716     return new AliasDeclaration(
3717       this.attribute_spec,
3718       this.keyword,
3719       this.name,
3720       this.generic_parameter,
3721       this.constraint,
3722       this.equal,
3723       this.type,
3724       semicolon);
3725   }
3726   rewrite(rewriter, parents)
3727   {
3728     if (parents == undefined)
3729       parents = [];
3730     let new_parents = parents.slice();
3731     new_parents.push(this);
3732     var attribute_spec = this.attribute_spec.rewrite(rewriter, new_parents);
3733     var keyword = this.keyword.rewrite(rewriter, new_parents);
3734     var name = this.name.rewrite(rewriter, new_parents);
3735     var generic_parameter = this.generic_parameter.rewrite(rewriter, new_parents);
3736     var constraint = this.constraint.rewrite(rewriter, new_parents);
3737     var equal = this.equal.rewrite(rewriter, new_parents);
3738     var type = this.type.rewrite(rewriter, new_parents);
3739     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
3740     if (
3741       attribute_spec === this.attribute_spec &&
3742       keyword === this.keyword &&
3743       name === this.name &&
3744       generic_parameter === this.generic_parameter &&
3745       constraint === this.constraint &&
3746       equal === this.equal &&
3747       type === this.type &&
3748       semicolon === this.semicolon)
3749     {
3750       return rewriter(this, parents);
3751     }
3752     else
3753     {
3754       return rewriter(new AliasDeclaration(
3755         attribute_spec,
3756         keyword,
3757         name,
3758         generic_parameter,
3759         constraint,
3760         equal,
3761         type,
3762         semicolon), parents);
3763     }
3764   }
3765   static from_json(json, position, source)
3766   {
3767     let attribute_spec = EditableSyntax.from_json(
3768       json.alias_attribute_spec, position, source);
3769     position += attribute_spec.width;
3770     let keyword = EditableSyntax.from_json(
3771       json.alias_keyword, position, source);
3772     position += keyword.width;
3773     let name = EditableSyntax.from_json(
3774       json.alias_name, position, source);
3775     position += name.width;
3776     let generic_parameter = EditableSyntax.from_json(
3777       json.alias_generic_parameter, position, source);
3778     position += generic_parameter.width;
3779     let constraint = EditableSyntax.from_json(
3780       json.alias_constraint, position, source);
3781     position += constraint.width;
3782     let equal = EditableSyntax.from_json(
3783       json.alias_equal, position, source);
3784     position += equal.width;
3785     let type = EditableSyntax.from_json(
3786       json.alias_type, position, source);
3787     position += type.width;
3788     let semicolon = EditableSyntax.from_json(
3789       json.alias_semicolon, position, source);
3790     position += semicolon.width;
3791     return new AliasDeclaration(
3792         attribute_spec,
3793         keyword,
3794         name,
3795         generic_parameter,
3796         constraint,
3797         equal,
3798         type,
3799         semicolon);
3800   }
3801   get children_keys()
3802   {
3803     if (AliasDeclaration._children_keys == null)
3804       AliasDeclaration._children_keys = [
3805         'attribute_spec',
3806         'keyword',
3807         'name',
3808         'generic_parameter',
3809         'constraint',
3810         'equal',
3811         'type',
3812         'semicolon'];
3813     return AliasDeclaration._children_keys;
3814   }
3815 }
3816 class PropertyDeclaration extends EditableSyntax
3817 {
3818   constructor(
3819     modifiers,
3820     type,
3821     declarators,
3822     semicolon)
3823   {
3824     super('property_declaration', {
3825       modifiers: modifiers,
3826       type: type,
3827       declarators: declarators,
3828       semicolon: semicolon });
3829   }
3830   get modifiers() { return this.children.modifiers; }
3831   get type() { return this.children.type; }
3832   get declarators() { return this.children.declarators; }
3833   get semicolon() { return this.children.semicolon; }
3834   with_modifiers(modifiers){
3835     return new PropertyDeclaration(
3836       modifiers,
3837       this.type,
3838       this.declarators,
3839       this.semicolon);
3840   }
3841   with_type(type){
3842     return new PropertyDeclaration(
3843       this.modifiers,
3844       type,
3845       this.declarators,
3846       this.semicolon);
3847   }
3848   with_declarators(declarators){
3849     return new PropertyDeclaration(
3850       this.modifiers,
3851       this.type,
3852       declarators,
3853       this.semicolon);
3854   }
3855   with_semicolon(semicolon){
3856     return new PropertyDeclaration(
3857       this.modifiers,
3858       this.type,
3859       this.declarators,
3860       semicolon);
3861   }
3862   rewrite(rewriter, parents)
3863   {
3864     if (parents == undefined)
3865       parents = [];
3866     let new_parents = parents.slice();
3867     new_parents.push(this);
3868     var modifiers = this.modifiers.rewrite(rewriter, new_parents);
3869     var type = this.type.rewrite(rewriter, new_parents);
3870     var declarators = this.declarators.rewrite(rewriter, new_parents);
3871     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
3872     if (
3873       modifiers === this.modifiers &&
3874       type === this.type &&
3875       declarators === this.declarators &&
3876       semicolon === this.semicolon)
3877     {
3878       return rewriter(this, parents);
3879     }
3880     else
3881     {
3882       return rewriter(new PropertyDeclaration(
3883         modifiers,
3884         type,
3885         declarators,
3886         semicolon), parents);
3887     }
3888   }
3889   static from_json(json, position, source)
3890   {
3891     let modifiers = EditableSyntax.from_json(
3892       json.property_modifiers, position, source);
3893     position += modifiers.width;
3894     let type = EditableSyntax.from_json(
3895       json.property_type, position, source);
3896     position += type.width;
3897     let declarators = EditableSyntax.from_json(
3898       json.property_declarators, position, source);
3899     position += declarators.width;
3900     let semicolon = EditableSyntax.from_json(
3901       json.property_semicolon, position, source);
3902     position += semicolon.width;
3903     return new PropertyDeclaration(
3904         modifiers,
3905         type,
3906         declarators,
3907         semicolon);
3908   }
3909   get children_keys()
3910   {
3911     if (PropertyDeclaration._children_keys == null)
3912       PropertyDeclaration._children_keys = [
3913         'modifiers',
3914         'type',
3915         'declarators',
3916         'semicolon'];
3917     return PropertyDeclaration._children_keys;
3918   }
3919 }
3920 class PropertyDeclarator extends EditableSyntax
3921 {
3922   constructor(
3923     name,
3924     initializer)
3925   {
3926     super('property_declarator', {
3927       name: name,
3928       initializer: initializer });
3929   }
3930   get name() { return this.children.name; }
3931   get initializer() { return this.children.initializer; }
3932   with_name(name){
3933     return new PropertyDeclarator(
3934       name,
3935       this.initializer);
3936   }
3937   with_initializer(initializer){
3938     return new PropertyDeclarator(
3939       this.name,
3940       initializer);
3941   }
3942   rewrite(rewriter, parents)
3943   {
3944     if (parents == undefined)
3945       parents = [];
3946     let new_parents = parents.slice();
3947     new_parents.push(this);
3948     var name = this.name.rewrite(rewriter, new_parents);
3949     var initializer = this.initializer.rewrite(rewriter, new_parents);
3950     if (
3951       name === this.name &&
3952       initializer === this.initializer)
3953     {
3954       return rewriter(this, parents);
3955     }
3956     else
3957     {
3958       return rewriter(new PropertyDeclarator(
3959         name,
3960         initializer), parents);
3961     }
3962   }
3963   static from_json(json, position, source)
3964   {
3965     let name = EditableSyntax.from_json(
3966       json.property_name, position, source);
3967     position += name.width;
3968     let initializer = EditableSyntax.from_json(
3969       json.property_initializer, position, source);
3970     position += initializer.width;
3971     return new PropertyDeclarator(
3972         name,
3973         initializer);
3974   }
3975   get children_keys()
3976   {
3977     if (PropertyDeclarator._children_keys == null)
3978       PropertyDeclarator._children_keys = [
3979         'name',
3980         'initializer'];
3981     return PropertyDeclarator._children_keys;
3982   }
3983 }
3984 class NamespaceDeclaration extends EditableSyntax
3985 {
3986   constructor(
3987     keyword,
3988     name,
3989     body)
3990   {
3991     super('namespace_declaration', {
3992       keyword: keyword,
3993       name: name,
3994       body: body });
3995   }
3996   get keyword() { return this.children.keyword; }
3997   get name() { return this.children.name; }
3998   get body() { return this.children.body; }
3999   with_keyword(keyword){
4000     return new NamespaceDeclaration(
4001       keyword,
4002       this.name,
4003       this.body);
4004   }
4005   with_name(name){
4006     return new NamespaceDeclaration(
4007       this.keyword,
4008       name,
4009       this.body);
4010   }
4011   with_body(body){
4012     return new NamespaceDeclaration(
4013       this.keyword,
4014       this.name,
4015       body);
4016   }
4017   rewrite(rewriter, parents)
4018   {
4019     if (parents == undefined)
4020       parents = [];
4021     let new_parents = parents.slice();
4022     new_parents.push(this);
4023     var keyword = this.keyword.rewrite(rewriter, new_parents);
4024     var name = this.name.rewrite(rewriter, new_parents);
4025     var body = this.body.rewrite(rewriter, new_parents);
4026     if (
4027       keyword === this.keyword &&
4028       name === this.name &&
4029       body === this.body)
4030     {
4031       return rewriter(this, parents);
4032     }
4033     else
4034     {
4035       return rewriter(new NamespaceDeclaration(
4036         keyword,
4037         name,
4038         body), parents);
4039     }
4040   }
4041   static from_json(json, position, source)
4042   {
4043     let keyword = EditableSyntax.from_json(
4044       json.namespace_keyword, position, source);
4045     position += keyword.width;
4046     let name = EditableSyntax.from_json(
4047       json.namespace_name, position, source);
4048     position += name.width;
4049     let body = EditableSyntax.from_json(
4050       json.namespace_body, position, source);
4051     position += body.width;
4052     return new NamespaceDeclaration(
4053         keyword,
4054         name,
4055         body);
4056   }
4057   get children_keys()
4058   {
4059     if (NamespaceDeclaration._children_keys == null)
4060       NamespaceDeclaration._children_keys = [
4061         'keyword',
4062         'name',
4063         'body'];
4064     return NamespaceDeclaration._children_keys;
4065   }
4066 }
4067 class NamespaceBody extends EditableSyntax
4068 {
4069   constructor(
4070     left_brace,
4071     declarations,
4072     right_brace)
4073   {
4074     super('namespace_body', {
4075       left_brace: left_brace,
4076       declarations: declarations,
4077       right_brace: right_brace });
4078   }
4079   get left_brace() { return this.children.left_brace; }
4080   get declarations() { return this.children.declarations; }
4081   get right_brace() { return this.children.right_brace; }
4082   with_left_brace(left_brace){
4083     return new NamespaceBody(
4084       left_brace,
4085       this.declarations,
4086       this.right_brace);
4087   }
4088   with_declarations(declarations){
4089     return new NamespaceBody(
4090       this.left_brace,
4091       declarations,
4092       this.right_brace);
4093   }
4094   with_right_brace(right_brace){
4095     return new NamespaceBody(
4096       this.left_brace,
4097       this.declarations,
4098       right_brace);
4099   }
4100   rewrite(rewriter, parents)
4101   {
4102     if (parents == undefined)
4103       parents = [];
4104     let new_parents = parents.slice();
4105     new_parents.push(this);
4106     var left_brace = this.left_brace.rewrite(rewriter, new_parents);
4107     var declarations = this.declarations.rewrite(rewriter, new_parents);
4108     var right_brace = this.right_brace.rewrite(rewriter, new_parents);
4109     if (
4110       left_brace === this.left_brace &&
4111       declarations === this.declarations &&
4112       right_brace === this.right_brace)
4113     {
4114       return rewriter(this, parents);
4115     }
4116     else
4117     {
4118       return rewriter(new NamespaceBody(
4119         left_brace,
4120         declarations,
4121         right_brace), parents);
4122     }
4123   }
4124   static from_json(json, position, source)
4125   {
4126     let left_brace = EditableSyntax.from_json(
4127       json.namespace_left_brace, position, source);
4128     position += left_brace.width;
4129     let declarations = EditableSyntax.from_json(
4130       json.namespace_declarations, position, source);
4131     position += declarations.width;
4132     let right_brace = EditableSyntax.from_json(
4133       json.namespace_right_brace, position, source);
4134     position += right_brace.width;
4135     return new NamespaceBody(
4136         left_brace,
4137         declarations,
4138         right_brace);
4139   }
4140   get children_keys()
4141   {
4142     if (NamespaceBody._children_keys == null)
4143       NamespaceBody._children_keys = [
4144         'left_brace',
4145         'declarations',
4146         'right_brace'];
4147     return NamespaceBody._children_keys;
4148   }
4149 }
4150 class NamespaceEmptyBody extends EditableSyntax
4151 {
4152   constructor(
4153     semicolon)
4154   {
4155     super('namespace_empty_body', {
4156       semicolon: semicolon });
4157   }
4158   get semicolon() { return this.children.semicolon; }
4159   with_semicolon(semicolon){
4160     return new NamespaceEmptyBody(
4161       semicolon);
4162   }
4163   rewrite(rewriter, parents)
4164   {
4165     if (parents == undefined)
4166       parents = [];
4167     let new_parents = parents.slice();
4168     new_parents.push(this);
4169     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
4170     if (
4171       semicolon === this.semicolon)
4172     {
4173       return rewriter(this, parents);
4174     }
4175     else
4176     {
4177       return rewriter(new NamespaceEmptyBody(
4178         semicolon), parents);
4179     }
4180   }
4181   static from_json(json, position, source)
4182   {
4183     let semicolon = EditableSyntax.from_json(
4184       json.namespace_semicolon, position, source);
4185     position += semicolon.width;
4186     return new NamespaceEmptyBody(
4187         semicolon);
4188   }
4189   get children_keys()
4190   {
4191     if (NamespaceEmptyBody._children_keys == null)
4192       NamespaceEmptyBody._children_keys = [
4193         'semicolon'];
4194     return NamespaceEmptyBody._children_keys;
4195   }
4196 }
4197 class NamespaceUseDeclaration extends EditableSyntax
4198 {
4199   constructor(
4200     keyword,
4201     kind,
4202     clauses,
4203     semicolon)
4204   {
4205     super('namespace_use_declaration', {
4206       keyword: keyword,
4207       kind: kind,
4208       clauses: clauses,
4209       semicolon: semicolon });
4210   }
4211   get keyword() { return this.children.keyword; }
4212   get kind() { return this.children.kind; }
4213   get clauses() { return this.children.clauses; }
4214   get semicolon() { return this.children.semicolon; }
4215   with_keyword(keyword){
4216     return new NamespaceUseDeclaration(
4217       keyword,
4218       this.kind,
4219       this.clauses,
4220       this.semicolon);
4221   }
4222   with_kind(kind){
4223     return new NamespaceUseDeclaration(
4224       this.keyword,
4225       kind,
4226       this.clauses,
4227       this.semicolon);
4228   }
4229   with_clauses(clauses){
4230     return new NamespaceUseDeclaration(
4231       this.keyword,
4232       this.kind,
4233       clauses,
4234       this.semicolon);
4235   }
4236   with_semicolon(semicolon){
4237     return new NamespaceUseDeclaration(
4238       this.keyword,
4239       this.kind,
4240       this.clauses,
4241       semicolon);
4242   }
4243   rewrite(rewriter, parents)
4244   {
4245     if (parents == undefined)
4246       parents = [];
4247     let new_parents = parents.slice();
4248     new_parents.push(this);
4249     var keyword = this.keyword.rewrite(rewriter, new_parents);
4250     var kind = this.kind.rewrite(rewriter, new_parents);
4251     var clauses = this.clauses.rewrite(rewriter, new_parents);
4252     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
4253     if (
4254       keyword === this.keyword &&
4255       kind === this.kind &&
4256       clauses === this.clauses &&
4257       semicolon === this.semicolon)
4258     {
4259       return rewriter(this, parents);
4260     }
4261     else
4262     {
4263       return rewriter(new NamespaceUseDeclaration(
4264         keyword,
4265         kind,
4266         clauses,
4267         semicolon), parents);
4268     }
4269   }
4270   static from_json(json, position, source)
4271   {
4272     let keyword = EditableSyntax.from_json(
4273       json.namespace_use_keyword, position, source);
4274     position += keyword.width;
4275     let kind = EditableSyntax.from_json(
4276       json.namespace_use_kind, position, source);
4277     position += kind.width;
4278     let clauses = EditableSyntax.from_json(
4279       json.namespace_use_clauses, position, source);
4280     position += clauses.width;
4281     let semicolon = EditableSyntax.from_json(
4282       json.namespace_use_semicolon, position, source);
4283     position += semicolon.width;
4284     return new NamespaceUseDeclaration(
4285         keyword,
4286         kind,
4287         clauses,
4288         semicolon);
4289   }
4290   get children_keys()
4291   {
4292     if (NamespaceUseDeclaration._children_keys == null)
4293       NamespaceUseDeclaration._children_keys = [
4294         'keyword',
4295         'kind',
4296         'clauses',
4297         'semicolon'];
4298     return NamespaceUseDeclaration._children_keys;
4299   }
4300 }
4301 class NamespaceGroupUseDeclaration extends EditableSyntax
4302 {
4303   constructor(
4304     keyword,
4305     kind,
4306     prefix,
4307     left_brace,
4308     clauses,
4309     right_brace,
4310     semicolon)
4311   {
4312     super('namespace_group_use_declaration', {
4313       keyword: keyword,
4314       kind: kind,
4315       prefix: prefix,
4316       left_brace: left_brace,
4317       clauses: clauses,
4318       right_brace: right_brace,
4319       semicolon: semicolon });
4320   }
4321   get keyword() { return this.children.keyword; }
4322   get kind() { return this.children.kind; }
4323   get prefix() { return this.children.prefix; }
4324   get left_brace() { return this.children.left_brace; }
4325   get clauses() { return this.children.clauses; }
4326   get right_brace() { return this.children.right_brace; }
4327   get semicolon() { return this.children.semicolon; }
4328   with_keyword(keyword){
4329     return new NamespaceGroupUseDeclaration(
4330       keyword,
4331       this.kind,
4332       this.prefix,
4333       this.left_brace,
4334       this.clauses,
4335       this.right_brace,
4336       this.semicolon);
4337   }
4338   with_kind(kind){
4339     return new NamespaceGroupUseDeclaration(
4340       this.keyword,
4341       kind,
4342       this.prefix,
4343       this.left_brace,
4344       this.clauses,
4345       this.right_brace,
4346       this.semicolon);
4347   }
4348   with_prefix(prefix){
4349     return new NamespaceGroupUseDeclaration(
4350       this.keyword,
4351       this.kind,
4352       prefix,
4353       this.left_brace,
4354       this.clauses,
4355       this.right_brace,
4356       this.semicolon);
4357   }
4358   with_left_brace(left_brace){
4359     return new NamespaceGroupUseDeclaration(
4360       this.keyword,
4361       this.kind,
4362       this.prefix,
4363       left_brace,
4364       this.clauses,
4365       this.right_brace,
4366       this.semicolon);
4367   }
4368   with_clauses(clauses){
4369     return new NamespaceGroupUseDeclaration(
4370       this.keyword,
4371       this.kind,
4372       this.prefix,
4373       this.left_brace,
4374       clauses,
4375       this.right_brace,
4376       this.semicolon);
4377   }
4378   with_right_brace(right_brace){
4379     return new NamespaceGroupUseDeclaration(
4380       this.keyword,
4381       this.kind,
4382       this.prefix,
4383       this.left_brace,
4384       this.clauses,
4385       right_brace,
4386       this.semicolon);
4387   }
4388   with_semicolon(semicolon){
4389     return new NamespaceGroupUseDeclaration(
4390       this.keyword,
4391       this.kind,
4392       this.prefix,
4393       this.left_brace,
4394       this.clauses,
4395       this.right_brace,
4396       semicolon);
4397   }
4398   rewrite(rewriter, parents)
4399   {
4400     if (parents == undefined)
4401       parents = [];
4402     let new_parents = parents.slice();
4403     new_parents.push(this);
4404     var keyword = this.keyword.rewrite(rewriter, new_parents);
4405     var kind = this.kind.rewrite(rewriter, new_parents);
4406     var prefix = this.prefix.rewrite(rewriter, new_parents);
4407     var left_brace = this.left_brace.rewrite(rewriter, new_parents);
4408     var clauses = this.clauses.rewrite(rewriter, new_parents);
4409     var right_brace = this.right_brace.rewrite(rewriter, new_parents);
4410     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
4411     if (
4412       keyword === this.keyword &&
4413       kind === this.kind &&
4414       prefix === this.prefix &&
4415       left_brace === this.left_brace &&
4416       clauses === this.clauses &&
4417       right_brace === this.right_brace &&
4418       semicolon === this.semicolon)
4419     {
4420       return rewriter(this, parents);
4421     }
4422     else
4423     {
4424       return rewriter(new NamespaceGroupUseDeclaration(
4425         keyword,
4426         kind,
4427         prefix,
4428         left_brace,
4429         clauses,
4430         right_brace,
4431         semicolon), parents);
4432     }
4433   }
4434   static from_json(json, position, source)
4435   {
4436     let keyword = EditableSyntax.from_json(
4437       json.namespace_group_use_keyword, position, source);
4438     position += keyword.width;
4439     let kind = EditableSyntax.from_json(
4440       json.namespace_group_use_kind, position, source);
4441     position += kind.width;
4442     let prefix = EditableSyntax.from_json(
4443       json.namespace_group_use_prefix, position, source);
4444     position += prefix.width;
4445     let left_brace = EditableSyntax.from_json(
4446       json.namespace_group_use_left_brace, position, source);
4447     position += left_brace.width;
4448     let clauses = EditableSyntax.from_json(
4449       json.namespace_group_use_clauses, position, source);
4450     position += clauses.width;
4451     let right_brace = EditableSyntax.from_json(
4452       json.namespace_group_use_right_brace, position, source);
4453     position += right_brace.width;
4454     let semicolon = EditableSyntax.from_json(
4455       json.namespace_group_use_semicolon, position, source);
4456     position += semicolon.width;
4457     return new NamespaceGroupUseDeclaration(
4458         keyword,
4459         kind,
4460         prefix,
4461         left_brace,
4462         clauses,
4463         right_brace,
4464         semicolon);
4465   }
4466   get children_keys()
4467   {
4468     if (NamespaceGroupUseDeclaration._children_keys == null)
4469       NamespaceGroupUseDeclaration._children_keys = [
4470         'keyword',
4471         'kind',
4472         'prefix',
4473         'left_brace',
4474         'clauses',
4475         'right_brace',
4476         'semicolon'];
4477     return NamespaceGroupUseDeclaration._children_keys;
4478   }
4479 }
4480 class NamespaceUseClause extends EditableSyntax
4481 {
4482   constructor(
4483     clause_kind,
4484     name,
4485     as,
4486     alias)
4487   {
4488     super('namespace_use_clause', {
4489       clause_kind: clause_kind,
4490       name: name,
4491       as: as,
4492       alias: alias });
4493   }
4494   get clause_kind() { return this.children.clause_kind; }
4495   get name() { return this.children.name; }
4496   get as() { return this.children.as; }
4497   get alias() { return this.children.alias; }
4498   with_clause_kind(clause_kind){
4499     return new NamespaceUseClause(
4500       clause_kind,
4501       this.name,
4502       this.as,
4503       this.alias);
4504   }
4505   with_name(name){
4506     return new NamespaceUseClause(
4507       this.clause_kind,
4508       name,
4509       this.as,
4510       this.alias);
4511   }
4512   with_as(as){
4513     return new NamespaceUseClause(
4514       this.clause_kind,
4515       this.name,
4516       as,
4517       this.alias);
4518   }
4519   with_alias(alias){
4520     return new NamespaceUseClause(
4521       this.clause_kind,
4522       this.name,
4523       this.as,
4524       alias);
4525   }
4526   rewrite(rewriter, parents)
4527   {
4528     if (parents == undefined)
4529       parents = [];
4530     let new_parents = parents.slice();
4531     new_parents.push(this);
4532     var clause_kind = this.clause_kind.rewrite(rewriter, new_parents);
4533     var name = this.name.rewrite(rewriter, new_parents);
4534     var as = this.as.rewrite(rewriter, new_parents);
4535     var alias = this.alias.rewrite(rewriter, new_parents);
4536     if (
4537       clause_kind === this.clause_kind &&
4538       name === this.name &&
4539       as === this.as &&
4540       alias === this.alias)
4541     {
4542       return rewriter(this, parents);
4543     }
4544     else
4545     {
4546       return rewriter(new NamespaceUseClause(
4547         clause_kind,
4548         name,
4549         as,
4550         alias), parents);
4551     }
4552   }
4553   static from_json(json, position, source)
4554   {
4555     let clause_kind = EditableSyntax.from_json(
4556       json.namespace_use_clause_kind, position, source);
4557     position += clause_kind.width;
4558     let name = EditableSyntax.from_json(
4559       json.namespace_use_name, position, source);
4560     position += name.width;
4561     let as = EditableSyntax.from_json(
4562       json.namespace_use_as, position, source);
4563     position += as.width;
4564     let alias = EditableSyntax.from_json(
4565       json.namespace_use_alias, position, source);
4566     position += alias.width;
4567     return new NamespaceUseClause(
4568         clause_kind,
4569         name,
4570         as,
4571         alias);
4572   }
4573   get children_keys()
4574   {
4575     if (NamespaceUseClause._children_keys == null)
4576       NamespaceUseClause._children_keys = [
4577         'clause_kind',
4578         'name',
4579         'as',
4580         'alias'];
4581     return NamespaceUseClause._children_keys;
4582   }
4583 }
4584 class FunctionDeclaration extends EditableSyntax
4585 {
4586   constructor(
4587     attribute_spec,
4588     declaration_header,
4589     body)
4590   {
4591     super('function_declaration', {
4592       attribute_spec: attribute_spec,
4593       declaration_header: declaration_header,
4594       body: body });
4595   }
4596   get attribute_spec() { return this.children.attribute_spec; }
4597   get declaration_header() { return this.children.declaration_header; }
4598   get body() { return this.children.body; }
4599   with_attribute_spec(attribute_spec){
4600     return new FunctionDeclaration(
4601       attribute_spec,
4602       this.declaration_header,
4603       this.body);
4604   }
4605   with_declaration_header(declaration_header){
4606     return new FunctionDeclaration(
4607       this.attribute_spec,
4608       declaration_header,
4609       this.body);
4610   }
4611   with_body(body){
4612     return new FunctionDeclaration(
4613       this.attribute_spec,
4614       this.declaration_header,
4615       body);
4616   }
4617   rewrite(rewriter, parents)
4618   {
4619     if (parents == undefined)
4620       parents = [];
4621     let new_parents = parents.slice();
4622     new_parents.push(this);
4623     var attribute_spec = this.attribute_spec.rewrite(rewriter, new_parents);
4624     var declaration_header = this.declaration_header.rewrite(rewriter, new_parents);
4625     var body = this.body.rewrite(rewriter, new_parents);
4626     if (
4627       attribute_spec === this.attribute_spec &&
4628       declaration_header === this.declaration_header &&
4629       body === this.body)
4630     {
4631       return rewriter(this, parents);
4632     }
4633     else
4634     {
4635       return rewriter(new FunctionDeclaration(
4636         attribute_spec,
4637         declaration_header,
4638         body), parents);
4639     }
4640   }
4641   static from_json(json, position, source)
4642   {
4643     let attribute_spec = EditableSyntax.from_json(
4644       json.function_attribute_spec, position, source);
4645     position += attribute_spec.width;
4646     let declaration_header = EditableSyntax.from_json(
4647       json.function_declaration_header, position, source);
4648     position += declaration_header.width;
4649     let body = EditableSyntax.from_json(
4650       json.function_body, position, source);
4651     position += body.width;
4652     return new FunctionDeclaration(
4653         attribute_spec,
4654         declaration_header,
4655         body);
4656   }
4657   get children_keys()
4658   {
4659     if (FunctionDeclaration._children_keys == null)
4660       FunctionDeclaration._children_keys = [
4661         'attribute_spec',
4662         'declaration_header',
4663         'body'];
4664     return FunctionDeclaration._children_keys;
4665   }
4666 }
4667 class FunctionDeclarationHeader extends EditableSyntax
4668 {
4669   constructor(
4670     modifiers,
4671     keyword,
4672     ampersand,
4673     name,
4674     type_parameter_list,
4675     left_paren,
4676     parameter_list,
4677     right_paren,
4678     colon,
4679     type,
4680     where_clause)
4681   {
4682     super('function_declaration_header', {
4683       modifiers: modifiers,
4684       keyword: keyword,
4685       ampersand: ampersand,
4686       name: name,
4687       type_parameter_list: type_parameter_list,
4688       left_paren: left_paren,
4689       parameter_list: parameter_list,
4690       right_paren: right_paren,
4691       colon: colon,
4692       type: type,
4693       where_clause: where_clause });
4694   }
4695   get modifiers() { return this.children.modifiers; }
4696   get keyword() { return this.children.keyword; }
4697   get ampersand() { return this.children.ampersand; }
4698   get name() { return this.children.name; }
4699   get type_parameter_list() { return this.children.type_parameter_list; }
4700   get left_paren() { return this.children.left_paren; }
4701   get parameter_list() { return this.children.parameter_list; }
4702   get right_paren() { return this.children.right_paren; }
4703   get colon() { return this.children.colon; }
4704   get type() { return this.children.type; }
4705   get where_clause() { return this.children.where_clause; }
4706   with_modifiers(modifiers){
4707     return new FunctionDeclarationHeader(
4708       modifiers,
4709       this.keyword,
4710       this.ampersand,
4711       this.name,
4712       this.type_parameter_list,
4713       this.left_paren,
4714       this.parameter_list,
4715       this.right_paren,
4716       this.colon,
4717       this.type,
4718       this.where_clause);
4719   }
4720   with_keyword(keyword){
4721     return new FunctionDeclarationHeader(
4722       this.modifiers,
4723       keyword,
4724       this.ampersand,
4725       this.name,
4726       this.type_parameter_list,
4727       this.left_paren,
4728       this.parameter_list,
4729       this.right_paren,
4730       this.colon,
4731       this.type,
4732       this.where_clause);
4733   }
4734   with_ampersand(ampersand){
4735     return new FunctionDeclarationHeader(
4736       this.modifiers,
4737       this.keyword,
4738       ampersand,
4739       this.name,
4740       this.type_parameter_list,
4741       this.left_paren,
4742       this.parameter_list,
4743       this.right_paren,
4744       this.colon,
4745       this.type,
4746       this.where_clause);
4747   }
4748   with_name(name){
4749     return new FunctionDeclarationHeader(
4750       this.modifiers,
4751       this.keyword,
4752       this.ampersand,
4753       name,
4754       this.type_parameter_list,
4755       this.left_paren,
4756       this.parameter_list,
4757       this.right_paren,
4758       this.colon,
4759       this.type,
4760       this.where_clause);
4761   }
4762   with_type_parameter_list(type_parameter_list){
4763     return new FunctionDeclarationHeader(
4764       this.modifiers,
4765       this.keyword,
4766       this.ampersand,
4767       this.name,
4768       type_parameter_list,
4769       this.left_paren,
4770       this.parameter_list,
4771       this.right_paren,
4772       this.colon,
4773       this.type,
4774       this.where_clause);
4775   }
4776   with_left_paren(left_paren){
4777     return new FunctionDeclarationHeader(
4778       this.modifiers,
4779       this.keyword,
4780       this.ampersand,
4781       this.name,
4782       this.type_parameter_list,
4783       left_paren,
4784       this.parameter_list,
4785       this.right_paren,
4786       this.colon,
4787       this.type,
4788       this.where_clause);
4789   }
4790   with_parameter_list(parameter_list){
4791     return new FunctionDeclarationHeader(
4792       this.modifiers,
4793       this.keyword,
4794       this.ampersand,
4795       this.name,
4796       this.type_parameter_list,
4797       this.left_paren,
4798       parameter_list,
4799       this.right_paren,
4800       this.colon,
4801       this.type,
4802       this.where_clause);
4803   }
4804   with_right_paren(right_paren){
4805     return new FunctionDeclarationHeader(
4806       this.modifiers,
4807       this.keyword,
4808       this.ampersand,
4809       this.name,
4810       this.type_parameter_list,
4811       this.left_paren,
4812       this.parameter_list,
4813       right_paren,
4814       this.colon,
4815       this.type,
4816       this.where_clause);
4817   }
4818   with_colon(colon){
4819     return new FunctionDeclarationHeader(
4820       this.modifiers,
4821       this.keyword,
4822       this.ampersand,
4823       this.name,
4824       this.type_parameter_list,
4825       this.left_paren,
4826       this.parameter_list,
4827       this.right_paren,
4828       colon,
4829       this.type,
4830       this.where_clause);
4831   }
4832   with_type(type){
4833     return new FunctionDeclarationHeader(
4834       this.modifiers,
4835       this.keyword,
4836       this.ampersand,
4837       this.name,
4838       this.type_parameter_list,
4839       this.left_paren,
4840       this.parameter_list,
4841       this.right_paren,
4842       this.colon,
4843       type,
4844       this.where_clause);
4845   }
4846   with_where_clause(where_clause){
4847     return new FunctionDeclarationHeader(
4848       this.modifiers,
4849       this.keyword,
4850       this.ampersand,
4851       this.name,
4852       this.type_parameter_list,
4853       this.left_paren,
4854       this.parameter_list,
4855       this.right_paren,
4856       this.colon,
4857       this.type,
4858       where_clause);
4859   }
4860   rewrite(rewriter, parents)
4861   {
4862     if (parents == undefined)
4863       parents = [];
4864     let new_parents = parents.slice();
4865     new_parents.push(this);
4866     var modifiers = this.modifiers.rewrite(rewriter, new_parents);
4867     var keyword = this.keyword.rewrite(rewriter, new_parents);
4868     var ampersand = this.ampersand.rewrite(rewriter, new_parents);
4869     var name = this.name.rewrite(rewriter, new_parents);
4870     var type_parameter_list = this.type_parameter_list.rewrite(rewriter, new_parents);
4871     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
4872     var parameter_list = this.parameter_list.rewrite(rewriter, new_parents);
4873     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
4874     var colon = this.colon.rewrite(rewriter, new_parents);
4875     var type = this.type.rewrite(rewriter, new_parents);
4876     var where_clause = this.where_clause.rewrite(rewriter, new_parents);
4877     if (
4878       modifiers === this.modifiers &&
4879       keyword === this.keyword &&
4880       ampersand === this.ampersand &&
4881       name === this.name &&
4882       type_parameter_list === this.type_parameter_list &&
4883       left_paren === this.left_paren &&
4884       parameter_list === this.parameter_list &&
4885       right_paren === this.right_paren &&
4886       colon === this.colon &&
4887       type === this.type &&
4888       where_clause === this.where_clause)
4889     {
4890       return rewriter(this, parents);
4891     }
4892     else
4893     {
4894       return rewriter(new FunctionDeclarationHeader(
4895         modifiers,
4896         keyword,
4897         ampersand,
4898         name,
4899         type_parameter_list,
4900         left_paren,
4901         parameter_list,
4902         right_paren,
4903         colon,
4904         type,
4905         where_clause), parents);
4906     }
4907   }
4908   static from_json(json, position, source)
4909   {
4910     let modifiers = EditableSyntax.from_json(
4911       json.function_modifiers, position, source);
4912     position += modifiers.width;
4913     let keyword = EditableSyntax.from_json(
4914       json.function_keyword, position, source);
4915     position += keyword.width;
4916     let ampersand = EditableSyntax.from_json(
4917       json.function_ampersand, position, source);
4918     position += ampersand.width;
4919     let name = EditableSyntax.from_json(
4920       json.function_name, position, source);
4921     position += name.width;
4922     let type_parameter_list = EditableSyntax.from_json(
4923       json.function_type_parameter_list, position, source);
4924     position += type_parameter_list.width;
4925     let left_paren = EditableSyntax.from_json(
4926       json.function_left_paren, position, source);
4927     position += left_paren.width;
4928     let parameter_list = EditableSyntax.from_json(
4929       json.function_parameter_list, position, source);
4930     position += parameter_list.width;
4931     let right_paren = EditableSyntax.from_json(
4932       json.function_right_paren, position, source);
4933     position += right_paren.width;
4934     let colon = EditableSyntax.from_json(
4935       json.function_colon, position, source);
4936     position += colon.width;
4937     let type = EditableSyntax.from_json(
4938       json.function_type, position, source);
4939     position += type.width;
4940     let where_clause = EditableSyntax.from_json(
4941       json.function_where_clause, position, source);
4942     position += where_clause.width;
4943     return new FunctionDeclarationHeader(
4944         modifiers,
4945         keyword,
4946         ampersand,
4947         name,
4948         type_parameter_list,
4949         left_paren,
4950         parameter_list,
4951         right_paren,
4952         colon,
4953         type,
4954         where_clause);
4955   }
4956   get children_keys()
4957   {
4958     if (FunctionDeclarationHeader._children_keys == null)
4959       FunctionDeclarationHeader._children_keys = [
4960         'modifiers',
4961         'keyword',
4962         'ampersand',
4963         'name',
4964         'type_parameter_list',
4965         'left_paren',
4966         'parameter_list',
4967         'right_paren',
4968         'colon',
4969         'type',
4970         'where_clause'];
4971     return FunctionDeclarationHeader._children_keys;
4972   }
4973 }
4974 class WhereClause extends EditableSyntax
4975 {
4976   constructor(
4977     keyword,
4978     constraints)
4979   {
4980     super('where_clause', {
4981       keyword: keyword,
4982       constraints: constraints });
4983   }
4984   get keyword() { return this.children.keyword; }
4985   get constraints() { return this.children.constraints; }
4986   with_keyword(keyword){
4987     return new WhereClause(
4988       keyword,
4989       this.constraints);
4990   }
4991   with_constraints(constraints){
4992     return new WhereClause(
4993       this.keyword,
4994       constraints);
4995   }
4996   rewrite(rewriter, parents)
4997   {
4998     if (parents == undefined)
4999       parents = [];
5000     let new_parents = parents.slice();
5001     new_parents.push(this);
5002     var keyword = this.keyword.rewrite(rewriter, new_parents);
5003     var constraints = this.constraints.rewrite(rewriter, new_parents);
5004     if (
5005       keyword === this.keyword &&
5006       constraints === this.constraints)
5007     {
5008       return rewriter(this, parents);
5009     }
5010     else
5011     {
5012       return rewriter(new WhereClause(
5013         keyword,
5014         constraints), parents);
5015     }
5016   }
5017   static from_json(json, position, source)
5018   {
5019     let keyword = EditableSyntax.from_json(
5020       json.where_clause_keyword, position, source);
5021     position += keyword.width;
5022     let constraints = EditableSyntax.from_json(
5023       json.where_clause_constraints, position, source);
5024     position += constraints.width;
5025     return new WhereClause(
5026         keyword,
5027         constraints);
5028   }
5029   get children_keys()
5030   {
5031     if (WhereClause._children_keys == null)
5032       WhereClause._children_keys = [
5033         'keyword',
5034         'constraints'];
5035     return WhereClause._children_keys;
5036   }
5037 }
5038 class WhereConstraint extends EditableSyntax
5039 {
5040   constructor(
5041     left_type,
5042     operator,
5043     right_type)
5044   {
5045     super('where_constraint', {
5046       left_type: left_type,
5047       operator: operator,
5048       right_type: right_type });
5049   }
5050   get left_type() { return this.children.left_type; }
5051   get operator() { return this.children.operator; }
5052   get right_type() { return this.children.right_type; }
5053   with_left_type(left_type){
5054     return new WhereConstraint(
5055       left_type,
5056       this.operator,
5057       this.right_type);
5058   }
5059   with_operator(operator){
5060     return new WhereConstraint(
5061       this.left_type,
5062       operator,
5063       this.right_type);
5064   }
5065   with_right_type(right_type){
5066     return new WhereConstraint(
5067       this.left_type,
5068       this.operator,
5069       right_type);
5070   }
5071   rewrite(rewriter, parents)
5072   {
5073     if (parents == undefined)
5074       parents = [];
5075     let new_parents = parents.slice();
5076     new_parents.push(this);
5077     var left_type = this.left_type.rewrite(rewriter, new_parents);
5078     var operator = this.operator.rewrite(rewriter, new_parents);
5079     var right_type = this.right_type.rewrite(rewriter, new_parents);
5080     if (
5081       left_type === this.left_type &&
5082       operator === this.operator &&
5083       right_type === this.right_type)
5084     {
5085       return rewriter(this, parents);
5086     }
5087     else
5088     {
5089       return rewriter(new WhereConstraint(
5090         left_type,
5091         operator,
5092         right_type), parents);
5093     }
5094   }
5095   static from_json(json, position, source)
5096   {
5097     let left_type = EditableSyntax.from_json(
5098       json.where_constraint_left_type, position, source);
5099     position += left_type.width;
5100     let operator = EditableSyntax.from_json(
5101       json.where_constraint_operator, position, source);
5102     position += operator.width;
5103     let right_type = EditableSyntax.from_json(
5104       json.where_constraint_right_type, position, source);
5105     position += right_type.width;
5106     return new WhereConstraint(
5107         left_type,
5108         operator,
5109         right_type);
5110   }
5111   get children_keys()
5112   {
5113     if (WhereConstraint._children_keys == null)
5114       WhereConstraint._children_keys = [
5115         'left_type',
5116         'operator',
5117         'right_type'];
5118     return WhereConstraint._children_keys;
5119   }
5120 }
5121 class MethodishDeclaration extends EditableSyntax
5122 {
5123   constructor(
5124     attribute,
5125     function_decl_header,
5126     function_body,
5127     semicolon)
5128   {
5129     super('methodish_declaration', {
5130       attribute: attribute,
5131       function_decl_header: function_decl_header,
5132       function_body: function_body,
5133       semicolon: semicolon });
5134   }
5135   get attribute() { return this.children.attribute; }
5136   get function_decl_header() { return this.children.function_decl_header; }
5137   get function_body() { return this.children.function_body; }
5138   get semicolon() { return this.children.semicolon; }
5139   with_attribute(attribute){
5140     return new MethodishDeclaration(
5141       attribute,
5142       this.function_decl_header,
5143       this.function_body,
5144       this.semicolon);
5145   }
5146   with_function_decl_header(function_decl_header){
5147     return new MethodishDeclaration(
5148       this.attribute,
5149       function_decl_header,
5150       this.function_body,
5151       this.semicolon);
5152   }
5153   with_function_body(function_body){
5154     return new MethodishDeclaration(
5155       this.attribute,
5156       this.function_decl_header,
5157       function_body,
5158       this.semicolon);
5159   }
5160   with_semicolon(semicolon){
5161     return new MethodishDeclaration(
5162       this.attribute,
5163       this.function_decl_header,
5164       this.function_body,
5165       semicolon);
5166   }
5167   rewrite(rewriter, parents)
5168   {
5169     if (parents == undefined)
5170       parents = [];
5171     let new_parents = parents.slice();
5172     new_parents.push(this);
5173     var attribute = this.attribute.rewrite(rewriter, new_parents);
5174     var function_decl_header = this.function_decl_header.rewrite(rewriter, new_parents);
5175     var function_body = this.function_body.rewrite(rewriter, new_parents);
5176     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
5177     if (
5178       attribute === this.attribute &&
5179       function_decl_header === this.function_decl_header &&
5180       function_body === this.function_body &&
5181       semicolon === this.semicolon)
5182     {
5183       return rewriter(this, parents);
5184     }
5185     else
5186     {
5187       return rewriter(new MethodishDeclaration(
5188         attribute,
5189         function_decl_header,
5190         function_body,
5191         semicolon), parents);
5192     }
5193   }
5194   static from_json(json, position, source)
5195   {
5196     let attribute = EditableSyntax.from_json(
5197       json.methodish_attribute, position, source);
5198     position += attribute.width;
5199     let function_decl_header = EditableSyntax.from_json(
5200       json.methodish_function_decl_header, position, source);
5201     position += function_decl_header.width;
5202     let function_body = EditableSyntax.from_json(
5203       json.methodish_function_body, position, source);
5204     position += function_body.width;
5205     let semicolon = EditableSyntax.from_json(
5206       json.methodish_semicolon, position, source);
5207     position += semicolon.width;
5208     return new MethodishDeclaration(
5209         attribute,
5210         function_decl_header,
5211         function_body,
5212         semicolon);
5213   }
5214   get children_keys()
5215   {
5216     if (MethodishDeclaration._children_keys == null)
5217       MethodishDeclaration._children_keys = [
5218         'attribute',
5219         'function_decl_header',
5220         'function_body',
5221         'semicolon'];
5222     return MethodishDeclaration._children_keys;
5223   }
5224 }
5225 class ClassishDeclaration extends EditableSyntax
5226 {
5227   constructor(
5228     attribute,
5229     modifiers,
5230     keyword,
5231     name,
5232     type_parameters,
5233     extends_keyword,
5234     extends_list,
5235     implements_keyword,
5236     implements_list,
5237     body)
5238   {
5239     super('classish_declaration', {
5240       attribute: attribute,
5241       modifiers: modifiers,
5242       keyword: keyword,
5243       name: name,
5244       type_parameters: type_parameters,
5245       extends_keyword: extends_keyword,
5246       extends_list: extends_list,
5247       implements_keyword: implements_keyword,
5248       implements_list: implements_list,
5249       body: body });
5250   }
5251   get attribute() { return this.children.attribute; }
5252   get modifiers() { return this.children.modifiers; }
5253   get keyword() { return this.children.keyword; }
5254   get name() { return this.children.name; }
5255   get type_parameters() { return this.children.type_parameters; }
5256   get extends_keyword() { return this.children.extends_keyword; }
5257   get extends_list() { return this.children.extends_list; }
5258   get implements_keyword() { return this.children.implements_keyword; }
5259   get implements_list() { return this.children.implements_list; }
5260   get body() { return this.children.body; }
5261   with_attribute(attribute){
5262     return new ClassishDeclaration(
5263       attribute,
5264       this.modifiers,
5265       this.keyword,
5266       this.name,
5267       this.type_parameters,
5268       this.extends_keyword,
5269       this.extends_list,
5270       this.implements_keyword,
5271       this.implements_list,
5272       this.body);
5273   }
5274   with_modifiers(modifiers){
5275     return new ClassishDeclaration(
5276       this.attribute,
5277       modifiers,
5278       this.keyword,
5279       this.name,
5280       this.type_parameters,
5281       this.extends_keyword,
5282       this.extends_list,
5283       this.implements_keyword,
5284       this.implements_list,
5285       this.body);
5286   }
5287   with_keyword(keyword){
5288     return new ClassishDeclaration(
5289       this.attribute,
5290       this.modifiers,
5291       keyword,
5292       this.name,
5293       this.type_parameters,
5294       this.extends_keyword,
5295       this.extends_list,
5296       this.implements_keyword,
5297       this.implements_list,
5298       this.body);
5299   }
5300   with_name(name){
5301     return new ClassishDeclaration(
5302       this.attribute,
5303       this.modifiers,
5304       this.keyword,
5305       name,
5306       this.type_parameters,
5307       this.extends_keyword,
5308       this.extends_list,
5309       this.implements_keyword,
5310       this.implements_list,
5311       this.body);
5312   }
5313   with_type_parameters(type_parameters){
5314     return new ClassishDeclaration(
5315       this.attribute,
5316       this.modifiers,
5317       this.keyword,
5318       this.name,
5319       type_parameters,
5320       this.extends_keyword,
5321       this.extends_list,
5322       this.implements_keyword,
5323       this.implements_list,
5324       this.body);
5325   }
5326   with_extends_keyword(extends_keyword){
5327     return new ClassishDeclaration(
5328       this.attribute,
5329       this.modifiers,
5330       this.keyword,
5331       this.name,
5332       this.type_parameters,
5333       extends_keyword,
5334       this.extends_list,
5335       this.implements_keyword,
5336       this.implements_list,
5337       this.body);
5338   }
5339   with_extends_list(extends_list){
5340     return new ClassishDeclaration(
5341       this.attribute,
5342       this.modifiers,
5343       this.keyword,
5344       this.name,
5345       this.type_parameters,
5346       this.extends_keyword,
5347       extends_list,
5348       this.implements_keyword,
5349       this.implements_list,
5350       this.body);
5351   }
5352   with_implements_keyword(implements_keyword){
5353     return new ClassishDeclaration(
5354       this.attribute,
5355       this.modifiers,
5356       this.keyword,
5357       this.name,
5358       this.type_parameters,
5359       this.extends_keyword,
5360       this.extends_list,
5361       implements_keyword,
5362       this.implements_list,
5363       this.body);
5364   }
5365   with_implements_list(implements_list){
5366     return new ClassishDeclaration(
5367       this.attribute,
5368       this.modifiers,
5369       this.keyword,
5370       this.name,
5371       this.type_parameters,
5372       this.extends_keyword,
5373       this.extends_list,
5374       this.implements_keyword,
5375       implements_list,
5376       this.body);
5377   }
5378   with_body(body){
5379     return new ClassishDeclaration(
5380       this.attribute,
5381       this.modifiers,
5382       this.keyword,
5383       this.name,
5384       this.type_parameters,
5385       this.extends_keyword,
5386       this.extends_list,
5387       this.implements_keyword,
5388       this.implements_list,
5389       body);
5390   }
5391   rewrite(rewriter, parents)
5392   {
5393     if (parents == undefined)
5394       parents = [];
5395     let new_parents = parents.slice();
5396     new_parents.push(this);
5397     var attribute = this.attribute.rewrite(rewriter, new_parents);
5398     var modifiers = this.modifiers.rewrite(rewriter, new_parents);
5399     var keyword = this.keyword.rewrite(rewriter, new_parents);
5400     var name = this.name.rewrite(rewriter, new_parents);
5401     var type_parameters = this.type_parameters.rewrite(rewriter, new_parents);
5402     var extends_keyword = this.extends_keyword.rewrite(rewriter, new_parents);
5403     var extends_list = this.extends_list.rewrite(rewriter, new_parents);
5404     var implements_keyword = this.implements_keyword.rewrite(rewriter, new_parents);
5405     var implements_list = this.implements_list.rewrite(rewriter, new_parents);
5406     var body = this.body.rewrite(rewriter, new_parents);
5407     if (
5408       attribute === this.attribute &&
5409       modifiers === this.modifiers &&
5410       keyword === this.keyword &&
5411       name === this.name &&
5412       type_parameters === this.type_parameters &&
5413       extends_keyword === this.extends_keyword &&
5414       extends_list === this.extends_list &&
5415       implements_keyword === this.implements_keyword &&
5416       implements_list === this.implements_list &&
5417       body === this.body)
5418     {
5419       return rewriter(this, parents);
5420     }
5421     else
5422     {
5423       return rewriter(new ClassishDeclaration(
5424         attribute,
5425         modifiers,
5426         keyword,
5427         name,
5428         type_parameters,
5429         extends_keyword,
5430         extends_list,
5431         implements_keyword,
5432         implements_list,
5433         body), parents);
5434     }
5435   }
5436   static from_json(json, position, source)
5437   {
5438     let attribute = EditableSyntax.from_json(
5439       json.classish_attribute, position, source);
5440     position += attribute.width;
5441     let modifiers = EditableSyntax.from_json(
5442       json.classish_modifiers, position, source);
5443     position += modifiers.width;
5444     let keyword = EditableSyntax.from_json(
5445       json.classish_keyword, position, source);
5446     position += keyword.width;
5447     let name = EditableSyntax.from_json(
5448       json.classish_name, position, source);
5449     position += name.width;
5450     let type_parameters = EditableSyntax.from_json(
5451       json.classish_type_parameters, position, source);
5452     position += type_parameters.width;
5453     let extends_keyword = EditableSyntax.from_json(
5454       json.classish_extends_keyword, position, source);
5455     position += extends_keyword.width;
5456     let extends_list = EditableSyntax.from_json(
5457       json.classish_extends_list, position, source);
5458     position += extends_list.width;
5459     let implements_keyword = EditableSyntax.from_json(
5460       json.classish_implements_keyword, position, source);
5461     position += implements_keyword.width;
5462     let implements_list = EditableSyntax.from_json(
5463       json.classish_implements_list, position, source);
5464     position += implements_list.width;
5465     let body = EditableSyntax.from_json(
5466       json.classish_body, position, source);
5467     position += body.width;
5468     return new ClassishDeclaration(
5469         attribute,
5470         modifiers,
5471         keyword,
5472         name,
5473         type_parameters,
5474         extends_keyword,
5475         extends_list,
5476         implements_keyword,
5477         implements_list,
5478         body);
5479   }
5480   get children_keys()
5481   {
5482     if (ClassishDeclaration._children_keys == null)
5483       ClassishDeclaration._children_keys = [
5484         'attribute',
5485         'modifiers',
5486         'keyword',
5487         'name',
5488         'type_parameters',
5489         'extends_keyword',
5490         'extends_list',
5491         'implements_keyword',
5492         'implements_list',
5493         'body'];
5494     return ClassishDeclaration._children_keys;
5495   }
5496 }
5497 class ClassishBody extends EditableSyntax
5498 {
5499   constructor(
5500     left_brace,
5501     elements,
5502     right_brace)
5503   {
5504     super('classish_body', {
5505       left_brace: left_brace,
5506       elements: elements,
5507       right_brace: right_brace });
5508   }
5509   get left_brace() { return this.children.left_brace; }
5510   get elements() { return this.children.elements; }
5511   get right_brace() { return this.children.right_brace; }
5512   with_left_brace(left_brace){
5513     return new ClassishBody(
5514       left_brace,
5515       this.elements,
5516       this.right_brace);
5517   }
5518   with_elements(elements){
5519     return new ClassishBody(
5520       this.left_brace,
5521       elements,
5522       this.right_brace);
5523   }
5524   with_right_brace(right_brace){
5525     return new ClassishBody(
5526       this.left_brace,
5527       this.elements,
5528       right_brace);
5529   }
5530   rewrite(rewriter, parents)
5531   {
5532     if (parents == undefined)
5533       parents = [];
5534     let new_parents = parents.slice();
5535     new_parents.push(this);
5536     var left_brace = this.left_brace.rewrite(rewriter, new_parents);
5537     var elements = this.elements.rewrite(rewriter, new_parents);
5538     var right_brace = this.right_brace.rewrite(rewriter, new_parents);
5539     if (
5540       left_brace === this.left_brace &&
5541       elements === this.elements &&
5542       right_brace === this.right_brace)
5543     {
5544       return rewriter(this, parents);
5545     }
5546     else
5547     {
5548       return rewriter(new ClassishBody(
5549         left_brace,
5550         elements,
5551         right_brace), parents);
5552     }
5553   }
5554   static from_json(json, position, source)
5555   {
5556     let left_brace = EditableSyntax.from_json(
5557       json.classish_body_left_brace, position, source);
5558     position += left_brace.width;
5559     let elements = EditableSyntax.from_json(
5560       json.classish_body_elements, position, source);
5561     position += elements.width;
5562     let right_brace = EditableSyntax.from_json(
5563       json.classish_body_right_brace, position, source);
5564     position += right_brace.width;
5565     return new ClassishBody(
5566         left_brace,
5567         elements,
5568         right_brace);
5569   }
5570   get children_keys()
5571   {
5572     if (ClassishBody._children_keys == null)
5573       ClassishBody._children_keys = [
5574         'left_brace',
5575         'elements',
5576         'right_brace'];
5577     return ClassishBody._children_keys;
5578   }
5579 }
5580 class TraitUsePrecedenceItem extends EditableSyntax
5581 {
5582   constructor(
5583     name,
5584     keyword,
5585     removed_names)
5586   {
5587     super('trait_use_precedence_item', {
5588       name: name,
5589       keyword: keyword,
5590       removed_names: removed_names });
5591   }
5592   get name() { return this.children.name; }
5593   get keyword() { return this.children.keyword; }
5594   get removed_names() { return this.children.removed_names; }
5595   with_name(name){
5596     return new TraitUsePrecedenceItem(
5597       name,
5598       this.keyword,
5599       this.removed_names);
5600   }
5601   with_keyword(keyword){
5602     return new TraitUsePrecedenceItem(
5603       this.name,
5604       keyword,
5605       this.removed_names);
5606   }
5607   with_removed_names(removed_names){
5608     return new TraitUsePrecedenceItem(
5609       this.name,
5610       this.keyword,
5611       removed_names);
5612   }
5613   rewrite(rewriter, parents)
5614   {
5615     if (parents == undefined)
5616       parents = [];
5617     let new_parents = parents.slice();
5618     new_parents.push(this);
5619     var name = this.name.rewrite(rewriter, new_parents);
5620     var keyword = this.keyword.rewrite(rewriter, new_parents);
5621     var removed_names = this.removed_names.rewrite(rewriter, new_parents);
5622     if (
5623       name === this.name &&
5624       keyword === this.keyword &&
5625       removed_names === this.removed_names)
5626     {
5627       return rewriter(this, parents);
5628     }
5629     else
5630     {
5631       return rewriter(new TraitUsePrecedenceItem(
5632         name,
5633         keyword,
5634         removed_names), parents);
5635     }
5636   }
5637   static from_json(json, position, source)
5638   {
5639     let name = EditableSyntax.from_json(
5640       json.trait_use_precedence_item_name, position, source);
5641     position += name.width;
5642     let keyword = EditableSyntax.from_json(
5643       json.trait_use_precedence_item_keyword, position, source);
5644     position += keyword.width;
5645     let removed_names = EditableSyntax.from_json(
5646       json.trait_use_precedence_item_removed_names, position, source);
5647     position += removed_names.width;
5648     return new TraitUsePrecedenceItem(
5649         name,
5650         keyword,
5651         removed_names);
5652   }
5653   get children_keys()
5654   {
5655     if (TraitUsePrecedenceItem._children_keys == null)
5656       TraitUsePrecedenceItem._children_keys = [
5657         'name',
5658         'keyword',
5659         'removed_names'];
5660     return TraitUsePrecedenceItem._children_keys;
5661   }
5662 }
5663 class TraitUseAliasItem extends EditableSyntax
5664 {
5665   constructor(
5666     aliasing_name,
5667     keyword,
5668     modifiers,
5669     aliased_name)
5670   {
5671     super('trait_use_alias_item', {
5672       aliasing_name: aliasing_name,
5673       keyword: keyword,
5674       modifiers: modifiers,
5675       aliased_name: aliased_name });
5676   }
5677   get aliasing_name() { return this.children.aliasing_name; }
5678   get keyword() { return this.children.keyword; }
5679   get modifiers() { return this.children.modifiers; }
5680   get aliased_name() { return this.children.aliased_name; }
5681   with_aliasing_name(aliasing_name){
5682     return new TraitUseAliasItem(
5683       aliasing_name,
5684       this.keyword,
5685       this.modifiers,
5686       this.aliased_name);
5687   }
5688   with_keyword(keyword){
5689     return new TraitUseAliasItem(
5690       this.aliasing_name,
5691       keyword,
5692       this.modifiers,
5693       this.aliased_name);
5694   }
5695   with_modifiers(modifiers){
5696     return new TraitUseAliasItem(
5697       this.aliasing_name,
5698       this.keyword,
5699       modifiers,
5700       this.aliased_name);
5701   }
5702   with_aliased_name(aliased_name){
5703     return new TraitUseAliasItem(
5704       this.aliasing_name,
5705       this.keyword,
5706       this.modifiers,
5707       aliased_name);
5708   }
5709   rewrite(rewriter, parents)
5710   {
5711     if (parents == undefined)
5712       parents = [];
5713     let new_parents = parents.slice();
5714     new_parents.push(this);
5715     var aliasing_name = this.aliasing_name.rewrite(rewriter, new_parents);
5716     var keyword = this.keyword.rewrite(rewriter, new_parents);
5717     var modifiers = this.modifiers.rewrite(rewriter, new_parents);
5718     var aliased_name = this.aliased_name.rewrite(rewriter, new_parents);
5719     if (
5720       aliasing_name === this.aliasing_name &&
5721       keyword === this.keyword &&
5722       modifiers === this.modifiers &&
5723       aliased_name === this.aliased_name)
5724     {
5725       return rewriter(this, parents);
5726     }
5727     else
5728     {
5729       return rewriter(new TraitUseAliasItem(
5730         aliasing_name,
5731         keyword,
5732         modifiers,
5733         aliased_name), parents);
5734     }
5735   }
5736   static from_json(json, position, source)
5737   {
5738     let aliasing_name = EditableSyntax.from_json(
5739       json.trait_use_alias_item_aliasing_name, position, source);
5740     position += aliasing_name.width;
5741     let keyword = EditableSyntax.from_json(
5742       json.trait_use_alias_item_keyword, position, source);
5743     position += keyword.width;
5744     let modifiers = EditableSyntax.from_json(
5745       json.trait_use_alias_item_modifiers, position, source);
5746     position += modifiers.width;
5747     let aliased_name = EditableSyntax.from_json(
5748       json.trait_use_alias_item_aliased_name, position, source);
5749     position += aliased_name.width;
5750     return new TraitUseAliasItem(
5751         aliasing_name,
5752         keyword,
5753         modifiers,
5754         aliased_name);
5755   }
5756   get children_keys()
5757   {
5758     if (TraitUseAliasItem._children_keys == null)
5759       TraitUseAliasItem._children_keys = [
5760         'aliasing_name',
5761         'keyword',
5762         'modifiers',
5763         'aliased_name'];
5764     return TraitUseAliasItem._children_keys;
5765   }
5766 }
5767 class TraitUseConflictResolution extends EditableSyntax
5768 {
5769   constructor(
5770     keyword,
5771     names,
5772     left_brace,
5773     clauses,
5774     right_brace)
5775   {
5776     super('trait_use_conflict_resolution', {
5777       keyword: keyword,
5778       names: names,
5779       left_brace: left_brace,
5780       clauses: clauses,
5781       right_brace: right_brace });
5782   }
5783   get keyword() { return this.children.keyword; }
5784   get names() { return this.children.names; }
5785   get left_brace() { return this.children.left_brace; }
5786   get clauses() { return this.children.clauses; }
5787   get right_brace() { return this.children.right_brace; }
5788   with_keyword(keyword){
5789     return new TraitUseConflictResolution(
5790       keyword,
5791       this.names,
5792       this.left_brace,
5793       this.clauses,
5794       this.right_brace);
5795   }
5796   with_names(names){
5797     return new TraitUseConflictResolution(
5798       this.keyword,
5799       names,
5800       this.left_brace,
5801       this.clauses,
5802       this.right_brace);
5803   }
5804   with_left_brace(left_brace){
5805     return new TraitUseConflictResolution(
5806       this.keyword,
5807       this.names,
5808       left_brace,
5809       this.clauses,
5810       this.right_brace);
5811   }
5812   with_clauses(clauses){
5813     return new TraitUseConflictResolution(
5814       this.keyword,
5815       this.names,
5816       this.left_brace,
5817       clauses,
5818       this.right_brace);
5819   }
5820   with_right_brace(right_brace){
5821     return new TraitUseConflictResolution(
5822       this.keyword,
5823       this.names,
5824       this.left_brace,
5825       this.clauses,
5826       right_brace);
5827   }
5828   rewrite(rewriter, parents)
5829   {
5830     if (parents == undefined)
5831       parents = [];
5832     let new_parents = parents.slice();
5833     new_parents.push(this);
5834     var keyword = this.keyword.rewrite(rewriter, new_parents);
5835     var names = this.names.rewrite(rewriter, new_parents);
5836     var left_brace = this.left_brace.rewrite(rewriter, new_parents);
5837     var clauses = this.clauses.rewrite(rewriter, new_parents);
5838     var right_brace = this.right_brace.rewrite(rewriter, new_parents);
5839     if (
5840       keyword === this.keyword &&
5841       names === this.names &&
5842       left_brace === this.left_brace &&
5843       clauses === this.clauses &&
5844       right_brace === this.right_brace)
5845     {
5846       return rewriter(this, parents);
5847     }
5848     else
5849     {
5850       return rewriter(new TraitUseConflictResolution(
5851         keyword,
5852         names,
5853         left_brace,
5854         clauses,
5855         right_brace), parents);
5856     }
5857   }
5858   static from_json(json, position, source)
5859   {
5860     let keyword = EditableSyntax.from_json(
5861       json.trait_use_conflict_resolution_keyword, position, source);
5862     position += keyword.width;
5863     let names = EditableSyntax.from_json(
5864       json.trait_use_conflict_resolution_names, position, source);
5865     position += names.width;
5866     let left_brace = EditableSyntax.from_json(
5867       json.trait_use_conflict_resolution_left_brace, position, source);
5868     position += left_brace.width;
5869     let clauses = EditableSyntax.from_json(
5870       json.trait_use_conflict_resolution_clauses, position, source);
5871     position += clauses.width;
5872     let right_brace = EditableSyntax.from_json(
5873       json.trait_use_conflict_resolution_right_brace, position, source);
5874     position += right_brace.width;
5875     return new TraitUseConflictResolution(
5876         keyword,
5877         names,
5878         left_brace,
5879         clauses,
5880         right_brace);
5881   }
5882   get children_keys()
5883   {
5884     if (TraitUseConflictResolution._children_keys == null)
5885       TraitUseConflictResolution._children_keys = [
5886         'keyword',
5887         'names',
5888         'left_brace',
5889         'clauses',
5890         'right_brace'];
5891     return TraitUseConflictResolution._children_keys;
5892   }
5893 }
5894 class TraitUse extends EditableSyntax
5895 {
5896   constructor(
5897     keyword,
5898     names,
5899     semicolon)
5900   {
5901     super('trait_use', {
5902       keyword: keyword,
5903       names: names,
5904       semicolon: semicolon });
5905   }
5906   get keyword() { return this.children.keyword; }
5907   get names() { return this.children.names; }
5908   get semicolon() { return this.children.semicolon; }
5909   with_keyword(keyword){
5910     return new TraitUse(
5911       keyword,
5912       this.names,
5913       this.semicolon);
5914   }
5915   with_names(names){
5916     return new TraitUse(
5917       this.keyword,
5918       names,
5919       this.semicolon);
5920   }
5921   with_semicolon(semicolon){
5922     return new TraitUse(
5923       this.keyword,
5924       this.names,
5925       semicolon);
5926   }
5927   rewrite(rewriter, parents)
5928   {
5929     if (parents == undefined)
5930       parents = [];
5931     let new_parents = parents.slice();
5932     new_parents.push(this);
5933     var keyword = this.keyword.rewrite(rewriter, new_parents);
5934     var names = this.names.rewrite(rewriter, new_parents);
5935     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
5936     if (
5937       keyword === this.keyword &&
5938       names === this.names &&
5939       semicolon === this.semicolon)
5940     {
5941       return rewriter(this, parents);
5942     }
5943     else
5944     {
5945       return rewriter(new TraitUse(
5946         keyword,
5947         names,
5948         semicolon), parents);
5949     }
5950   }
5951   static from_json(json, position, source)
5952   {
5953     let keyword = EditableSyntax.from_json(
5954       json.trait_use_keyword, position, source);
5955     position += keyword.width;
5956     let names = EditableSyntax.from_json(
5957       json.trait_use_names, position, source);
5958     position += names.width;
5959     let semicolon = EditableSyntax.from_json(
5960       json.trait_use_semicolon, position, source);
5961     position += semicolon.width;
5962     return new TraitUse(
5963         keyword,
5964         names,
5965         semicolon);
5966   }
5967   get children_keys()
5968   {
5969     if (TraitUse._children_keys == null)
5970       TraitUse._children_keys = [
5971         'keyword',
5972         'names',
5973         'semicolon'];
5974     return TraitUse._children_keys;
5975   }
5976 }
5977 class RequireClause extends EditableSyntax
5978 {
5979   constructor(
5980     keyword,
5981     kind,
5982     name,
5983     semicolon)
5984   {
5985     super('require_clause', {
5986       keyword: keyword,
5987       kind: kind,
5988       name: name,
5989       semicolon: semicolon });
5990   }
5991   get keyword() { return this.children.keyword; }
5992   get kind() { return this.children.kind; }
5993   get name() { return this.children.name; }
5994   get semicolon() { return this.children.semicolon; }
5995   with_keyword(keyword){
5996     return new RequireClause(
5997       keyword,
5998       this.kind,
5999       this.name,
6000       this.semicolon);
6001   }
6002   with_kind(kind){
6003     return new RequireClause(
6004       this.keyword,
6005       kind,
6006       this.name,
6007       this.semicolon);
6008   }
6009   with_name(name){
6010     return new RequireClause(
6011       this.keyword,
6012       this.kind,
6013       name,
6014       this.semicolon);
6015   }
6016   with_semicolon(semicolon){
6017     return new RequireClause(
6018       this.keyword,
6019       this.kind,
6020       this.name,
6021       semicolon);
6022   }
6023   rewrite(rewriter, parents)
6024   {
6025     if (parents == undefined)
6026       parents = [];
6027     let new_parents = parents.slice();
6028     new_parents.push(this);
6029     var keyword = this.keyword.rewrite(rewriter, new_parents);
6030     var kind = this.kind.rewrite(rewriter, new_parents);
6031     var name = this.name.rewrite(rewriter, new_parents);
6032     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
6033     if (
6034       keyword === this.keyword &&
6035       kind === this.kind &&
6036       name === this.name &&
6037       semicolon === this.semicolon)
6038     {
6039       return rewriter(this, parents);
6040     }
6041     else
6042     {
6043       return rewriter(new RequireClause(
6044         keyword,
6045         kind,
6046         name,
6047         semicolon), parents);
6048     }
6049   }
6050   static from_json(json, position, source)
6051   {
6052     let keyword = EditableSyntax.from_json(
6053       json.require_keyword, position, source);
6054     position += keyword.width;
6055     let kind = EditableSyntax.from_json(
6056       json.require_kind, position, source);
6057     position += kind.width;
6058     let name = EditableSyntax.from_json(
6059       json.require_name, position, source);
6060     position += name.width;
6061     let semicolon = EditableSyntax.from_json(
6062       json.require_semicolon, position, source);
6063     position += semicolon.width;
6064     return new RequireClause(
6065         keyword,
6066         kind,
6067         name,
6068         semicolon);
6069   }
6070   get children_keys()
6071   {
6072     if (RequireClause._children_keys == null)
6073       RequireClause._children_keys = [
6074         'keyword',
6075         'kind',
6076         'name',
6077         'semicolon'];
6078     return RequireClause._children_keys;
6079   }
6080 }
6081 class ConstDeclaration extends EditableSyntax
6082 {
6083   constructor(
6084     abstract,
6085     keyword,
6086     type_specifier,
6087     declarators,
6088     semicolon)
6089   {
6090     super('const_declaration', {
6091       abstract: abstract,
6092       keyword: keyword,
6093       type_specifier: type_specifier,
6094       declarators: declarators,
6095       semicolon: semicolon });
6096   }
6097   get abstract() { return this.children.abstract; }
6098   get keyword() { return this.children.keyword; }
6099   get type_specifier() { return this.children.type_specifier; }
6100   get declarators() { return this.children.declarators; }
6101   get semicolon() { return this.children.semicolon; }
6102   with_abstract(abstract){
6103     return new ConstDeclaration(
6104       abstract,
6105       this.keyword,
6106       this.type_specifier,
6107       this.declarators,
6108       this.semicolon);
6109   }
6110   with_keyword(keyword){
6111     return new ConstDeclaration(
6112       this.abstract,
6113       keyword,
6114       this.type_specifier,
6115       this.declarators,
6116       this.semicolon);
6117   }
6118   with_type_specifier(type_specifier){
6119     return new ConstDeclaration(
6120       this.abstract,
6121       this.keyword,
6122       type_specifier,
6123       this.declarators,
6124       this.semicolon);
6125   }
6126   with_declarators(declarators){
6127     return new ConstDeclaration(
6128       this.abstract,
6129       this.keyword,
6130       this.type_specifier,
6131       declarators,
6132       this.semicolon);
6133   }
6134   with_semicolon(semicolon){
6135     return new ConstDeclaration(
6136       this.abstract,
6137       this.keyword,
6138       this.type_specifier,
6139       this.declarators,
6140       semicolon);
6141   }
6142   rewrite(rewriter, parents)
6143   {
6144     if (parents == undefined)
6145       parents = [];
6146     let new_parents = parents.slice();
6147     new_parents.push(this);
6148     var abstract = this.abstract.rewrite(rewriter, new_parents);
6149     var keyword = this.keyword.rewrite(rewriter, new_parents);
6150     var type_specifier = this.type_specifier.rewrite(rewriter, new_parents);
6151     var declarators = this.declarators.rewrite(rewriter, new_parents);
6152     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
6153     if (
6154       abstract === this.abstract &&
6155       keyword === this.keyword &&
6156       type_specifier === this.type_specifier &&
6157       declarators === this.declarators &&
6158       semicolon === this.semicolon)
6159     {
6160       return rewriter(this, parents);
6161     }
6162     else
6163     {
6164       return rewriter(new ConstDeclaration(
6165         abstract,
6166         keyword,
6167         type_specifier,
6168         declarators,
6169         semicolon), parents);
6170     }
6171   }
6172   static from_json(json, position, source)
6173   {
6174     let abstract = EditableSyntax.from_json(
6175       json.const_abstract, position, source);
6176     position += abstract.width;
6177     let keyword = EditableSyntax.from_json(
6178       json.const_keyword, position, source);
6179     position += keyword.width;
6180     let type_specifier = EditableSyntax.from_json(
6181       json.const_type_specifier, position, source);
6182     position += type_specifier.width;
6183     let declarators = EditableSyntax.from_json(
6184       json.const_declarators, position, source);
6185     position += declarators.width;
6186     let semicolon = EditableSyntax.from_json(
6187       json.const_semicolon, position, source);
6188     position += semicolon.width;
6189     return new ConstDeclaration(
6190         abstract,
6191         keyword,
6192         type_specifier,
6193         declarators,
6194         semicolon);
6195   }
6196   get children_keys()
6197   {
6198     if (ConstDeclaration._children_keys == null)
6199       ConstDeclaration._children_keys = [
6200         'abstract',
6201         'keyword',
6202         'type_specifier',
6203         'declarators',
6204         'semicolon'];
6205     return ConstDeclaration._children_keys;
6206   }
6207 }
6208 class ConstantDeclarator extends EditableSyntax
6209 {
6210   constructor(
6211     name,
6212     initializer)
6213   {
6214     super('constant_declarator', {
6215       name: name,
6216       initializer: initializer });
6217   }
6218   get name() { return this.children.name; }
6219   get initializer() { return this.children.initializer; }
6220   with_name(name){
6221     return new ConstantDeclarator(
6222       name,
6223       this.initializer);
6224   }
6225   with_initializer(initializer){
6226     return new ConstantDeclarator(
6227       this.name,
6228       initializer);
6229   }
6230   rewrite(rewriter, parents)
6231   {
6232     if (parents == undefined)
6233       parents = [];
6234     let new_parents = parents.slice();
6235     new_parents.push(this);
6236     var name = this.name.rewrite(rewriter, new_parents);
6237     var initializer = this.initializer.rewrite(rewriter, new_parents);
6238     if (
6239       name === this.name &&
6240       initializer === this.initializer)
6241     {
6242       return rewriter(this, parents);
6243     }
6244     else
6245     {
6246       return rewriter(new ConstantDeclarator(
6247         name,
6248         initializer), parents);
6249     }
6250   }
6251   static from_json(json, position, source)
6252   {
6253     let name = EditableSyntax.from_json(
6254       json.constant_declarator_name, position, source);
6255     position += name.width;
6256     let initializer = EditableSyntax.from_json(
6257       json.constant_declarator_initializer, position, source);
6258     position += initializer.width;
6259     return new ConstantDeclarator(
6260         name,
6261         initializer);
6262   }
6263   get children_keys()
6264   {
6265     if (ConstantDeclarator._children_keys == null)
6266       ConstantDeclarator._children_keys = [
6267         'name',
6268         'initializer'];
6269     return ConstantDeclarator._children_keys;
6270   }
6271 }
6272 class TypeConstDeclaration extends EditableSyntax
6273 {
6274   constructor(
6275     abstract,
6276     keyword,
6277     type_keyword,
6278     name,
6279     type_parameters,
6280     type_constraint,
6281     equal,
6282     type_specifier,
6283     semicolon)
6284   {
6285     super('type_const_declaration', {
6286       abstract: abstract,
6287       keyword: keyword,
6288       type_keyword: type_keyword,
6289       name: name,
6290       type_parameters: type_parameters,
6291       type_constraint: type_constraint,
6292       equal: equal,
6293       type_specifier: type_specifier,
6294       semicolon: semicolon });
6295   }
6296   get abstract() { return this.children.abstract; }
6297   get keyword() { return this.children.keyword; }
6298   get type_keyword() { return this.children.type_keyword; }
6299   get name() { return this.children.name; }
6300   get type_parameters() { return this.children.type_parameters; }
6301   get type_constraint() { return this.children.type_constraint; }
6302   get equal() { return this.children.equal; }
6303   get type_specifier() { return this.children.type_specifier; }
6304   get semicolon() { return this.children.semicolon; }
6305   with_abstract(abstract){
6306     return new TypeConstDeclaration(
6307       abstract,
6308       this.keyword,
6309       this.type_keyword,
6310       this.name,
6311       this.type_parameters,
6312       this.type_constraint,
6313       this.equal,
6314       this.type_specifier,
6315       this.semicolon);
6316   }
6317   with_keyword(keyword){
6318     return new TypeConstDeclaration(
6319       this.abstract,
6320       keyword,
6321       this.type_keyword,
6322       this.name,
6323       this.type_parameters,
6324       this.type_constraint,
6325       this.equal,
6326       this.type_specifier,
6327       this.semicolon);
6328   }
6329   with_type_keyword(type_keyword){
6330     return new TypeConstDeclaration(
6331       this.abstract,
6332       this.keyword,
6333       type_keyword,
6334       this.name,
6335       this.type_parameters,
6336       this.type_constraint,
6337       this.equal,
6338       this.type_specifier,
6339       this.semicolon);
6340   }
6341   with_name(name){
6342     return new TypeConstDeclaration(
6343       this.abstract,
6344       this.keyword,
6345       this.type_keyword,
6346       name,
6347       this.type_parameters,
6348       this.type_constraint,
6349       this.equal,
6350       this.type_specifier,
6351       this.semicolon);
6352   }
6353   with_type_parameters(type_parameters){
6354     return new TypeConstDeclaration(
6355       this.abstract,
6356       this.keyword,
6357       this.type_keyword,
6358       this.name,
6359       type_parameters,
6360       this.type_constraint,
6361       this.equal,
6362       this.type_specifier,
6363       this.semicolon);
6364   }
6365   with_type_constraint(type_constraint){
6366     return new TypeConstDeclaration(
6367       this.abstract,
6368       this.keyword,
6369       this.type_keyword,
6370       this.name,
6371       this.type_parameters,
6372       type_constraint,
6373       this.equal,
6374       this.type_specifier,
6375       this.semicolon);
6376   }
6377   with_equal(equal){
6378     return new TypeConstDeclaration(
6379       this.abstract,
6380       this.keyword,
6381       this.type_keyword,
6382       this.name,
6383       this.type_parameters,
6384       this.type_constraint,
6385       equal,
6386       this.type_specifier,
6387       this.semicolon);
6388   }
6389   with_type_specifier(type_specifier){
6390     return new TypeConstDeclaration(
6391       this.abstract,
6392       this.keyword,
6393       this.type_keyword,
6394       this.name,
6395       this.type_parameters,
6396       this.type_constraint,
6397       this.equal,
6398       type_specifier,
6399       this.semicolon);
6400   }
6401   with_semicolon(semicolon){
6402     return new TypeConstDeclaration(
6403       this.abstract,
6404       this.keyword,
6405       this.type_keyword,
6406       this.name,
6407       this.type_parameters,
6408       this.type_constraint,
6409       this.equal,
6410       this.type_specifier,
6411       semicolon);
6412   }
6413   rewrite(rewriter, parents)
6414   {
6415     if (parents == undefined)
6416       parents = [];
6417     let new_parents = parents.slice();
6418     new_parents.push(this);
6419     var abstract = this.abstract.rewrite(rewriter, new_parents);
6420     var keyword = this.keyword.rewrite(rewriter, new_parents);
6421     var type_keyword = this.type_keyword.rewrite(rewriter, new_parents);
6422     var name = this.name.rewrite(rewriter, new_parents);
6423     var type_parameters = this.type_parameters.rewrite(rewriter, new_parents);
6424     var type_constraint = this.type_constraint.rewrite(rewriter, new_parents);
6425     var equal = this.equal.rewrite(rewriter, new_parents);
6426     var type_specifier = this.type_specifier.rewrite(rewriter, new_parents);
6427     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
6428     if (
6429       abstract === this.abstract &&
6430       keyword === this.keyword &&
6431       type_keyword === this.type_keyword &&
6432       name === this.name &&
6433       type_parameters === this.type_parameters &&
6434       type_constraint === this.type_constraint &&
6435       equal === this.equal &&
6436       type_specifier === this.type_specifier &&
6437       semicolon === this.semicolon)
6438     {
6439       return rewriter(this, parents);
6440     }
6441     else
6442     {
6443       return rewriter(new TypeConstDeclaration(
6444         abstract,
6445         keyword,
6446         type_keyword,
6447         name,
6448         type_parameters,
6449         type_constraint,
6450         equal,
6451         type_specifier,
6452         semicolon), parents);
6453     }
6454   }
6455   static from_json(json, position, source)
6456   {
6457     let abstract = EditableSyntax.from_json(
6458       json.type_const_abstract, position, source);
6459     position += abstract.width;
6460     let keyword = EditableSyntax.from_json(
6461       json.type_const_keyword, position, source);
6462     position += keyword.width;
6463     let type_keyword = EditableSyntax.from_json(
6464       json.type_const_type_keyword, position, source);
6465     position += type_keyword.width;
6466     let name = EditableSyntax.from_json(
6467       json.type_const_name, position, source);
6468     position += name.width;
6469     let type_parameters = EditableSyntax.from_json(
6470       json.type_const_type_parameters, position, source);
6471     position += type_parameters.width;
6472     let type_constraint = EditableSyntax.from_json(
6473       json.type_const_type_constraint, position, source);
6474     position += type_constraint.width;
6475     let equal = EditableSyntax.from_json(
6476       json.type_const_equal, position, source);
6477     position += equal.width;
6478     let type_specifier = EditableSyntax.from_json(
6479       json.type_const_type_specifier, position, source);
6480     position += type_specifier.width;
6481     let semicolon = EditableSyntax.from_json(
6482       json.type_const_semicolon, position, source);
6483     position += semicolon.width;
6484     return new TypeConstDeclaration(
6485         abstract,
6486         keyword,
6487         type_keyword,
6488         name,
6489         type_parameters,
6490         type_constraint,
6491         equal,
6492         type_specifier,
6493         semicolon);
6494   }
6495   get children_keys()
6496   {
6497     if (TypeConstDeclaration._children_keys == null)
6498       TypeConstDeclaration._children_keys = [
6499         'abstract',
6500         'keyword',
6501         'type_keyword',
6502         'name',
6503         'type_parameters',
6504         'type_constraint',
6505         'equal',
6506         'type_specifier',
6507         'semicolon'];
6508     return TypeConstDeclaration._children_keys;
6509   }
6510 }
6511 class DecoratedExpression extends EditableSyntax
6512 {
6513   constructor(
6514     decorator,
6515     expression)
6516   {
6517     super('decorated_expression', {
6518       decorator: decorator,
6519       expression: expression });
6520   }
6521   get decorator() { return this.children.decorator; }
6522   get expression() { return this.children.expression; }
6523   with_decorator(decorator){
6524     return new DecoratedExpression(
6525       decorator,
6526       this.expression);
6527   }
6528   with_expression(expression){
6529     return new DecoratedExpression(
6530       this.decorator,
6531       expression);
6532   }
6533   rewrite(rewriter, parents)
6534   {
6535     if (parents == undefined)
6536       parents = [];
6537     let new_parents = parents.slice();
6538     new_parents.push(this);
6539     var decorator = this.decorator.rewrite(rewriter, new_parents);
6540     var expression = this.expression.rewrite(rewriter, new_parents);
6541     if (
6542       decorator === this.decorator &&
6543       expression === this.expression)
6544     {
6545       return rewriter(this, parents);
6546     }
6547     else
6548     {
6549       return rewriter(new DecoratedExpression(
6550         decorator,
6551         expression), parents);
6552     }
6553   }
6554   static from_json(json, position, source)
6555   {
6556     let decorator = EditableSyntax.from_json(
6557       json.decorated_expression_decorator, position, source);
6558     position += decorator.width;
6559     let expression = EditableSyntax.from_json(
6560       json.decorated_expression_expression, position, source);
6561     position += expression.width;
6562     return new DecoratedExpression(
6563         decorator,
6564         expression);
6565   }
6566   get children_keys()
6567   {
6568     if (DecoratedExpression._children_keys == null)
6569       DecoratedExpression._children_keys = [
6570         'decorator',
6571         'expression'];
6572     return DecoratedExpression._children_keys;
6573   }
6574 }
6575 class ParameterDeclaration extends EditableSyntax
6576 {
6577   constructor(
6578     attribute,
6579     visibility,
6580     call_convention,
6581     type,
6582     name,
6583     default_value)
6584   {
6585     super('parameter_declaration', {
6586       attribute: attribute,
6587       visibility: visibility,
6588       call_convention: call_convention,
6589       type: type,
6590       name: name,
6591       default_value: default_value });
6592   }
6593   get attribute() { return this.children.attribute; }
6594   get visibility() { return this.children.visibility; }
6595   get call_convention() { return this.children.call_convention; }
6596   get type() { return this.children.type; }
6597   get name() { return this.children.name; }
6598   get default_value() { return this.children.default_value; }
6599   with_attribute(attribute){
6600     return new ParameterDeclaration(
6601       attribute,
6602       this.visibility,
6603       this.call_convention,
6604       this.type,
6605       this.name,
6606       this.default_value);
6607   }
6608   with_visibility(visibility){
6609     return new ParameterDeclaration(
6610       this.attribute,
6611       visibility,
6612       this.call_convention,
6613       this.type,
6614       this.name,
6615       this.default_value);
6616   }
6617   with_call_convention(call_convention){
6618     return new ParameterDeclaration(
6619       this.attribute,
6620       this.visibility,
6621       call_convention,
6622       this.type,
6623       this.name,
6624       this.default_value);
6625   }
6626   with_type(type){
6627     return new ParameterDeclaration(
6628       this.attribute,
6629       this.visibility,
6630       this.call_convention,
6631       type,
6632       this.name,
6633       this.default_value);
6634   }
6635   with_name(name){
6636     return new ParameterDeclaration(
6637       this.attribute,
6638       this.visibility,
6639       this.call_convention,
6640       this.type,
6641       name,
6642       this.default_value);
6643   }
6644   with_default_value(default_value){
6645     return new ParameterDeclaration(
6646       this.attribute,
6647       this.visibility,
6648       this.call_convention,
6649       this.type,
6650       this.name,
6651       default_value);
6652   }
6653   rewrite(rewriter, parents)
6654   {
6655     if (parents == undefined)
6656       parents = [];
6657     let new_parents = parents.slice();
6658     new_parents.push(this);
6659     var attribute = this.attribute.rewrite(rewriter, new_parents);
6660     var visibility = this.visibility.rewrite(rewriter, new_parents);
6661     var call_convention = this.call_convention.rewrite(rewriter, new_parents);
6662     var type = this.type.rewrite(rewriter, new_parents);
6663     var name = this.name.rewrite(rewriter, new_parents);
6664     var default_value = this.default_value.rewrite(rewriter, new_parents);
6665     if (
6666       attribute === this.attribute &&
6667       visibility === this.visibility &&
6668       call_convention === this.call_convention &&
6669       type === this.type &&
6670       name === this.name &&
6671       default_value === this.default_value)
6672     {
6673       return rewriter(this, parents);
6674     }
6675     else
6676     {
6677       return rewriter(new ParameterDeclaration(
6678         attribute,
6679         visibility,
6680         call_convention,
6681         type,
6682         name,
6683         default_value), parents);
6684     }
6685   }
6686   static from_json(json, position, source)
6687   {
6688     let attribute = EditableSyntax.from_json(
6689       json.parameter_attribute, position, source);
6690     position += attribute.width;
6691     let visibility = EditableSyntax.from_json(
6692       json.parameter_visibility, position, source);
6693     position += visibility.width;
6694     let call_convention = EditableSyntax.from_json(
6695       json.parameter_call_convention, position, source);
6696     position += call_convention.width;
6697     let type = EditableSyntax.from_json(
6698       json.parameter_type, position, source);
6699     position += type.width;
6700     let name = EditableSyntax.from_json(
6701       json.parameter_name, position, source);
6702     position += name.width;
6703     let default_value = EditableSyntax.from_json(
6704       json.parameter_default_value, position, source);
6705     position += default_value.width;
6706     return new ParameterDeclaration(
6707         attribute,
6708         visibility,
6709         call_convention,
6710         type,
6711         name,
6712         default_value);
6713   }
6714   get children_keys()
6715   {
6716     if (ParameterDeclaration._children_keys == null)
6717       ParameterDeclaration._children_keys = [
6718         'attribute',
6719         'visibility',
6720         'call_convention',
6721         'type',
6722         'name',
6723         'default_value'];
6724     return ParameterDeclaration._children_keys;
6725   }
6726 }
6727 class VariadicParameter extends EditableSyntax
6728 {
6729   constructor(
6730     call_convention,
6731     type,
6732     ellipsis)
6733   {
6734     super('variadic_parameter', {
6735       call_convention: call_convention,
6736       type: type,
6737       ellipsis: ellipsis });
6738   }
6739   get call_convention() { return this.children.call_convention; }
6740   get type() { return this.children.type; }
6741   get ellipsis() { return this.children.ellipsis; }
6742   with_call_convention(call_convention){
6743     return new VariadicParameter(
6744       call_convention,
6745       this.type,
6746       this.ellipsis);
6747   }
6748   with_type(type){
6749     return new VariadicParameter(
6750       this.call_convention,
6751       type,
6752       this.ellipsis);
6753   }
6754   with_ellipsis(ellipsis){
6755     return new VariadicParameter(
6756       this.call_convention,
6757       this.type,
6758       ellipsis);
6759   }
6760   rewrite(rewriter, parents)
6761   {
6762     if (parents == undefined)
6763       parents = [];
6764     let new_parents = parents.slice();
6765     new_parents.push(this);
6766     var call_convention = this.call_convention.rewrite(rewriter, new_parents);
6767     var type = this.type.rewrite(rewriter, new_parents);
6768     var ellipsis = this.ellipsis.rewrite(rewriter, new_parents);
6769     if (
6770       call_convention === this.call_convention &&
6771       type === this.type &&
6772       ellipsis === this.ellipsis)
6773     {
6774       return rewriter(this, parents);
6775     }
6776     else
6777     {
6778       return rewriter(new VariadicParameter(
6779         call_convention,
6780         type,
6781         ellipsis), parents);
6782     }
6783   }
6784   static from_json(json, position, source)
6785   {
6786     let call_convention = EditableSyntax.from_json(
6787       json.variadic_parameter_call_convention, position, source);
6788     position += call_convention.width;
6789     let type = EditableSyntax.from_json(
6790       json.variadic_parameter_type, position, source);
6791     position += type.width;
6792     let ellipsis = EditableSyntax.from_json(
6793       json.variadic_parameter_ellipsis, position, source);
6794     position += ellipsis.width;
6795     return new VariadicParameter(
6796         call_convention,
6797         type,
6798         ellipsis);
6799   }
6800   get children_keys()
6801   {
6802     if (VariadicParameter._children_keys == null)
6803       VariadicParameter._children_keys = [
6804         'call_convention',
6805         'type',
6806         'ellipsis'];
6807     return VariadicParameter._children_keys;
6808   }
6809 }
6810 class AttributeSpecification extends EditableSyntax
6811 {
6812   constructor(
6813     left_double_angle,
6814     attributes,
6815     right_double_angle)
6816   {
6817     super('attribute_specification', {
6818       left_double_angle: left_double_angle,
6819       attributes: attributes,
6820       right_double_angle: right_double_angle });
6821   }
6822   get left_double_angle() { return this.children.left_double_angle; }
6823   get attributes() { return this.children.attributes; }
6824   get right_double_angle() { return this.children.right_double_angle; }
6825   with_left_double_angle(left_double_angle){
6826     return new AttributeSpecification(
6827       left_double_angle,
6828       this.attributes,
6829       this.right_double_angle);
6830   }
6831   with_attributes(attributes){
6832     return new AttributeSpecification(
6833       this.left_double_angle,
6834       attributes,
6835       this.right_double_angle);
6836   }
6837   with_right_double_angle(right_double_angle){
6838     return new AttributeSpecification(
6839       this.left_double_angle,
6840       this.attributes,
6841       right_double_angle);
6842   }
6843   rewrite(rewriter, parents)
6844   {
6845     if (parents == undefined)
6846       parents = [];
6847     let new_parents = parents.slice();
6848     new_parents.push(this);
6849     var left_double_angle = this.left_double_angle.rewrite(rewriter, new_parents);
6850     var attributes = this.attributes.rewrite(rewriter, new_parents);
6851     var right_double_angle = this.right_double_angle.rewrite(rewriter, new_parents);
6852     if (
6853       left_double_angle === this.left_double_angle &&
6854       attributes === this.attributes &&
6855       right_double_angle === this.right_double_angle)
6856     {
6857       return rewriter(this, parents);
6858     }
6859     else
6860     {
6861       return rewriter(new AttributeSpecification(
6862         left_double_angle,
6863         attributes,
6864         right_double_angle), parents);
6865     }
6866   }
6867   static from_json(json, position, source)
6868   {
6869     let left_double_angle = EditableSyntax.from_json(
6870       json.attribute_specification_left_double_angle, position, source);
6871     position += left_double_angle.width;
6872     let attributes = EditableSyntax.from_json(
6873       json.attribute_specification_attributes, position, source);
6874     position += attributes.width;
6875     let right_double_angle = EditableSyntax.from_json(
6876       json.attribute_specification_right_double_angle, position, source);
6877     position += right_double_angle.width;
6878     return new AttributeSpecification(
6879         left_double_angle,
6880         attributes,
6881         right_double_angle);
6882   }
6883   get children_keys()
6884   {
6885     if (AttributeSpecification._children_keys == null)
6886       AttributeSpecification._children_keys = [
6887         'left_double_angle',
6888         'attributes',
6889         'right_double_angle'];
6890     return AttributeSpecification._children_keys;
6891   }
6892 }
6893 class Attribute extends EditableSyntax
6894 {
6895   constructor(
6896     name,
6897     left_paren,
6898     values,
6899     right_paren)
6900   {
6901     super('attribute', {
6902       name: name,
6903       left_paren: left_paren,
6904       values: values,
6905       right_paren: right_paren });
6906   }
6907   get name() { return this.children.name; }
6908   get left_paren() { return this.children.left_paren; }
6909   get values() { return this.children.values; }
6910   get right_paren() { return this.children.right_paren; }
6911   with_name(name){
6912     return new Attribute(
6913       name,
6914       this.left_paren,
6915       this.values,
6916       this.right_paren);
6917   }
6918   with_left_paren(left_paren){
6919     return new Attribute(
6920       this.name,
6921       left_paren,
6922       this.values,
6923       this.right_paren);
6924   }
6925   with_values(values){
6926     return new Attribute(
6927       this.name,
6928       this.left_paren,
6929       values,
6930       this.right_paren);
6931   }
6932   with_right_paren(right_paren){
6933     return new Attribute(
6934       this.name,
6935       this.left_paren,
6936       this.values,
6937       right_paren);
6938   }
6939   rewrite(rewriter, parents)
6940   {
6941     if (parents == undefined)
6942       parents = [];
6943     let new_parents = parents.slice();
6944     new_parents.push(this);
6945     var name = this.name.rewrite(rewriter, new_parents);
6946     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
6947     var values = this.values.rewrite(rewriter, new_parents);
6948     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
6949     if (
6950       name === this.name &&
6951       left_paren === this.left_paren &&
6952       values === this.values &&
6953       right_paren === this.right_paren)
6954     {
6955       return rewriter(this, parents);
6956     }
6957     else
6958     {
6959       return rewriter(new Attribute(
6960         name,
6961         left_paren,
6962         values,
6963         right_paren), parents);
6964     }
6965   }
6966   static from_json(json, position, source)
6967   {
6968     let name = EditableSyntax.from_json(
6969       json.attribute_name, position, source);
6970     position += name.width;
6971     let left_paren = EditableSyntax.from_json(
6972       json.attribute_left_paren, position, source);
6973     position += left_paren.width;
6974     let values = EditableSyntax.from_json(
6975       json.attribute_values, position, source);
6976     position += values.width;
6977     let right_paren = EditableSyntax.from_json(
6978       json.attribute_right_paren, position, source);
6979     position += right_paren.width;
6980     return new Attribute(
6981         name,
6982         left_paren,
6983         values,
6984         right_paren);
6985   }
6986   get children_keys()
6987   {
6988     if (Attribute._children_keys == null)
6989       Attribute._children_keys = [
6990         'name',
6991         'left_paren',
6992         'values',
6993         'right_paren'];
6994     return Attribute._children_keys;
6995   }
6996 }
6997 class InclusionExpression extends EditableSyntax
6998 {
6999   constructor(
7000     require,
7001     filename)
7002   {
7003     super('inclusion_expression', {
7004       require: require,
7005       filename: filename });
7006   }
7007   get require() { return this.children.require; }
7008   get filename() { return this.children.filename; }
7009   with_require(require){
7010     return new InclusionExpression(
7011       require,
7012       this.filename);
7013   }
7014   with_filename(filename){
7015     return new InclusionExpression(
7016       this.require,
7017       filename);
7018   }
7019   rewrite(rewriter, parents)
7020   {
7021     if (parents == undefined)
7022       parents = [];
7023     let new_parents = parents.slice();
7024     new_parents.push(this);
7025     var require = this.require.rewrite(rewriter, new_parents);
7026     var filename = this.filename.rewrite(rewriter, new_parents);
7027     if (
7028       require === this.require &&
7029       filename === this.filename)
7030     {
7031       return rewriter(this, parents);
7032     }
7033     else
7034     {
7035       return rewriter(new InclusionExpression(
7036         require,
7037         filename), parents);
7038     }
7039   }
7040   static from_json(json, position, source)
7041   {
7042     let require = EditableSyntax.from_json(
7043       json.inclusion_require, position, source);
7044     position += require.width;
7045     let filename = EditableSyntax.from_json(
7046       json.inclusion_filename, position, source);
7047     position += filename.width;
7048     return new InclusionExpression(
7049         require,
7050         filename);
7051   }
7052   get children_keys()
7053   {
7054     if (InclusionExpression._children_keys == null)
7055       InclusionExpression._children_keys = [
7056         'require',
7057         'filename'];
7058     return InclusionExpression._children_keys;
7059   }
7060 }
7061 class InclusionDirective extends EditableSyntax
7062 {
7063   constructor(
7064     expression,
7065     semicolon)
7066   {
7067     super('inclusion_directive', {
7068       expression: expression,
7069       semicolon: semicolon });
7070   }
7071   get expression() { return this.children.expression; }
7072   get semicolon() { return this.children.semicolon; }
7073   with_expression(expression){
7074     return new InclusionDirective(
7075       expression,
7076       this.semicolon);
7077   }
7078   with_semicolon(semicolon){
7079     return new InclusionDirective(
7080       this.expression,
7081       semicolon);
7082   }
7083   rewrite(rewriter, parents)
7084   {
7085     if (parents == undefined)
7086       parents = [];
7087     let new_parents = parents.slice();
7088     new_parents.push(this);
7089     var expression = this.expression.rewrite(rewriter, new_parents);
7090     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
7091     if (
7092       expression === this.expression &&
7093       semicolon === this.semicolon)
7094     {
7095       return rewriter(this, parents);
7096     }
7097     else
7098     {
7099       return rewriter(new InclusionDirective(
7100         expression,
7101         semicolon), parents);
7102     }
7103   }
7104   static from_json(json, position, source)
7105   {
7106     let expression = EditableSyntax.from_json(
7107       json.inclusion_expression, position, source);
7108     position += expression.width;
7109     let semicolon = EditableSyntax.from_json(
7110       json.inclusion_semicolon, position, source);
7111     position += semicolon.width;
7112     return new InclusionDirective(
7113         expression,
7114         semicolon);
7115   }
7116   get children_keys()
7117   {
7118     if (InclusionDirective._children_keys == null)
7119       InclusionDirective._children_keys = [
7120         'expression',
7121         'semicolon'];
7122     return InclusionDirective._children_keys;
7123   }
7124 }
7125 class CompoundStatement extends EditableSyntax
7126 {
7127   constructor(
7128     left_brace,
7129     statements,
7130     right_brace)
7131   {
7132     super('compound_statement', {
7133       left_brace: left_brace,
7134       statements: statements,
7135       right_brace: right_brace });
7136   }
7137   get left_brace() { return this.children.left_brace; }
7138   get statements() { return this.children.statements; }
7139   get right_brace() { return this.children.right_brace; }
7140   with_left_brace(left_brace){
7141     return new CompoundStatement(
7142       left_brace,
7143       this.statements,
7144       this.right_brace);
7145   }
7146   with_statements(statements){
7147     return new CompoundStatement(
7148       this.left_brace,
7149       statements,
7150       this.right_brace);
7151   }
7152   with_right_brace(right_brace){
7153     return new CompoundStatement(
7154       this.left_brace,
7155       this.statements,
7156       right_brace);
7157   }
7158   rewrite(rewriter, parents)
7159   {
7160     if (parents == undefined)
7161       parents = [];
7162     let new_parents = parents.slice();
7163     new_parents.push(this);
7164     var left_brace = this.left_brace.rewrite(rewriter, new_parents);
7165     var statements = this.statements.rewrite(rewriter, new_parents);
7166     var right_brace = this.right_brace.rewrite(rewriter, new_parents);
7167     if (
7168       left_brace === this.left_brace &&
7169       statements === this.statements &&
7170       right_brace === this.right_brace)
7171     {
7172       return rewriter(this, parents);
7173     }
7174     else
7175     {
7176       return rewriter(new CompoundStatement(
7177         left_brace,
7178         statements,
7179         right_brace), parents);
7180     }
7181   }
7182   static from_json(json, position, source)
7183   {
7184     let left_brace = EditableSyntax.from_json(
7185       json.compound_left_brace, position, source);
7186     position += left_brace.width;
7187     let statements = EditableSyntax.from_json(
7188       json.compound_statements, position, source);
7189     position += statements.width;
7190     let right_brace = EditableSyntax.from_json(
7191       json.compound_right_brace, position, source);
7192     position += right_brace.width;
7193     return new CompoundStatement(
7194         left_brace,
7195         statements,
7196         right_brace);
7197   }
7198   get children_keys()
7199   {
7200     if (CompoundStatement._children_keys == null)
7201       CompoundStatement._children_keys = [
7202         'left_brace',
7203         'statements',
7204         'right_brace'];
7205     return CompoundStatement._children_keys;
7206   }
7207 }
7208 class AlternateLoopStatement extends EditableSyntax
7209 {
7210   constructor(
7211     opening_colon,
7212     statements,
7213     closing_keyword,
7214     closing_semicolon)
7215   {
7216     super('alternate_loop_statement', {
7217       opening_colon: opening_colon,
7218       statements: statements,
7219       closing_keyword: closing_keyword,
7220       closing_semicolon: closing_semicolon });
7221   }
7222   get opening_colon() { return this.children.opening_colon; }
7223   get statements() { return this.children.statements; }
7224   get closing_keyword() { return this.children.closing_keyword; }
7225   get closing_semicolon() { return this.children.closing_semicolon; }
7226   with_opening_colon(opening_colon){
7227     return new AlternateLoopStatement(
7228       opening_colon,
7229       this.statements,
7230       this.closing_keyword,
7231       this.closing_semicolon);
7232   }
7233   with_statements(statements){
7234     return new AlternateLoopStatement(
7235       this.opening_colon,
7236       statements,
7237       this.closing_keyword,
7238       this.closing_semicolon);
7239   }
7240   with_closing_keyword(closing_keyword){
7241     return new AlternateLoopStatement(
7242       this.opening_colon,
7243       this.statements,
7244       closing_keyword,
7245       this.closing_semicolon);
7246   }
7247   with_closing_semicolon(closing_semicolon){
7248     return new AlternateLoopStatement(
7249       this.opening_colon,
7250       this.statements,
7251       this.closing_keyword,
7252       closing_semicolon);
7253   }
7254   rewrite(rewriter, parents)
7255   {
7256     if (parents == undefined)
7257       parents = [];
7258     let new_parents = parents.slice();
7259     new_parents.push(this);
7260     var opening_colon = this.opening_colon.rewrite(rewriter, new_parents);
7261     var statements = this.statements.rewrite(rewriter, new_parents);
7262     var closing_keyword = this.closing_keyword.rewrite(rewriter, new_parents);
7263     var closing_semicolon = this.closing_semicolon.rewrite(rewriter, new_parents);
7264     if (
7265       opening_colon === this.opening_colon &&
7266       statements === this.statements &&
7267       closing_keyword === this.closing_keyword &&
7268       closing_semicolon === this.closing_semicolon)
7269     {
7270       return rewriter(this, parents);
7271     }
7272     else
7273     {
7274       return rewriter(new AlternateLoopStatement(
7275         opening_colon,
7276         statements,
7277         closing_keyword,
7278         closing_semicolon), parents);
7279     }
7280   }
7281   static from_json(json, position, source)
7282   {
7283     let opening_colon = EditableSyntax.from_json(
7284       json.alternate_loop_opening_colon, position, source);
7285     position += opening_colon.width;
7286     let statements = EditableSyntax.from_json(
7287       json.alternate_loop_statements, position, source);
7288     position += statements.width;
7289     let closing_keyword = EditableSyntax.from_json(
7290       json.alternate_loop_closing_keyword, position, source);
7291     position += closing_keyword.width;
7292     let closing_semicolon = EditableSyntax.from_json(
7293       json.alternate_loop_closing_semicolon, position, source);
7294     position += closing_semicolon.width;
7295     return new AlternateLoopStatement(
7296         opening_colon,
7297         statements,
7298         closing_keyword,
7299         closing_semicolon);
7300   }
7301   get children_keys()
7302   {
7303     if (AlternateLoopStatement._children_keys == null)
7304       AlternateLoopStatement._children_keys = [
7305         'opening_colon',
7306         'statements',
7307         'closing_keyword',
7308         'closing_semicolon'];
7309     return AlternateLoopStatement._children_keys;
7310   }
7311 }
7312 class ExpressionStatement extends EditableSyntax
7313 {
7314   constructor(
7315     expression,
7316     semicolon)
7317   {
7318     super('expression_statement', {
7319       expression: expression,
7320       semicolon: semicolon });
7321   }
7322   get expression() { return this.children.expression; }
7323   get semicolon() { return this.children.semicolon; }
7324   with_expression(expression){
7325     return new ExpressionStatement(
7326       expression,
7327       this.semicolon);
7328   }
7329   with_semicolon(semicolon){
7330     return new ExpressionStatement(
7331       this.expression,
7332       semicolon);
7333   }
7334   rewrite(rewriter, parents)
7335   {
7336     if (parents == undefined)
7337       parents = [];
7338     let new_parents = parents.slice();
7339     new_parents.push(this);
7340     var expression = this.expression.rewrite(rewriter, new_parents);
7341     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
7342     if (
7343       expression === this.expression &&
7344       semicolon === this.semicolon)
7345     {
7346       return rewriter(this, parents);
7347     }
7348     else
7349     {
7350       return rewriter(new ExpressionStatement(
7351         expression,
7352         semicolon), parents);
7353     }
7354   }
7355   static from_json(json, position, source)
7356   {
7357     let expression = EditableSyntax.from_json(
7358       json.expression_statement_expression, position, source);
7359     position += expression.width;
7360     let semicolon = EditableSyntax.from_json(
7361       json.expression_statement_semicolon, position, source);
7362     position += semicolon.width;
7363     return new ExpressionStatement(
7364         expression,
7365         semicolon);
7366   }
7367   get children_keys()
7368   {
7369     if (ExpressionStatement._children_keys == null)
7370       ExpressionStatement._children_keys = [
7371         'expression',
7372         'semicolon'];
7373     return ExpressionStatement._children_keys;
7374   }
7375 }
7376 class MarkupSection extends EditableSyntax
7377 {
7378   constructor(
7379     prefix,
7380     text,
7381     suffix,
7382     expression)
7383   {
7384     super('markup_section', {
7385       prefix: prefix,
7386       text: text,
7387       suffix: suffix,
7388       expression: expression });
7389   }
7390   get prefix() { return this.children.prefix; }
7391   get text() { return this.children.text; }
7392   get suffix() { return this.children.suffix; }
7393   get expression() { return this.children.expression; }
7394   with_prefix(prefix){
7395     return new MarkupSection(
7396       prefix,
7397       this.text,
7398       this.suffix,
7399       this.expression);
7400   }
7401   with_text(text){
7402     return new MarkupSection(
7403       this.prefix,
7404       text,
7405       this.suffix,
7406       this.expression);
7407   }
7408   with_suffix(suffix){
7409     return new MarkupSection(
7410       this.prefix,
7411       this.text,
7412       suffix,
7413       this.expression);
7414   }
7415   with_expression(expression){
7416     return new MarkupSection(
7417       this.prefix,
7418       this.text,
7419       this.suffix,
7420       expression);
7421   }
7422   rewrite(rewriter, parents)
7423   {
7424     if (parents == undefined)
7425       parents = [];
7426     let new_parents = parents.slice();
7427     new_parents.push(this);
7428     var prefix = this.prefix.rewrite(rewriter, new_parents);
7429     var text = this.text.rewrite(rewriter, new_parents);
7430     var suffix = this.suffix.rewrite(rewriter, new_parents);
7431     var expression = this.expression.rewrite(rewriter, new_parents);
7432     if (
7433       prefix === this.prefix &&
7434       text === this.text &&
7435       suffix === this.suffix &&
7436       expression === this.expression)
7437     {
7438       return rewriter(this, parents);
7439     }
7440     else
7441     {
7442       return rewriter(new MarkupSection(
7443         prefix,
7444         text,
7445         suffix,
7446         expression), parents);
7447     }
7448   }
7449   static from_json(json, position, source)
7450   {
7451     let prefix = EditableSyntax.from_json(
7452       json.markup_prefix, position, source);
7453     position += prefix.width;
7454     let text = EditableSyntax.from_json(
7455       json.markup_text, position, source);
7456     position += text.width;
7457     let suffix = EditableSyntax.from_json(
7458       json.markup_suffix, position, source);
7459     position += suffix.width;
7460     let expression = EditableSyntax.from_json(
7461       json.markup_expression, position, source);
7462     position += expression.width;
7463     return new MarkupSection(
7464         prefix,
7465         text,
7466         suffix,
7467         expression);
7468   }
7469   get children_keys()
7470   {
7471     if (MarkupSection._children_keys == null)
7472       MarkupSection._children_keys = [
7473         'prefix',
7474         'text',
7475         'suffix',
7476         'expression'];
7477     return MarkupSection._children_keys;
7478   }
7479 }
7480 class MarkupSuffix extends EditableSyntax
7481 {
7482   constructor(
7483     less_than_question,
7484     name)
7485   {
7486     super('markup_suffix', {
7487       less_than_question: less_than_question,
7488       name: name });
7489   }
7490   get less_than_question() { return this.children.less_than_question; }
7491   get name() { return this.children.name; }
7492   with_less_than_question(less_than_question){
7493     return new MarkupSuffix(
7494       less_than_question,
7495       this.name);
7496   }
7497   with_name(name){
7498     return new MarkupSuffix(
7499       this.less_than_question,
7500       name);
7501   }
7502   rewrite(rewriter, parents)
7503   {
7504     if (parents == undefined)
7505       parents = [];
7506     let new_parents = parents.slice();
7507     new_parents.push(this);
7508     var less_than_question = this.less_than_question.rewrite(rewriter, new_parents);
7509     var name = this.name.rewrite(rewriter, new_parents);
7510     if (
7511       less_than_question === this.less_than_question &&
7512       name === this.name)
7513     {
7514       return rewriter(this, parents);
7515     }
7516     else
7517     {
7518       return rewriter(new MarkupSuffix(
7519         less_than_question,
7520         name), parents);
7521     }
7522   }
7523   static from_json(json, position, source)
7524   {
7525     let less_than_question = EditableSyntax.from_json(
7526       json.markup_suffix_less_than_question, position, source);
7527     position += less_than_question.width;
7528     let name = EditableSyntax.from_json(
7529       json.markup_suffix_name, position, source);
7530     position += name.width;
7531     return new MarkupSuffix(
7532         less_than_question,
7533         name);
7534   }
7535   get children_keys()
7536   {
7537     if (MarkupSuffix._children_keys == null)
7538       MarkupSuffix._children_keys = [
7539         'less_than_question',
7540         'name'];
7541     return MarkupSuffix._children_keys;
7542   }
7543 }
7544 class UnsetStatement extends EditableSyntax
7545 {
7546   constructor(
7547     keyword,
7548     left_paren,
7549     variables,
7550     right_paren,
7551     semicolon)
7552   {
7553     super('unset_statement', {
7554       keyword: keyword,
7555       left_paren: left_paren,
7556       variables: variables,
7557       right_paren: right_paren,
7558       semicolon: semicolon });
7559   }
7560   get keyword() { return this.children.keyword; }
7561   get left_paren() { return this.children.left_paren; }
7562   get variables() { return this.children.variables; }
7563   get right_paren() { return this.children.right_paren; }
7564   get semicolon() { return this.children.semicolon; }
7565   with_keyword(keyword){
7566     return new UnsetStatement(
7567       keyword,
7568       this.left_paren,
7569       this.variables,
7570       this.right_paren,
7571       this.semicolon);
7572   }
7573   with_left_paren(left_paren){
7574     return new UnsetStatement(
7575       this.keyword,
7576       left_paren,
7577       this.variables,
7578       this.right_paren,
7579       this.semicolon);
7580   }
7581   with_variables(variables){
7582     return new UnsetStatement(
7583       this.keyword,
7584       this.left_paren,
7585       variables,
7586       this.right_paren,
7587       this.semicolon);
7588   }
7589   with_right_paren(right_paren){
7590     return new UnsetStatement(
7591       this.keyword,
7592       this.left_paren,
7593       this.variables,
7594       right_paren,
7595       this.semicolon);
7596   }
7597   with_semicolon(semicolon){
7598     return new UnsetStatement(
7599       this.keyword,
7600       this.left_paren,
7601       this.variables,
7602       this.right_paren,
7603       semicolon);
7604   }
7605   rewrite(rewriter, parents)
7606   {
7607     if (parents == undefined)
7608       parents = [];
7609     let new_parents = parents.slice();
7610     new_parents.push(this);
7611     var keyword = this.keyword.rewrite(rewriter, new_parents);
7612     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
7613     var variables = this.variables.rewrite(rewriter, new_parents);
7614     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
7615     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
7616     if (
7617       keyword === this.keyword &&
7618       left_paren === this.left_paren &&
7619       variables === this.variables &&
7620       right_paren === this.right_paren &&
7621       semicolon === this.semicolon)
7622     {
7623       return rewriter(this, parents);
7624     }
7625     else
7626     {
7627       return rewriter(new UnsetStatement(
7628         keyword,
7629         left_paren,
7630         variables,
7631         right_paren,
7632         semicolon), parents);
7633     }
7634   }
7635   static from_json(json, position, source)
7636   {
7637     let keyword = EditableSyntax.from_json(
7638       json.unset_keyword, position, source);
7639     position += keyword.width;
7640     let left_paren = EditableSyntax.from_json(
7641       json.unset_left_paren, position, source);
7642     position += left_paren.width;
7643     let variables = EditableSyntax.from_json(
7644       json.unset_variables, position, source);
7645     position += variables.width;
7646     let right_paren = EditableSyntax.from_json(
7647       json.unset_right_paren, position, source);
7648     position += right_paren.width;
7649     let semicolon = EditableSyntax.from_json(
7650       json.unset_semicolon, position, source);
7651     position += semicolon.width;
7652     return new UnsetStatement(
7653         keyword,
7654         left_paren,
7655         variables,
7656         right_paren,
7657         semicolon);
7658   }
7659   get children_keys()
7660   {
7661     if (UnsetStatement._children_keys == null)
7662       UnsetStatement._children_keys = [
7663         'keyword',
7664         'left_paren',
7665         'variables',
7666         'right_paren',
7667         'semicolon'];
7668     return UnsetStatement._children_keys;
7669   }
7670 }
7671 class UsingStatementBlockScoped extends EditableSyntax
7672 {
7673   constructor(
7674     await_keyword,
7675     using_keyword,
7676     left_paren,
7677     expressions,
7678     right_paren,
7679     body)
7680   {
7681     super('using_statement_block_scoped', {
7682       await_keyword: await_keyword,
7683       using_keyword: using_keyword,
7684       left_paren: left_paren,
7685       expressions: expressions,
7686       right_paren: right_paren,
7687       body: body });
7688   }
7689   get await_keyword() { return this.children.await_keyword; }
7690   get using_keyword() { return this.children.using_keyword; }
7691   get left_paren() { return this.children.left_paren; }
7692   get expressions() { return this.children.expressions; }
7693   get right_paren() { return this.children.right_paren; }
7694   get body() { return this.children.body; }
7695   with_await_keyword(await_keyword){
7696     return new UsingStatementBlockScoped(
7697       await_keyword,
7698       this.using_keyword,
7699       this.left_paren,
7700       this.expressions,
7701       this.right_paren,
7702       this.body);
7703   }
7704   with_using_keyword(using_keyword){
7705     return new UsingStatementBlockScoped(
7706       this.await_keyword,
7707       using_keyword,
7708       this.left_paren,
7709       this.expressions,
7710       this.right_paren,
7711       this.body);
7712   }
7713   with_left_paren(left_paren){
7714     return new UsingStatementBlockScoped(
7715       this.await_keyword,
7716       this.using_keyword,
7717       left_paren,
7718       this.expressions,
7719       this.right_paren,
7720       this.body);
7721   }
7722   with_expressions(expressions){
7723     return new UsingStatementBlockScoped(
7724       this.await_keyword,
7725       this.using_keyword,
7726       this.left_paren,
7727       expressions,
7728       this.right_paren,
7729       this.body);
7730   }
7731   with_right_paren(right_paren){
7732     return new UsingStatementBlockScoped(
7733       this.await_keyword,
7734       this.using_keyword,
7735       this.left_paren,
7736       this.expressions,
7737       right_paren,
7738       this.body);
7739   }
7740   with_body(body){
7741     return new UsingStatementBlockScoped(
7742       this.await_keyword,
7743       this.using_keyword,
7744       this.left_paren,
7745       this.expressions,
7746       this.right_paren,
7747       body);
7748   }
7749   rewrite(rewriter, parents)
7750   {
7751     if (parents == undefined)
7752       parents = [];
7753     let new_parents = parents.slice();
7754     new_parents.push(this);
7755     var await_keyword = this.await_keyword.rewrite(rewriter, new_parents);
7756     var using_keyword = this.using_keyword.rewrite(rewriter, new_parents);
7757     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
7758     var expressions = this.expressions.rewrite(rewriter, new_parents);
7759     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
7760     var body = this.body.rewrite(rewriter, new_parents);
7761     if (
7762       await_keyword === this.await_keyword &&
7763       using_keyword === this.using_keyword &&
7764       left_paren === this.left_paren &&
7765       expressions === this.expressions &&
7766       right_paren === this.right_paren &&
7767       body === this.body)
7768     {
7769       return rewriter(this, parents);
7770     }
7771     else
7772     {
7773       return rewriter(new UsingStatementBlockScoped(
7774         await_keyword,
7775         using_keyword,
7776         left_paren,
7777         expressions,
7778         right_paren,
7779         body), parents);
7780     }
7781   }
7782   static from_json(json, position, source)
7783   {
7784     let await_keyword = EditableSyntax.from_json(
7785       json.using_block_await_keyword, position, source);
7786     position += await_keyword.width;
7787     let using_keyword = EditableSyntax.from_json(
7788       json.using_block_using_keyword, position, source);
7789     position += using_keyword.width;
7790     let left_paren = EditableSyntax.from_json(
7791       json.using_block_left_paren, position, source);
7792     position += left_paren.width;
7793     let expressions = EditableSyntax.from_json(
7794       json.using_block_expressions, position, source);
7795     position += expressions.width;
7796     let right_paren = EditableSyntax.from_json(
7797       json.using_block_right_paren, position, source);
7798     position += right_paren.width;
7799     let body = EditableSyntax.from_json(
7800       json.using_block_body, position, source);
7801     position += body.width;
7802     return new UsingStatementBlockScoped(
7803         await_keyword,
7804         using_keyword,
7805         left_paren,
7806         expressions,
7807         right_paren,
7808         body);
7809   }
7810   get children_keys()
7811   {
7812     if (UsingStatementBlockScoped._children_keys == null)
7813       UsingStatementBlockScoped._children_keys = [
7814         'await_keyword',
7815         'using_keyword',
7816         'left_paren',
7817         'expressions',
7818         'right_paren',
7819         'body'];
7820     return UsingStatementBlockScoped._children_keys;
7821   }
7822 }
7823 class UsingStatementFunctionScoped extends EditableSyntax
7824 {
7825   constructor(
7826     await_keyword,
7827     using_keyword,
7828     expression,
7829     semicolon)
7830   {
7831     super('using_statement_function_scoped', {
7832       await_keyword: await_keyword,
7833       using_keyword: using_keyword,
7834       expression: expression,
7835       semicolon: semicolon });
7836   }
7837   get await_keyword() { return this.children.await_keyword; }
7838   get using_keyword() { return this.children.using_keyword; }
7839   get expression() { return this.children.expression; }
7840   get semicolon() { return this.children.semicolon; }
7841   with_await_keyword(await_keyword){
7842     return new UsingStatementFunctionScoped(
7843       await_keyword,
7844       this.using_keyword,
7845       this.expression,
7846       this.semicolon);
7847   }
7848   with_using_keyword(using_keyword){
7849     return new UsingStatementFunctionScoped(
7850       this.await_keyword,
7851       using_keyword,
7852       this.expression,
7853       this.semicolon);
7854   }
7855   with_expression(expression){
7856     return new UsingStatementFunctionScoped(
7857       this.await_keyword,
7858       this.using_keyword,
7859       expression,
7860       this.semicolon);
7861   }
7862   with_semicolon(semicolon){
7863     return new UsingStatementFunctionScoped(
7864       this.await_keyword,
7865       this.using_keyword,
7866       this.expression,
7867       semicolon);
7868   }
7869   rewrite(rewriter, parents)
7870   {
7871     if (parents == undefined)
7872       parents = [];
7873     let new_parents = parents.slice();
7874     new_parents.push(this);
7875     var await_keyword = this.await_keyword.rewrite(rewriter, new_parents);
7876     var using_keyword = this.using_keyword.rewrite(rewriter, new_parents);
7877     var expression = this.expression.rewrite(rewriter, new_parents);
7878     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
7879     if (
7880       await_keyword === this.await_keyword &&
7881       using_keyword === this.using_keyword &&
7882       expression === this.expression &&
7883       semicolon === this.semicolon)
7884     {
7885       return rewriter(this, parents);
7886     }
7887     else
7888     {
7889       return rewriter(new UsingStatementFunctionScoped(
7890         await_keyword,
7891         using_keyword,
7892         expression,
7893         semicolon), parents);
7894     }
7895   }
7896   static from_json(json, position, source)
7897   {
7898     let await_keyword = EditableSyntax.from_json(
7899       json.using_function_await_keyword, position, source);
7900     position += await_keyword.width;
7901     let using_keyword = EditableSyntax.from_json(
7902       json.using_function_using_keyword, position, source);
7903     position += using_keyword.width;
7904     let expression = EditableSyntax.from_json(
7905       json.using_function_expression, position, source);
7906     position += expression.width;
7907     let semicolon = EditableSyntax.from_json(
7908       json.using_function_semicolon, position, source);
7909     position += semicolon.width;
7910     return new UsingStatementFunctionScoped(
7911         await_keyword,
7912         using_keyword,
7913         expression,
7914         semicolon);
7915   }
7916   get children_keys()
7917   {
7918     if (UsingStatementFunctionScoped._children_keys == null)
7919       UsingStatementFunctionScoped._children_keys = [
7920         'await_keyword',
7921         'using_keyword',
7922         'expression',
7923         'semicolon'];
7924     return UsingStatementFunctionScoped._children_keys;
7925   }
7926 }
7927 class DeclareDirectiveStatement extends EditableSyntax
7928 {
7929   constructor(
7930     keyword,
7931     left_paren,
7932     expression,
7933     right_paren,
7934     semicolon)
7935   {
7936     super('declare_directive_statement', {
7937       keyword: keyword,
7938       left_paren: left_paren,
7939       expression: expression,
7940       right_paren: right_paren,
7941       semicolon: semicolon });
7942   }
7943   get keyword() { return this.children.keyword; }
7944   get left_paren() { return this.children.left_paren; }
7945   get expression() { return this.children.expression; }
7946   get right_paren() { return this.children.right_paren; }
7947   get semicolon() { return this.children.semicolon; }
7948   with_keyword(keyword){
7949     return new DeclareDirectiveStatement(
7950       keyword,
7951       this.left_paren,
7952       this.expression,
7953       this.right_paren,
7954       this.semicolon);
7955   }
7956   with_left_paren(left_paren){
7957     return new DeclareDirectiveStatement(
7958       this.keyword,
7959       left_paren,
7960       this.expression,
7961       this.right_paren,
7962       this.semicolon);
7963   }
7964   with_expression(expression){
7965     return new DeclareDirectiveStatement(
7966       this.keyword,
7967       this.left_paren,
7968       expression,
7969       this.right_paren,
7970       this.semicolon);
7971   }
7972   with_right_paren(right_paren){
7973     return new DeclareDirectiveStatement(
7974       this.keyword,
7975       this.left_paren,
7976       this.expression,
7977       right_paren,
7978       this.semicolon);
7979   }
7980   with_semicolon(semicolon){
7981     return new DeclareDirectiveStatement(
7982       this.keyword,
7983       this.left_paren,
7984       this.expression,
7985       this.right_paren,
7986       semicolon);
7987   }
7988   rewrite(rewriter, parents)
7989   {
7990     if (parents == undefined)
7991       parents = [];
7992     let new_parents = parents.slice();
7993     new_parents.push(this);
7994     var keyword = this.keyword.rewrite(rewriter, new_parents);
7995     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
7996     var expression = this.expression.rewrite(rewriter, new_parents);
7997     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
7998     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
7999     if (
8000       keyword === this.keyword &&
8001       left_paren === this.left_paren &&
8002       expression === this.expression &&
8003       right_paren === this.right_paren &&
8004       semicolon === this.semicolon)
8005     {
8006       return rewriter(this, parents);
8007     }
8008     else
8009     {
8010       return rewriter(new DeclareDirectiveStatement(
8011         keyword,
8012         left_paren,
8013         expression,
8014         right_paren,
8015         semicolon), parents);
8016     }
8017   }
8018   static from_json(json, position, source)
8019   {
8020     let keyword = EditableSyntax.from_json(
8021       json.declare_directive_keyword, position, source);
8022     position += keyword.width;
8023     let left_paren = EditableSyntax.from_json(
8024       json.declare_directive_left_paren, position, source);
8025     position += left_paren.width;
8026     let expression = EditableSyntax.from_json(
8027       json.declare_directive_expression, position, source);
8028     position += expression.width;
8029     let right_paren = EditableSyntax.from_json(
8030       json.declare_directive_right_paren, position, source);
8031     position += right_paren.width;
8032     let semicolon = EditableSyntax.from_json(
8033       json.declare_directive_semicolon, position, source);
8034     position += semicolon.width;
8035     return new DeclareDirectiveStatement(
8036         keyword,
8037         left_paren,
8038         expression,
8039         right_paren,
8040         semicolon);
8041   }
8042   get children_keys()
8043   {
8044     if (DeclareDirectiveStatement._children_keys == null)
8045       DeclareDirectiveStatement._children_keys = [
8046         'keyword',
8047         'left_paren',
8048         'expression',
8049         'right_paren',
8050         'semicolon'];
8051     return DeclareDirectiveStatement._children_keys;
8052   }
8053 }
8054 class DeclareBlockStatement extends EditableSyntax
8055 {
8056   constructor(
8057     keyword,
8058     left_paren,
8059     expression,
8060     right_paren,
8061     body)
8062   {
8063     super('declare_block_statement', {
8064       keyword: keyword,
8065       left_paren: left_paren,
8066       expression: expression,
8067       right_paren: right_paren,
8068       body: body });
8069   }
8070   get keyword() { return this.children.keyword; }
8071   get left_paren() { return this.children.left_paren; }
8072   get expression() { return this.children.expression; }
8073   get right_paren() { return this.children.right_paren; }
8074   get body() { return this.children.body; }
8075   with_keyword(keyword){
8076     return new DeclareBlockStatement(
8077       keyword,
8078       this.left_paren,
8079       this.expression,
8080       this.right_paren,
8081       this.body);
8082   }
8083   with_left_paren(left_paren){
8084     return new DeclareBlockStatement(
8085       this.keyword,
8086       left_paren,
8087       this.expression,
8088       this.right_paren,
8089       this.body);
8090   }
8091   with_expression(expression){
8092     return new DeclareBlockStatement(
8093       this.keyword,
8094       this.left_paren,
8095       expression,
8096       this.right_paren,
8097       this.body);
8098   }
8099   with_right_paren(right_paren){
8100     return new DeclareBlockStatement(
8101       this.keyword,
8102       this.left_paren,
8103       this.expression,
8104       right_paren,
8105       this.body);
8106   }
8107   with_body(body){
8108     return new DeclareBlockStatement(
8109       this.keyword,
8110       this.left_paren,
8111       this.expression,
8112       this.right_paren,
8113       body);
8114   }
8115   rewrite(rewriter, parents)
8116   {
8117     if (parents == undefined)
8118       parents = [];
8119     let new_parents = parents.slice();
8120     new_parents.push(this);
8121     var keyword = this.keyword.rewrite(rewriter, new_parents);
8122     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
8123     var expression = this.expression.rewrite(rewriter, new_parents);
8124     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
8125     var body = this.body.rewrite(rewriter, new_parents);
8126     if (
8127       keyword === this.keyword &&
8128       left_paren === this.left_paren &&
8129       expression === this.expression &&
8130       right_paren === this.right_paren &&
8131       body === this.body)
8132     {
8133       return rewriter(this, parents);
8134     }
8135     else
8136     {
8137       return rewriter(new DeclareBlockStatement(
8138         keyword,
8139         left_paren,
8140         expression,
8141         right_paren,
8142         body), parents);
8143     }
8144   }
8145   static from_json(json, position, source)
8146   {
8147     let keyword = EditableSyntax.from_json(
8148       json.declare_block_keyword, position, source);
8149     position += keyword.width;
8150     let left_paren = EditableSyntax.from_json(
8151       json.declare_block_left_paren, position, source);
8152     position += left_paren.width;
8153     let expression = EditableSyntax.from_json(
8154       json.declare_block_expression, position, source);
8155     position += expression.width;
8156     let right_paren = EditableSyntax.from_json(
8157       json.declare_block_right_paren, position, source);
8158     position += right_paren.width;
8159     let body = EditableSyntax.from_json(
8160       json.declare_block_body, position, source);
8161     position += body.width;
8162     return new DeclareBlockStatement(
8163         keyword,
8164         left_paren,
8165         expression,
8166         right_paren,
8167         body);
8168   }
8169   get children_keys()
8170   {
8171     if (DeclareBlockStatement._children_keys == null)
8172       DeclareBlockStatement._children_keys = [
8173         'keyword',
8174         'left_paren',
8175         'expression',
8176         'right_paren',
8177         'body'];
8178     return DeclareBlockStatement._children_keys;
8179   }
8180 }
8181 class WhileStatement extends EditableSyntax
8182 {
8183   constructor(
8184     keyword,
8185     left_paren,
8186     condition,
8187     right_paren,
8188     body)
8189   {
8190     super('while_statement', {
8191       keyword: keyword,
8192       left_paren: left_paren,
8193       condition: condition,
8194       right_paren: right_paren,
8195       body: body });
8196   }
8197   get keyword() { return this.children.keyword; }
8198   get left_paren() { return this.children.left_paren; }
8199   get condition() { return this.children.condition; }
8200   get right_paren() { return this.children.right_paren; }
8201   get body() { return this.children.body; }
8202   with_keyword(keyword){
8203     return new WhileStatement(
8204       keyword,
8205       this.left_paren,
8206       this.condition,
8207       this.right_paren,
8208       this.body);
8209   }
8210   with_left_paren(left_paren){
8211     return new WhileStatement(
8212       this.keyword,
8213       left_paren,
8214       this.condition,
8215       this.right_paren,
8216       this.body);
8217   }
8218   with_condition(condition){
8219     return new WhileStatement(
8220       this.keyword,
8221       this.left_paren,
8222       condition,
8223       this.right_paren,
8224       this.body);
8225   }
8226   with_right_paren(right_paren){
8227     return new WhileStatement(
8228       this.keyword,
8229       this.left_paren,
8230       this.condition,
8231       right_paren,
8232       this.body);
8233   }
8234   with_body(body){
8235     return new WhileStatement(
8236       this.keyword,
8237       this.left_paren,
8238       this.condition,
8239       this.right_paren,
8240       body);
8241   }
8242   rewrite(rewriter, parents)
8243   {
8244     if (parents == undefined)
8245       parents = [];
8246     let new_parents = parents.slice();
8247     new_parents.push(this);
8248     var keyword = this.keyword.rewrite(rewriter, new_parents);
8249     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
8250     var condition = this.condition.rewrite(rewriter, new_parents);
8251     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
8252     var body = this.body.rewrite(rewriter, new_parents);
8253     if (
8254       keyword === this.keyword &&
8255       left_paren === this.left_paren &&
8256       condition === this.condition &&
8257       right_paren === this.right_paren &&
8258       body === this.body)
8259     {
8260       return rewriter(this, parents);
8261     }
8262     else
8263     {
8264       return rewriter(new WhileStatement(
8265         keyword,
8266         left_paren,
8267         condition,
8268         right_paren,
8269         body), parents);
8270     }
8271   }
8272   static from_json(json, position, source)
8273   {
8274     let keyword = EditableSyntax.from_json(
8275       json.while_keyword, position, source);
8276     position += keyword.width;
8277     let left_paren = EditableSyntax.from_json(
8278       json.while_left_paren, position, source);
8279     position += left_paren.width;
8280     let condition = EditableSyntax.from_json(
8281       json.while_condition, position, source);
8282     position += condition.width;
8283     let right_paren = EditableSyntax.from_json(
8284       json.while_right_paren, position, source);
8285     position += right_paren.width;
8286     let body = EditableSyntax.from_json(
8287       json.while_body, position, source);
8288     position += body.width;
8289     return new WhileStatement(
8290         keyword,
8291         left_paren,
8292         condition,
8293         right_paren,
8294         body);
8295   }
8296   get children_keys()
8297   {
8298     if (WhileStatement._children_keys == null)
8299       WhileStatement._children_keys = [
8300         'keyword',
8301         'left_paren',
8302         'condition',
8303         'right_paren',
8304         'body'];
8305     return WhileStatement._children_keys;
8306   }
8307 }
8308 class IfStatement extends EditableSyntax
8309 {
8310   constructor(
8311     keyword,
8312     left_paren,
8313     condition,
8314     right_paren,
8315     statement,
8316     elseif_clauses,
8317     else_clause)
8318   {
8319     super('if_statement', {
8320       keyword: keyword,
8321       left_paren: left_paren,
8322       condition: condition,
8323       right_paren: right_paren,
8324       statement: statement,
8325       elseif_clauses: elseif_clauses,
8326       else_clause: else_clause });
8327   }
8328   get keyword() { return this.children.keyword; }
8329   get left_paren() { return this.children.left_paren; }
8330   get condition() { return this.children.condition; }
8331   get right_paren() { return this.children.right_paren; }
8332   get statement() { return this.children.statement; }
8333   get elseif_clauses() { return this.children.elseif_clauses; }
8334   get else_clause() { return this.children.else_clause; }
8335   with_keyword(keyword){
8336     return new IfStatement(
8337       keyword,
8338       this.left_paren,
8339       this.condition,
8340       this.right_paren,
8341       this.statement,
8342       this.elseif_clauses,
8343       this.else_clause);
8344   }
8345   with_left_paren(left_paren){
8346     return new IfStatement(
8347       this.keyword,
8348       left_paren,
8349       this.condition,
8350       this.right_paren,
8351       this.statement,
8352       this.elseif_clauses,
8353       this.else_clause);
8354   }
8355   with_condition(condition){
8356     return new IfStatement(
8357       this.keyword,
8358       this.left_paren,
8359       condition,
8360       this.right_paren,
8361       this.statement,
8362       this.elseif_clauses,
8363       this.else_clause);
8364   }
8365   with_right_paren(right_paren){
8366     return new IfStatement(
8367       this.keyword,
8368       this.left_paren,
8369       this.condition,
8370       right_paren,
8371       this.statement,
8372       this.elseif_clauses,
8373       this.else_clause);
8374   }
8375   with_statement(statement){
8376     return new IfStatement(
8377       this.keyword,
8378       this.left_paren,
8379       this.condition,
8380       this.right_paren,
8381       statement,
8382       this.elseif_clauses,
8383       this.else_clause);
8384   }
8385   with_elseif_clauses(elseif_clauses){
8386     return new IfStatement(
8387       this.keyword,
8388       this.left_paren,
8389       this.condition,
8390       this.right_paren,
8391       this.statement,
8392       elseif_clauses,
8393       this.else_clause);
8394   }
8395   with_else_clause(else_clause){
8396     return new IfStatement(
8397       this.keyword,
8398       this.left_paren,
8399       this.condition,
8400       this.right_paren,
8401       this.statement,
8402       this.elseif_clauses,
8403       else_clause);
8404   }
8405   rewrite(rewriter, parents)
8406   {
8407     if (parents == undefined)
8408       parents = [];
8409     let new_parents = parents.slice();
8410     new_parents.push(this);
8411     var keyword = this.keyword.rewrite(rewriter, new_parents);
8412     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
8413     var condition = this.condition.rewrite(rewriter, new_parents);
8414     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
8415     var statement = this.statement.rewrite(rewriter, new_parents);
8416     var elseif_clauses = this.elseif_clauses.rewrite(rewriter, new_parents);
8417     var else_clause = this.else_clause.rewrite(rewriter, new_parents);
8418     if (
8419       keyword === this.keyword &&
8420       left_paren === this.left_paren &&
8421       condition === this.condition &&
8422       right_paren === this.right_paren &&
8423       statement === this.statement &&
8424       elseif_clauses === this.elseif_clauses &&
8425       else_clause === this.else_clause)
8426     {
8427       return rewriter(this, parents);
8428     }
8429     else
8430     {
8431       return rewriter(new IfStatement(
8432         keyword,
8433         left_paren,
8434         condition,
8435         right_paren,
8436         statement,
8437         elseif_clauses,
8438         else_clause), parents);
8439     }
8440   }
8441   static from_json(json, position, source)
8442   {
8443     let keyword = EditableSyntax.from_json(
8444       json.if_keyword, position, source);
8445     position += keyword.width;
8446     let left_paren = EditableSyntax.from_json(
8447       json.if_left_paren, position, source);
8448     position += left_paren.width;
8449     let condition = EditableSyntax.from_json(
8450       json.if_condition, position, source);
8451     position += condition.width;
8452     let right_paren = EditableSyntax.from_json(
8453       json.if_right_paren, position, source);
8454     position += right_paren.width;
8455     let statement = EditableSyntax.from_json(
8456       json.if_statement, position, source);
8457     position += statement.width;
8458     let elseif_clauses = EditableSyntax.from_json(
8459       json.if_elseif_clauses, position, source);
8460     position += elseif_clauses.width;
8461     let else_clause = EditableSyntax.from_json(
8462       json.if_else_clause, position, source);
8463     position += else_clause.width;
8464     return new IfStatement(
8465         keyword,
8466         left_paren,
8467         condition,
8468         right_paren,
8469         statement,
8470         elseif_clauses,
8471         else_clause);
8472   }
8473   get children_keys()
8474   {
8475     if (IfStatement._children_keys == null)
8476       IfStatement._children_keys = [
8477         'keyword',
8478         'left_paren',
8479         'condition',
8480         'right_paren',
8481         'statement',
8482         'elseif_clauses',
8483         'else_clause'];
8484     return IfStatement._children_keys;
8485   }
8486 }
8487 class ElseifClause extends EditableSyntax
8488 {
8489   constructor(
8490     keyword,
8491     left_paren,
8492     condition,
8493     right_paren,
8494     statement)
8495   {
8496     super('elseif_clause', {
8497       keyword: keyword,
8498       left_paren: left_paren,
8499       condition: condition,
8500       right_paren: right_paren,
8501       statement: statement });
8502   }
8503   get keyword() { return this.children.keyword; }
8504   get left_paren() { return this.children.left_paren; }
8505   get condition() { return this.children.condition; }
8506   get right_paren() { return this.children.right_paren; }
8507   get statement() { return this.children.statement; }
8508   with_keyword(keyword){
8509     return new ElseifClause(
8510       keyword,
8511       this.left_paren,
8512       this.condition,
8513       this.right_paren,
8514       this.statement);
8515   }
8516   with_left_paren(left_paren){
8517     return new ElseifClause(
8518       this.keyword,
8519       left_paren,
8520       this.condition,
8521       this.right_paren,
8522       this.statement);
8523   }
8524   with_condition(condition){
8525     return new ElseifClause(
8526       this.keyword,
8527       this.left_paren,
8528       condition,
8529       this.right_paren,
8530       this.statement);
8531   }
8532   with_right_paren(right_paren){
8533     return new ElseifClause(
8534       this.keyword,
8535       this.left_paren,
8536       this.condition,
8537       right_paren,
8538       this.statement);
8539   }
8540   with_statement(statement){
8541     return new ElseifClause(
8542       this.keyword,
8543       this.left_paren,
8544       this.condition,
8545       this.right_paren,
8546       statement);
8547   }
8548   rewrite(rewriter, parents)
8549   {
8550     if (parents == undefined)
8551       parents = [];
8552     let new_parents = parents.slice();
8553     new_parents.push(this);
8554     var keyword = this.keyword.rewrite(rewriter, new_parents);
8555     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
8556     var condition = this.condition.rewrite(rewriter, new_parents);
8557     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
8558     var statement = this.statement.rewrite(rewriter, new_parents);
8559     if (
8560       keyword === this.keyword &&
8561       left_paren === this.left_paren &&
8562       condition === this.condition &&
8563       right_paren === this.right_paren &&
8564       statement === this.statement)
8565     {
8566       return rewriter(this, parents);
8567     }
8568     else
8569     {
8570       return rewriter(new ElseifClause(
8571         keyword,
8572         left_paren,
8573         condition,
8574         right_paren,
8575         statement), parents);
8576     }
8577   }
8578   static from_json(json, position, source)
8579   {
8580     let keyword = EditableSyntax.from_json(
8581       json.elseif_keyword, position, source);
8582     position += keyword.width;
8583     let left_paren = EditableSyntax.from_json(
8584       json.elseif_left_paren, position, source);
8585     position += left_paren.width;
8586     let condition = EditableSyntax.from_json(
8587       json.elseif_condition, position, source);
8588     position += condition.width;
8589     let right_paren = EditableSyntax.from_json(
8590       json.elseif_right_paren, position, source);
8591     position += right_paren.width;
8592     let statement = EditableSyntax.from_json(
8593       json.elseif_statement, position, source);
8594     position += statement.width;
8595     return new ElseifClause(
8596         keyword,
8597         left_paren,
8598         condition,
8599         right_paren,
8600         statement);
8601   }
8602   get children_keys()
8603   {
8604     if (ElseifClause._children_keys == null)
8605       ElseifClause._children_keys = [
8606         'keyword',
8607         'left_paren',
8608         'condition',
8609         'right_paren',
8610         'statement'];
8611     return ElseifClause._children_keys;
8612   }
8613 }
8614 class ElseClause extends EditableSyntax
8615 {
8616   constructor(
8617     keyword,
8618     statement)
8619   {
8620     super('else_clause', {
8621       keyword: keyword,
8622       statement: statement });
8623   }
8624   get keyword() { return this.children.keyword; }
8625   get statement() { return this.children.statement; }
8626   with_keyword(keyword){
8627     return new ElseClause(
8628       keyword,
8629       this.statement);
8630   }
8631   with_statement(statement){
8632     return new ElseClause(
8633       this.keyword,
8634       statement);
8635   }
8636   rewrite(rewriter, parents)
8637   {
8638     if (parents == undefined)
8639       parents = [];
8640     let new_parents = parents.slice();
8641     new_parents.push(this);
8642     var keyword = this.keyword.rewrite(rewriter, new_parents);
8643     var statement = this.statement.rewrite(rewriter, new_parents);
8644     if (
8645       keyword === this.keyword &&
8646       statement === this.statement)
8647     {
8648       return rewriter(this, parents);
8649     }
8650     else
8651     {
8652       return rewriter(new ElseClause(
8653         keyword,
8654         statement), parents);
8655     }
8656   }
8657   static from_json(json, position, source)
8658   {
8659     let keyword = EditableSyntax.from_json(
8660       json.else_keyword, position, source);
8661     position += keyword.width;
8662     let statement = EditableSyntax.from_json(
8663       json.else_statement, position, source);
8664     position += statement.width;
8665     return new ElseClause(
8666         keyword,
8667         statement);
8668   }
8669   get children_keys()
8670   {
8671     if (ElseClause._children_keys == null)
8672       ElseClause._children_keys = [
8673         'keyword',
8674         'statement'];
8675     return ElseClause._children_keys;
8676   }
8677 }
8678 class IfEndIfStatement extends EditableSyntax
8679 {
8680   constructor(
8681     keyword,
8682     left_paren,
8683     condition,
8684     right_paren,
8685     colon,
8686     statement,
8687     elseif_colon_clauses,
8688     else_colon_clause,
8689     endif_keyword,
8690     semicolon)
8691   {
8692     super('if_endif_statement', {
8693       keyword: keyword,
8694       left_paren: left_paren,
8695       condition: condition,
8696       right_paren: right_paren,
8697       colon: colon,
8698       statement: statement,
8699       elseif_colon_clauses: elseif_colon_clauses,
8700       else_colon_clause: else_colon_clause,
8701       endif_keyword: endif_keyword,
8702       semicolon: semicolon });
8703   }
8704   get keyword() { return this.children.keyword; }
8705   get left_paren() { return this.children.left_paren; }
8706   get condition() { return this.children.condition; }
8707   get right_paren() { return this.children.right_paren; }
8708   get colon() { return this.children.colon; }
8709   get statement() { return this.children.statement; }
8710   get elseif_colon_clauses() { return this.children.elseif_colon_clauses; }
8711   get else_colon_clause() { return this.children.else_colon_clause; }
8712   get endif_keyword() { return this.children.endif_keyword; }
8713   get semicolon() { return this.children.semicolon; }
8714   with_keyword(keyword){
8715     return new IfEndIfStatement(
8716       keyword,
8717       this.left_paren,
8718       this.condition,
8719       this.right_paren,
8720       this.colon,
8721       this.statement,
8722       this.elseif_colon_clauses,
8723       this.else_colon_clause,
8724       this.endif_keyword,
8725       this.semicolon);
8726   }
8727   with_left_paren(left_paren){
8728     return new IfEndIfStatement(
8729       this.keyword,
8730       left_paren,
8731       this.condition,
8732       this.right_paren,
8733       this.colon,
8734       this.statement,
8735       this.elseif_colon_clauses,
8736       this.else_colon_clause,
8737       this.endif_keyword,
8738       this.semicolon);
8739   }
8740   with_condition(condition){
8741     return new IfEndIfStatement(
8742       this.keyword,
8743       this.left_paren,
8744       condition,
8745       this.right_paren,
8746       this.colon,
8747       this.statement,
8748       this.elseif_colon_clauses,
8749       this.else_colon_clause,
8750       this.endif_keyword,
8751       this.semicolon);
8752   }
8753   with_right_paren(right_paren){
8754     return new IfEndIfStatement(
8755       this.keyword,
8756       this.left_paren,
8757       this.condition,
8758       right_paren,
8759       this.colon,
8760       this.statement,
8761       this.elseif_colon_clauses,
8762       this.else_colon_clause,
8763       this.endif_keyword,
8764       this.semicolon);
8765   }
8766   with_colon(colon){
8767     return new IfEndIfStatement(
8768       this.keyword,
8769       this.left_paren,
8770       this.condition,
8771       this.right_paren,
8772       colon,
8773       this.statement,
8774       this.elseif_colon_clauses,
8775       this.else_colon_clause,
8776       this.endif_keyword,
8777       this.semicolon);
8778   }
8779   with_statement(statement){
8780     return new IfEndIfStatement(
8781       this.keyword,
8782       this.left_paren,
8783       this.condition,
8784       this.right_paren,
8785       this.colon,
8786       statement,
8787       this.elseif_colon_clauses,
8788       this.else_colon_clause,
8789       this.endif_keyword,
8790       this.semicolon);
8791   }
8792   with_elseif_colon_clauses(elseif_colon_clauses){
8793     return new IfEndIfStatement(
8794       this.keyword,
8795       this.left_paren,
8796       this.condition,
8797       this.right_paren,
8798       this.colon,
8799       this.statement,
8800       elseif_colon_clauses,
8801       this.else_colon_clause,
8802       this.endif_keyword,
8803       this.semicolon);
8804   }
8805   with_else_colon_clause(else_colon_clause){
8806     return new IfEndIfStatement(
8807       this.keyword,
8808       this.left_paren,
8809       this.condition,
8810       this.right_paren,
8811       this.colon,
8812       this.statement,
8813       this.elseif_colon_clauses,
8814       else_colon_clause,
8815       this.endif_keyword,
8816       this.semicolon);
8817   }
8818   with_endif_keyword(endif_keyword){
8819     return new IfEndIfStatement(
8820       this.keyword,
8821       this.left_paren,
8822       this.condition,
8823       this.right_paren,
8824       this.colon,
8825       this.statement,
8826       this.elseif_colon_clauses,
8827       this.else_colon_clause,
8828       endif_keyword,
8829       this.semicolon);
8830   }
8831   with_semicolon(semicolon){
8832     return new IfEndIfStatement(
8833       this.keyword,
8834       this.left_paren,
8835       this.condition,
8836       this.right_paren,
8837       this.colon,
8838       this.statement,
8839       this.elseif_colon_clauses,
8840       this.else_colon_clause,
8841       this.endif_keyword,
8842       semicolon);
8843   }
8844   rewrite(rewriter, parents)
8845   {
8846     if (parents == undefined)
8847       parents = [];
8848     let new_parents = parents.slice();
8849     new_parents.push(this);
8850     var keyword = this.keyword.rewrite(rewriter, new_parents);
8851     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
8852     var condition = this.condition.rewrite(rewriter, new_parents);
8853     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
8854     var colon = this.colon.rewrite(rewriter, new_parents);
8855     var statement = this.statement.rewrite(rewriter, new_parents);
8856     var elseif_colon_clauses = this.elseif_colon_clauses.rewrite(rewriter, new_parents);
8857     var else_colon_clause = this.else_colon_clause.rewrite(rewriter, new_parents);
8858     var endif_keyword = this.endif_keyword.rewrite(rewriter, new_parents);
8859     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
8860     if (
8861       keyword === this.keyword &&
8862       left_paren === this.left_paren &&
8863       condition === this.condition &&
8864       right_paren === this.right_paren &&
8865       colon === this.colon &&
8866       statement === this.statement &&
8867       elseif_colon_clauses === this.elseif_colon_clauses &&
8868       else_colon_clause === this.else_colon_clause &&
8869       endif_keyword === this.endif_keyword &&
8870       semicolon === this.semicolon)
8871     {
8872       return rewriter(this, parents);
8873     }
8874     else
8875     {
8876       return rewriter(new IfEndIfStatement(
8877         keyword,
8878         left_paren,
8879         condition,
8880         right_paren,
8881         colon,
8882         statement,
8883         elseif_colon_clauses,
8884         else_colon_clause,
8885         endif_keyword,
8886         semicolon), parents);
8887     }
8888   }
8889   static from_json(json, position, source)
8890   {
8891     let keyword = EditableSyntax.from_json(
8892       json.if_endif_keyword, position, source);
8893     position += keyword.width;
8894     let left_paren = EditableSyntax.from_json(
8895       json.if_endif_left_paren, position, source);
8896     position += left_paren.width;
8897     let condition = EditableSyntax.from_json(
8898       json.if_endif_condition, position, source);
8899     position += condition.width;
8900     let right_paren = EditableSyntax.from_json(
8901       json.if_endif_right_paren, position, source);
8902     position += right_paren.width;
8903     let colon = EditableSyntax.from_json(
8904       json.if_endif_colon, position, source);
8905     position += colon.width;
8906     let statement = EditableSyntax.from_json(
8907       json.if_endif_statement, position, source);
8908     position += statement.width;
8909     let elseif_colon_clauses = EditableSyntax.from_json(
8910       json.if_endif_elseif_colon_clauses, position, source);
8911     position += elseif_colon_clauses.width;
8912     let else_colon_clause = EditableSyntax.from_json(
8913       json.if_endif_else_colon_clause, position, source);
8914     position += else_colon_clause.width;
8915     let endif_keyword = EditableSyntax.from_json(
8916       json.if_endif_endif_keyword, position, source);
8917     position += endif_keyword.width;
8918     let semicolon = EditableSyntax.from_json(
8919       json.if_endif_semicolon, position, source);
8920     position += semicolon.width;
8921     return new IfEndIfStatement(
8922         keyword,
8923         left_paren,
8924         condition,
8925         right_paren,
8926         colon,
8927         statement,
8928         elseif_colon_clauses,
8929         else_colon_clause,
8930         endif_keyword,
8931         semicolon);
8932   }
8933   get children_keys()
8934   {
8935     if (IfEndIfStatement._children_keys == null)
8936       IfEndIfStatement._children_keys = [
8937         'keyword',
8938         'left_paren',
8939         'condition',
8940         'right_paren',
8941         'colon',
8942         'statement',
8943         'elseif_colon_clauses',
8944         'else_colon_clause',
8945         'endif_keyword',
8946         'semicolon'];
8947     return IfEndIfStatement._children_keys;
8948   }
8949 }
8950 class ElseifColonClause extends EditableSyntax
8951 {
8952   constructor(
8953     keyword,
8954     left_paren,
8955     condition,
8956     right_paren,
8957     colon,
8958     statement)
8959   {
8960     super('elseif_colon_clause', {
8961       keyword: keyword,
8962       left_paren: left_paren,
8963       condition: condition,
8964       right_paren: right_paren,
8965       colon: colon,
8966       statement: statement });
8967   }
8968   get keyword() { return this.children.keyword; }
8969   get left_paren() { return this.children.left_paren; }
8970   get condition() { return this.children.condition; }
8971   get right_paren() { return this.children.right_paren; }
8972   get colon() { return this.children.colon; }
8973   get statement() { return this.children.statement; }
8974   with_keyword(keyword){
8975     return new ElseifColonClause(
8976       keyword,
8977       this.left_paren,
8978       this.condition,
8979       this.right_paren,
8980       this.colon,
8981       this.statement);
8982   }
8983   with_left_paren(left_paren){
8984     return new ElseifColonClause(
8985       this.keyword,
8986       left_paren,
8987       this.condition,
8988       this.right_paren,
8989       this.colon,
8990       this.statement);
8991   }
8992   with_condition(condition){
8993     return new ElseifColonClause(
8994       this.keyword,
8995       this.left_paren,
8996       condition,
8997       this.right_paren,
8998       this.colon,
8999       this.statement);
9000   }
9001   with_right_paren(right_paren){
9002     return new ElseifColonClause(
9003       this.keyword,
9004       this.left_paren,
9005       this.condition,
9006       right_paren,
9007       this.colon,
9008       this.statement);
9009   }
9010   with_colon(colon){
9011     return new ElseifColonClause(
9012       this.keyword,
9013       this.left_paren,
9014       this.condition,
9015       this.right_paren,
9016       colon,
9017       this.statement);
9018   }
9019   with_statement(statement){
9020     return new ElseifColonClause(
9021       this.keyword,
9022       this.left_paren,
9023       this.condition,
9024       this.right_paren,
9025       this.colon,
9026       statement);
9027   }
9028   rewrite(rewriter, parents)
9029   {
9030     if (parents == undefined)
9031       parents = [];
9032     let new_parents = parents.slice();
9033     new_parents.push(this);
9034     var keyword = this.keyword.rewrite(rewriter, new_parents);
9035     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
9036     var condition = this.condition.rewrite(rewriter, new_parents);
9037     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
9038     var colon = this.colon.rewrite(rewriter, new_parents);
9039     var statement = this.statement.rewrite(rewriter, new_parents);
9040     if (
9041       keyword === this.keyword &&
9042       left_paren === this.left_paren &&
9043       condition === this.condition &&
9044       right_paren === this.right_paren &&
9045       colon === this.colon &&
9046       statement === this.statement)
9047     {
9048       return rewriter(this, parents);
9049     }
9050     else
9051     {
9052       return rewriter(new ElseifColonClause(
9053         keyword,
9054         left_paren,
9055         condition,
9056         right_paren,
9057         colon,
9058         statement), parents);
9059     }
9060   }
9061   static from_json(json, position, source)
9062   {
9063     let keyword = EditableSyntax.from_json(
9064       json.elseif_colon_keyword, position, source);
9065     position += keyword.width;
9066     let left_paren = EditableSyntax.from_json(
9067       json.elseif_colon_left_paren, position, source);
9068     position += left_paren.width;
9069     let condition = EditableSyntax.from_json(
9070       json.elseif_colon_condition, position, source);
9071     position += condition.width;
9072     let right_paren = EditableSyntax.from_json(
9073       json.elseif_colon_right_paren, position, source);
9074     position += right_paren.width;
9075     let colon = EditableSyntax.from_json(
9076       json.elseif_colon_colon, position, source);
9077     position += colon.width;
9078     let statement = EditableSyntax.from_json(
9079       json.elseif_colon_statement, position, source);
9080     position += statement.width;
9081     return new ElseifColonClause(
9082         keyword,
9083         left_paren,
9084         condition,
9085         right_paren,
9086         colon,
9087         statement);
9088   }
9089   get children_keys()
9090   {
9091     if (ElseifColonClause._children_keys == null)
9092       ElseifColonClause._children_keys = [
9093         'keyword',
9094         'left_paren',
9095         'condition',
9096         'right_paren',
9097         'colon',
9098         'statement'];
9099     return ElseifColonClause._children_keys;
9100   }
9101 }
9102 class ElseColonClause extends EditableSyntax
9103 {
9104   constructor(
9105     keyword,
9106     colon,
9107     statement)
9108   {
9109     super('else_colon_clause', {
9110       keyword: keyword,
9111       colon: colon,
9112       statement: statement });
9113   }
9114   get keyword() { return this.children.keyword; }
9115   get colon() { return this.children.colon; }
9116   get statement() { return this.children.statement; }
9117   with_keyword(keyword){
9118     return new ElseColonClause(
9119       keyword,
9120       this.colon,
9121       this.statement);
9122   }
9123   with_colon(colon){
9124     return new ElseColonClause(
9125       this.keyword,
9126       colon,
9127       this.statement);
9128   }
9129   with_statement(statement){
9130     return new ElseColonClause(
9131       this.keyword,
9132       this.colon,
9133       statement);
9134   }
9135   rewrite(rewriter, parents)
9136   {
9137     if (parents == undefined)
9138       parents = [];
9139     let new_parents = parents.slice();
9140     new_parents.push(this);
9141     var keyword = this.keyword.rewrite(rewriter, new_parents);
9142     var colon = this.colon.rewrite(rewriter, new_parents);
9143     var statement = this.statement.rewrite(rewriter, new_parents);
9144     if (
9145       keyword === this.keyword &&
9146       colon === this.colon &&
9147       statement === this.statement)
9148     {
9149       return rewriter(this, parents);
9150     }
9151     else
9152     {
9153       return rewriter(new ElseColonClause(
9154         keyword,
9155         colon,
9156         statement), parents);
9157     }
9158   }
9159   static from_json(json, position, source)
9160   {
9161     let keyword = EditableSyntax.from_json(
9162       json.else_colon_keyword, position, source);
9163     position += keyword.width;
9164     let colon = EditableSyntax.from_json(
9165       json.else_colon_colon, position, source);
9166     position += colon.width;
9167     let statement = EditableSyntax.from_json(
9168       json.else_colon_statement, position, source);
9169     position += statement.width;
9170     return new ElseColonClause(
9171         keyword,
9172         colon,
9173         statement);
9174   }
9175   get children_keys()
9176   {
9177     if (ElseColonClause._children_keys == null)
9178       ElseColonClause._children_keys = [
9179         'keyword',
9180         'colon',
9181         'statement'];
9182     return ElseColonClause._children_keys;
9183   }
9184 }
9185 class TryStatement extends EditableSyntax
9186 {
9187   constructor(
9188     keyword,
9189     compound_statement,
9190     catch_clauses,
9191     finally_clause)
9192   {
9193     super('try_statement', {
9194       keyword: keyword,
9195       compound_statement: compound_statement,
9196       catch_clauses: catch_clauses,
9197       finally_clause: finally_clause });
9198   }
9199   get keyword() { return this.children.keyword; }
9200   get compound_statement() { return this.children.compound_statement; }
9201   get catch_clauses() { return this.children.catch_clauses; }
9202   get finally_clause() { return this.children.finally_clause; }
9203   with_keyword(keyword){
9204     return new TryStatement(
9205       keyword,
9206       this.compound_statement,
9207       this.catch_clauses,
9208       this.finally_clause);
9209   }
9210   with_compound_statement(compound_statement){
9211     return new TryStatement(
9212       this.keyword,
9213       compound_statement,
9214       this.catch_clauses,
9215       this.finally_clause);
9216   }
9217   with_catch_clauses(catch_clauses){
9218     return new TryStatement(
9219       this.keyword,
9220       this.compound_statement,
9221       catch_clauses,
9222       this.finally_clause);
9223   }
9224   with_finally_clause(finally_clause){
9225     return new TryStatement(
9226       this.keyword,
9227       this.compound_statement,
9228       this.catch_clauses,
9229       finally_clause);
9230   }
9231   rewrite(rewriter, parents)
9232   {
9233     if (parents == undefined)
9234       parents = [];
9235     let new_parents = parents.slice();
9236     new_parents.push(this);
9237     var keyword = this.keyword.rewrite(rewriter, new_parents);
9238     var compound_statement = this.compound_statement.rewrite(rewriter, new_parents);
9239     var catch_clauses = this.catch_clauses.rewrite(rewriter, new_parents);
9240     var finally_clause = this.finally_clause.rewrite(rewriter, new_parents);
9241     if (
9242       keyword === this.keyword &&
9243       compound_statement === this.compound_statement &&
9244       catch_clauses === this.catch_clauses &&
9245       finally_clause === this.finally_clause)
9246     {
9247       return rewriter(this, parents);
9248     }
9249     else
9250     {
9251       return rewriter(new TryStatement(
9252         keyword,
9253         compound_statement,
9254         catch_clauses,
9255         finally_clause), parents);
9256     }
9257   }
9258   static from_json(json, position, source)
9259   {
9260     let keyword = EditableSyntax.from_json(
9261       json.try_keyword, position, source);
9262     position += keyword.width;
9263     let compound_statement = EditableSyntax.from_json(
9264       json.try_compound_statement, position, source);
9265     position += compound_statement.width;
9266     let catch_clauses = EditableSyntax.from_json(
9267       json.try_catch_clauses, position, source);
9268     position += catch_clauses.width;
9269     let finally_clause = EditableSyntax.from_json(
9270       json.try_finally_clause, position, source);
9271     position += finally_clause.width;
9272     return new TryStatement(
9273         keyword,
9274         compound_statement,
9275         catch_clauses,
9276         finally_clause);
9277   }
9278   get children_keys()
9279   {
9280     if (TryStatement._children_keys == null)
9281       TryStatement._children_keys = [
9282         'keyword',
9283         'compound_statement',
9284         'catch_clauses',
9285         'finally_clause'];
9286     return TryStatement._children_keys;
9287   }
9288 }
9289 class CatchClause extends EditableSyntax
9290 {
9291   constructor(
9292     keyword,
9293     left_paren,
9294     type,
9295     variable,
9296     right_paren,
9297     body)
9298   {
9299     super('catch_clause', {
9300       keyword: keyword,
9301       left_paren: left_paren,
9302       type: type,
9303       variable: variable,
9304       right_paren: right_paren,
9305       body: body });
9306   }
9307   get keyword() { return this.children.keyword; }
9308   get left_paren() { return this.children.left_paren; }
9309   get type() { return this.children.type; }
9310   get variable() { return this.children.variable; }
9311   get right_paren() { return this.children.right_paren; }
9312   get body() { return this.children.body; }
9313   with_keyword(keyword){
9314     return new CatchClause(
9315       keyword,
9316       this.left_paren,
9317       this.type,
9318       this.variable,
9319       this.right_paren,
9320       this.body);
9321   }
9322   with_left_paren(left_paren){
9323     return new CatchClause(
9324       this.keyword,
9325       left_paren,
9326       this.type,
9327       this.variable,
9328       this.right_paren,
9329       this.body);
9330   }
9331   with_type(type){
9332     return new CatchClause(
9333       this.keyword,
9334       this.left_paren,
9335       type,
9336       this.variable,
9337       this.right_paren,
9338       this.body);
9339   }
9340   with_variable(variable){
9341     return new CatchClause(
9342       this.keyword,
9343       this.left_paren,
9344       this.type,
9345       variable,
9346       this.right_paren,
9347       this.body);
9348   }
9349   with_right_paren(right_paren){
9350     return new CatchClause(
9351       this.keyword,
9352       this.left_paren,
9353       this.type,
9354       this.variable,
9355       right_paren,
9356       this.body);
9357   }
9358   with_body(body){
9359     return new CatchClause(
9360       this.keyword,
9361       this.left_paren,
9362       this.type,
9363       this.variable,
9364       this.right_paren,
9365       body);
9366   }
9367   rewrite(rewriter, parents)
9368   {
9369     if (parents == undefined)
9370       parents = [];
9371     let new_parents = parents.slice();
9372     new_parents.push(this);
9373     var keyword = this.keyword.rewrite(rewriter, new_parents);
9374     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
9375     var type = this.type.rewrite(rewriter, new_parents);
9376     var variable = this.variable.rewrite(rewriter, new_parents);
9377     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
9378     var body = this.body.rewrite(rewriter, new_parents);
9379     if (
9380       keyword === this.keyword &&
9381       left_paren === this.left_paren &&
9382       type === this.type &&
9383       variable === this.variable &&
9384       right_paren === this.right_paren &&
9385       body === this.body)
9386     {
9387       return rewriter(this, parents);
9388     }
9389     else
9390     {
9391       return rewriter(new CatchClause(
9392         keyword,
9393         left_paren,
9394         type,
9395         variable,
9396         right_paren,
9397         body), parents);
9398     }
9399   }
9400   static from_json(json, position, source)
9401   {
9402     let keyword = EditableSyntax.from_json(
9403       json.catch_keyword, position, source);
9404     position += keyword.width;
9405     let left_paren = EditableSyntax.from_json(
9406       json.catch_left_paren, position, source);
9407     position += left_paren.width;
9408     let type = EditableSyntax.from_json(
9409       json.catch_type, position, source);
9410     position += type.width;
9411     let variable = EditableSyntax.from_json(
9412       json.catch_variable, position, source);
9413     position += variable.width;
9414     let right_paren = EditableSyntax.from_json(
9415       json.catch_right_paren, position, source);
9416     position += right_paren.width;
9417     let body = EditableSyntax.from_json(
9418       json.catch_body, position, source);
9419     position += body.width;
9420     return new CatchClause(
9421         keyword,
9422         left_paren,
9423         type,
9424         variable,
9425         right_paren,
9426         body);
9427   }
9428   get children_keys()
9429   {
9430     if (CatchClause._children_keys == null)
9431       CatchClause._children_keys = [
9432         'keyword',
9433         'left_paren',
9434         'type',
9435         'variable',
9436         'right_paren',
9437         'body'];
9438     return CatchClause._children_keys;
9439   }
9440 }
9441 class FinallyClause extends EditableSyntax
9442 {
9443   constructor(
9444     keyword,
9445     body)
9446   {
9447     super('finally_clause', {
9448       keyword: keyword,
9449       body: body });
9450   }
9451   get keyword() { return this.children.keyword; }
9452   get body() { return this.children.body; }
9453   with_keyword(keyword){
9454     return new FinallyClause(
9455       keyword,
9456       this.body);
9457   }
9458   with_body(body){
9459     return new FinallyClause(
9460       this.keyword,
9461       body);
9462   }
9463   rewrite(rewriter, parents)
9464   {
9465     if (parents == undefined)
9466       parents = [];
9467     let new_parents = parents.slice();
9468     new_parents.push(this);
9469     var keyword = this.keyword.rewrite(rewriter, new_parents);
9470     var body = this.body.rewrite(rewriter, new_parents);
9471     if (
9472       keyword === this.keyword &&
9473       body === this.body)
9474     {
9475       return rewriter(this, parents);
9476     }
9477     else
9478     {
9479       return rewriter(new FinallyClause(
9480         keyword,
9481         body), parents);
9482     }
9483   }
9484   static from_json(json, position, source)
9485   {
9486     let keyword = EditableSyntax.from_json(
9487       json.finally_keyword, position, source);
9488     position += keyword.width;
9489     let body = EditableSyntax.from_json(
9490       json.finally_body, position, source);
9491     position += body.width;
9492     return new FinallyClause(
9493         keyword,
9494         body);
9495   }
9496   get children_keys()
9497   {
9498     if (FinallyClause._children_keys == null)
9499       FinallyClause._children_keys = [
9500         'keyword',
9501         'body'];
9502     return FinallyClause._children_keys;
9503   }
9504 }
9505 class DoStatement extends EditableSyntax
9506 {
9507   constructor(
9508     keyword,
9509     body,
9510     while_keyword,
9511     left_paren,
9512     condition,
9513     right_paren,
9514     semicolon)
9515   {
9516     super('do_statement', {
9517       keyword: keyword,
9518       body: body,
9519       while_keyword: while_keyword,
9520       left_paren: left_paren,
9521       condition: condition,
9522       right_paren: right_paren,
9523       semicolon: semicolon });
9524   }
9525   get keyword() { return this.children.keyword; }
9526   get body() { return this.children.body; }
9527   get while_keyword() { return this.children.while_keyword; }
9528   get left_paren() { return this.children.left_paren; }
9529   get condition() { return this.children.condition; }
9530   get right_paren() { return this.children.right_paren; }
9531   get semicolon() { return this.children.semicolon; }
9532   with_keyword(keyword){
9533     return new DoStatement(
9534       keyword,
9535       this.body,
9536       this.while_keyword,
9537       this.left_paren,
9538       this.condition,
9539       this.right_paren,
9540       this.semicolon);
9541   }
9542   with_body(body){
9543     return new DoStatement(
9544       this.keyword,
9545       body,
9546       this.while_keyword,
9547       this.left_paren,
9548       this.condition,
9549       this.right_paren,
9550       this.semicolon);
9551   }
9552   with_while_keyword(while_keyword){
9553     return new DoStatement(
9554       this.keyword,
9555       this.body,
9556       while_keyword,
9557       this.left_paren,
9558       this.condition,
9559       this.right_paren,
9560       this.semicolon);
9561   }
9562   with_left_paren(left_paren){
9563     return new DoStatement(
9564       this.keyword,
9565       this.body,
9566       this.while_keyword,
9567       left_paren,
9568       this.condition,
9569       this.right_paren,
9570       this.semicolon);
9571   }
9572   with_condition(condition){
9573     return new DoStatement(
9574       this.keyword,
9575       this.body,
9576       this.while_keyword,
9577       this.left_paren,
9578       condition,
9579       this.right_paren,
9580       this.semicolon);
9581   }
9582   with_right_paren(right_paren){
9583     return new DoStatement(
9584       this.keyword,
9585       this.body,
9586       this.while_keyword,
9587       this.left_paren,
9588       this.condition,
9589       right_paren,
9590       this.semicolon);
9591   }
9592   with_semicolon(semicolon){
9593     return new DoStatement(
9594       this.keyword,
9595       this.body,
9596       this.while_keyword,
9597       this.left_paren,
9598       this.condition,
9599       this.right_paren,
9600       semicolon);
9601   }
9602   rewrite(rewriter, parents)
9603   {
9604     if (parents == undefined)
9605       parents = [];
9606     let new_parents = parents.slice();
9607     new_parents.push(this);
9608     var keyword = this.keyword.rewrite(rewriter, new_parents);
9609     var body = this.body.rewrite(rewriter, new_parents);
9610     var while_keyword = this.while_keyword.rewrite(rewriter, new_parents);
9611     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
9612     var condition = this.condition.rewrite(rewriter, new_parents);
9613     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
9614     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
9615     if (
9616       keyword === this.keyword &&
9617       body === this.body &&
9618       while_keyword === this.while_keyword &&
9619       left_paren === this.left_paren &&
9620       condition === this.condition &&
9621       right_paren === this.right_paren &&
9622       semicolon === this.semicolon)
9623     {
9624       return rewriter(this, parents);
9625     }
9626     else
9627     {
9628       return rewriter(new DoStatement(
9629         keyword,
9630         body,
9631         while_keyword,
9632         left_paren,
9633         condition,
9634         right_paren,
9635         semicolon), parents);
9636     }
9637   }
9638   static from_json(json, position, source)
9639   {
9640     let keyword = EditableSyntax.from_json(
9641       json.do_keyword, position, source);
9642     position += keyword.width;
9643     let body = EditableSyntax.from_json(
9644       json.do_body, position, source);
9645     position += body.width;
9646     let while_keyword = EditableSyntax.from_json(
9647       json.do_while_keyword, position, source);
9648     position += while_keyword.width;
9649     let left_paren = EditableSyntax.from_json(
9650       json.do_left_paren, position, source);
9651     position += left_paren.width;
9652     let condition = EditableSyntax.from_json(
9653       json.do_condition, position, source);
9654     position += condition.width;
9655     let right_paren = EditableSyntax.from_json(
9656       json.do_right_paren, position, source);
9657     position += right_paren.width;
9658     let semicolon = EditableSyntax.from_json(
9659       json.do_semicolon, position, source);
9660     position += semicolon.width;
9661     return new DoStatement(
9662         keyword,
9663         body,
9664         while_keyword,
9665         left_paren,
9666         condition,
9667         right_paren,
9668         semicolon);
9669   }
9670   get children_keys()
9671   {
9672     if (DoStatement._children_keys == null)
9673       DoStatement._children_keys = [
9674         'keyword',
9675         'body',
9676         'while_keyword',
9677         'left_paren',
9678         'condition',
9679         'right_paren',
9680         'semicolon'];
9681     return DoStatement._children_keys;
9682   }
9683 }
9684 class ForStatement extends EditableSyntax
9685 {
9686   constructor(
9687     keyword,
9688     left_paren,
9689     initializer,
9690     first_semicolon,
9691     control,
9692     second_semicolon,
9693     end_of_loop,
9694     right_paren,
9695     body)
9696   {
9697     super('for_statement', {
9698       keyword: keyword,
9699       left_paren: left_paren,
9700       initializer: initializer,
9701       first_semicolon: first_semicolon,
9702       control: control,
9703       second_semicolon: second_semicolon,
9704       end_of_loop: end_of_loop,
9705       right_paren: right_paren,
9706       body: body });
9707   }
9708   get keyword() { return this.children.keyword; }
9709   get left_paren() { return this.children.left_paren; }
9710   get initializer() { return this.children.initializer; }
9711   get first_semicolon() { return this.children.first_semicolon; }
9712   get control() { return this.children.control; }
9713   get second_semicolon() { return this.children.second_semicolon; }
9714   get end_of_loop() { return this.children.end_of_loop; }
9715   get right_paren() { return this.children.right_paren; }
9716   get body() { return this.children.body; }
9717   with_keyword(keyword){
9718     return new ForStatement(
9719       keyword,
9720       this.left_paren,
9721       this.initializer,
9722       this.first_semicolon,
9723       this.control,
9724       this.second_semicolon,
9725       this.end_of_loop,
9726       this.right_paren,
9727       this.body);
9728   }
9729   with_left_paren(left_paren){
9730     return new ForStatement(
9731       this.keyword,
9732       left_paren,
9733       this.initializer,
9734       this.first_semicolon,
9735       this.control,
9736       this.second_semicolon,
9737       this.end_of_loop,
9738       this.right_paren,
9739       this.body);
9740   }
9741   with_initializer(initializer){
9742     return new ForStatement(
9743       this.keyword,
9744       this.left_paren,
9745       initializer,
9746       this.first_semicolon,
9747       this.control,
9748       this.second_semicolon,
9749       this.end_of_loop,
9750       this.right_paren,
9751       this.body);
9752   }
9753   with_first_semicolon(first_semicolon){
9754     return new ForStatement(
9755       this.keyword,
9756       this.left_paren,
9757       this.initializer,
9758       first_semicolon,
9759       this.control,
9760       this.second_semicolon,
9761       this.end_of_loop,
9762       this.right_paren,
9763       this.body);
9764   }
9765   with_control(control){
9766     return new ForStatement(
9767       this.keyword,
9768       this.left_paren,
9769       this.initializer,
9770       this.first_semicolon,
9771       control,
9772       this.second_semicolon,
9773       this.end_of_loop,
9774       this.right_paren,
9775       this.body);
9776   }
9777   with_second_semicolon(second_semicolon){
9778     return new ForStatement(
9779       this.keyword,
9780       this.left_paren,
9781       this.initializer,
9782       this.first_semicolon,
9783       this.control,
9784       second_semicolon,
9785       this.end_of_loop,
9786       this.right_paren,
9787       this.body);
9788   }
9789   with_end_of_loop(end_of_loop){
9790     return new ForStatement(
9791       this.keyword,
9792       this.left_paren,
9793       this.initializer,
9794       this.first_semicolon,
9795       this.control,
9796       this.second_semicolon,
9797       end_of_loop,
9798       this.right_paren,
9799       this.body);
9800   }
9801   with_right_paren(right_paren){
9802     return new ForStatement(
9803       this.keyword,
9804       this.left_paren,
9805       this.initializer,
9806       this.first_semicolon,
9807       this.control,
9808       this.second_semicolon,
9809       this.end_of_loop,
9810       right_paren,
9811       this.body);
9812   }
9813   with_body(body){
9814     return new ForStatement(
9815       this.keyword,
9816       this.left_paren,
9817       this.initializer,
9818       this.first_semicolon,
9819       this.control,
9820       this.second_semicolon,
9821       this.end_of_loop,
9822       this.right_paren,
9823       body);
9824   }
9825   rewrite(rewriter, parents)
9826   {
9827     if (parents == undefined)
9828       parents = [];
9829     let new_parents = parents.slice();
9830     new_parents.push(this);
9831     var keyword = this.keyword.rewrite(rewriter, new_parents);
9832     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
9833     var initializer = this.initializer.rewrite(rewriter, new_parents);
9834     var first_semicolon = this.first_semicolon.rewrite(rewriter, new_parents);
9835     var control = this.control.rewrite(rewriter, new_parents);
9836     var second_semicolon = this.second_semicolon.rewrite(rewriter, new_parents);
9837     var end_of_loop = this.end_of_loop.rewrite(rewriter, new_parents);
9838     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
9839     var body = this.body.rewrite(rewriter, new_parents);
9840     if (
9841       keyword === this.keyword &&
9842       left_paren === this.left_paren &&
9843       initializer === this.initializer &&
9844       first_semicolon === this.first_semicolon &&
9845       control === this.control &&
9846       second_semicolon === this.second_semicolon &&
9847       end_of_loop === this.end_of_loop &&
9848       right_paren === this.right_paren &&
9849       body === this.body)
9850     {
9851       return rewriter(this, parents);
9852     }
9853     else
9854     {
9855       return rewriter(new ForStatement(
9856         keyword,
9857         left_paren,
9858         initializer,
9859         first_semicolon,
9860         control,
9861         second_semicolon,
9862         end_of_loop,
9863         right_paren,
9864         body), parents);
9865     }
9866   }
9867   static from_json(json, position, source)
9868   {
9869     let keyword = EditableSyntax.from_json(
9870       json.for_keyword, position, source);
9871     position += keyword.width;
9872     let left_paren = EditableSyntax.from_json(
9873       json.for_left_paren, position, source);
9874     position += left_paren.width;
9875     let initializer = EditableSyntax.from_json(
9876       json.for_initializer, position, source);
9877     position += initializer.width;
9878     let first_semicolon = EditableSyntax.from_json(
9879       json.for_first_semicolon, position, source);
9880     position += first_semicolon.width;
9881     let control = EditableSyntax.from_json(
9882       json.for_control, position, source);
9883     position += control.width;
9884     let second_semicolon = EditableSyntax.from_json(
9885       json.for_second_semicolon, position, source);
9886     position += second_semicolon.width;
9887     let end_of_loop = EditableSyntax.from_json(
9888       json.for_end_of_loop, position, source);
9889     position += end_of_loop.width;
9890     let right_paren = EditableSyntax.from_json(
9891       json.for_right_paren, position, source);
9892     position += right_paren.width;
9893     let body = EditableSyntax.from_json(
9894       json.for_body, position, source);
9895     position += body.width;
9896     return new ForStatement(
9897         keyword,
9898         left_paren,
9899         initializer,
9900         first_semicolon,
9901         control,
9902         second_semicolon,
9903         end_of_loop,
9904         right_paren,
9905         body);
9906   }
9907   get children_keys()
9908   {
9909     if (ForStatement._children_keys == null)
9910       ForStatement._children_keys = [
9911         'keyword',
9912         'left_paren',
9913         'initializer',
9914         'first_semicolon',
9915         'control',
9916         'second_semicolon',
9917         'end_of_loop',
9918         'right_paren',
9919         'body'];
9920     return ForStatement._children_keys;
9921   }
9922 }
9923 class ForeachStatement extends EditableSyntax
9924 {
9925   constructor(
9926     keyword,
9927     left_paren,
9928     collection,
9929     await_keyword,
9930     as,
9931     key,
9932     arrow,
9933     value,
9934     right_paren,
9935     body)
9936   {
9937     super('foreach_statement', {
9938       keyword: keyword,
9939       left_paren: left_paren,
9940       collection: collection,
9941       await_keyword: await_keyword,
9942       as: as,
9943       key: key,
9944       arrow: arrow,
9945       value: value,
9946       right_paren: right_paren,
9947       body: body });
9948   }
9949   get keyword() { return this.children.keyword; }
9950   get left_paren() { return this.children.left_paren; }
9951   get collection() { return this.children.collection; }
9952   get await_keyword() { return this.children.await_keyword; }
9953   get as() { return this.children.as; }
9954   get key() { return this.children.key; }
9955   get arrow() { return this.children.arrow; }
9956   get value() { return this.children.value; }
9957   get right_paren() { return this.children.right_paren; }
9958   get body() { return this.children.body; }
9959   with_keyword(keyword){
9960     return new ForeachStatement(
9961       keyword,
9962       this.left_paren,
9963       this.collection,
9964       this.await_keyword,
9965       this.as,
9966       this.key,
9967       this.arrow,
9968       this.value,
9969       this.right_paren,
9970       this.body);
9971   }
9972   with_left_paren(left_paren){
9973     return new ForeachStatement(
9974       this.keyword,
9975       left_paren,
9976       this.collection,
9977       this.await_keyword,
9978       this.as,
9979       this.key,
9980       this.arrow,
9981       this.value,
9982       this.right_paren,
9983       this.body);
9984   }
9985   with_collection(collection){
9986     return new ForeachStatement(
9987       this.keyword,
9988       this.left_paren,
9989       collection,
9990       this.await_keyword,
9991       this.as,
9992       this.key,
9993       this.arrow,
9994       this.value,
9995       this.right_paren,
9996       this.body);
9997   }
9998   with_await_keyword(await_keyword){
9999     return new ForeachStatement(
10000       this.keyword,
10001       this.left_paren,
10002       this.collection,
10003       await_keyword,
10004       this.as,
10005       this.key,
10006       this.arrow,
10007       this.value,
10008       this.right_paren,
10009       this.body);
10010   }
10011   with_as(as){
10012     return new ForeachStatement(
10013       this.keyword,
10014       this.left_paren,
10015       this.collection,
10016       this.await_keyword,
10017       as,
10018       this.key,
10019       this.arrow,
10020       this.value,
10021       this.right_paren,
10022       this.body);
10023   }
10024   with_key(key){
10025     return new ForeachStatement(
10026       this.keyword,
10027       this.left_paren,
10028       this.collection,
10029       this.await_keyword,
10030       this.as,
10031       key,
10032       this.arrow,
10033       this.value,
10034       this.right_paren,
10035       this.body);
10036   }
10037   with_arrow(arrow){
10038     return new ForeachStatement(
10039       this.keyword,
10040       this.left_paren,
10041       this.collection,
10042       this.await_keyword,
10043       this.as,
10044       this.key,
10045       arrow,
10046       this.value,
10047       this.right_paren,
10048       this.body);
10049   }
10050   with_value(value){
10051     return new ForeachStatement(
10052       this.keyword,
10053       this.left_paren,
10054       this.collection,
10055       this.await_keyword,
10056       this.as,
10057       this.key,
10058       this.arrow,
10059       value,
10060       this.right_paren,
10061       this.body);
10062   }
10063   with_right_paren(right_paren){
10064     return new ForeachStatement(
10065       this.keyword,
10066       this.left_paren,
10067       this.collection,
10068       this.await_keyword,
10069       this.as,
10070       this.key,
10071       this.arrow,
10072       this.value,
10073       right_paren,
10074       this.body);
10075   }
10076   with_body(body){
10077     return new ForeachStatement(
10078       this.keyword,
10079       this.left_paren,
10080       this.collection,
10081       this.await_keyword,
10082       this.as,
10083       this.key,
10084       this.arrow,
10085       this.value,
10086       this.right_paren,
10087       body);
10088   }
10089   rewrite(rewriter, parents)
10090   {
10091     if (parents == undefined)
10092       parents = [];
10093     let new_parents = parents.slice();
10094     new_parents.push(this);
10095     var keyword = this.keyword.rewrite(rewriter, new_parents);
10096     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
10097     var collection = this.collection.rewrite(rewriter, new_parents);
10098     var await_keyword = this.await_keyword.rewrite(rewriter, new_parents);
10099     var as = this.as.rewrite(rewriter, new_parents);
10100     var key = this.key.rewrite(rewriter, new_parents);
10101     var arrow = this.arrow.rewrite(rewriter, new_parents);
10102     var value = this.value.rewrite(rewriter, new_parents);
10103     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
10104     var body = this.body.rewrite(rewriter, new_parents);
10105     if (
10106       keyword === this.keyword &&
10107       left_paren === this.left_paren &&
10108       collection === this.collection &&
10109       await_keyword === this.await_keyword &&
10110       as === this.as &&
10111       key === this.key &&
10112       arrow === this.arrow &&
10113       value === this.value &&
10114       right_paren === this.right_paren &&
10115       body === this.body)
10116     {
10117       return rewriter(this, parents);
10118     }
10119     else
10120     {
10121       return rewriter(new ForeachStatement(
10122         keyword,
10123         left_paren,
10124         collection,
10125         await_keyword,
10126         as,
10127         key,
10128         arrow,
10129         value,
10130         right_paren,
10131         body), parents);
10132     }
10133   }
10134   static from_json(json, position, source)
10135   {
10136     let keyword = EditableSyntax.from_json(
10137       json.foreach_keyword, position, source);
10138     position += keyword.width;
10139     let left_paren = EditableSyntax.from_json(
10140       json.foreach_left_paren, position, source);
10141     position += left_paren.width;
10142     let collection = EditableSyntax.from_json(
10143       json.foreach_collection, position, source);
10144     position += collection.width;
10145     let await_keyword = EditableSyntax.from_json(
10146       json.foreach_await_keyword, position, source);
10147     position += await_keyword.width;
10148     let as = EditableSyntax.from_json(
10149       json.foreach_as, position, source);
10150     position += as.width;
10151     let key = EditableSyntax.from_json(
10152       json.foreach_key, position, source);
10153     position += key.width;
10154     let arrow = EditableSyntax.from_json(
10155       json.foreach_arrow, position, source);
10156     position += arrow.width;
10157     let value = EditableSyntax.from_json(
10158       json.foreach_value, position, source);
10159     position += value.width;
10160     let right_paren = EditableSyntax.from_json(
10161       json.foreach_right_paren, position, source);
10162     position += right_paren.width;
10163     let body = EditableSyntax.from_json(
10164       json.foreach_body, position, source);
10165     position += body.width;
10166     return new ForeachStatement(
10167         keyword,
10168         left_paren,
10169         collection,
10170         await_keyword,
10171         as,
10172         key,
10173         arrow,
10174         value,
10175         right_paren,
10176         body);
10177   }
10178   get children_keys()
10179   {
10180     if (ForeachStatement._children_keys == null)
10181       ForeachStatement._children_keys = [
10182         'keyword',
10183         'left_paren',
10184         'collection',
10185         'await_keyword',
10186         'as',
10187         'key',
10188         'arrow',
10189         'value',
10190         'right_paren',
10191         'body'];
10192     return ForeachStatement._children_keys;
10193   }
10194 }
10195 class SwitchStatement extends EditableSyntax
10196 {
10197   constructor(
10198     keyword,
10199     left_paren,
10200     expression,
10201     right_paren,
10202     left_brace,
10203     sections,
10204     right_brace)
10205   {
10206     super('switch_statement', {
10207       keyword: keyword,
10208       left_paren: left_paren,
10209       expression: expression,
10210       right_paren: right_paren,
10211       left_brace: left_brace,
10212       sections: sections,
10213       right_brace: right_brace });
10214   }
10215   get keyword() { return this.children.keyword; }
10216   get left_paren() { return this.children.left_paren; }
10217   get expression() { return this.children.expression; }
10218   get right_paren() { return this.children.right_paren; }
10219   get left_brace() { return this.children.left_brace; }
10220   get sections() { return this.children.sections; }
10221   get right_brace() { return this.children.right_brace; }
10222   with_keyword(keyword){
10223     return new SwitchStatement(
10224       keyword,
10225       this.left_paren,
10226       this.expression,
10227       this.right_paren,
10228       this.left_brace,
10229       this.sections,
10230       this.right_brace);
10231   }
10232   with_left_paren(left_paren){
10233     return new SwitchStatement(
10234       this.keyword,
10235       left_paren,
10236       this.expression,
10237       this.right_paren,
10238       this.left_brace,
10239       this.sections,
10240       this.right_brace);
10241   }
10242   with_expression(expression){
10243     return new SwitchStatement(
10244       this.keyword,
10245       this.left_paren,
10246       expression,
10247       this.right_paren,
10248       this.left_brace,
10249       this.sections,
10250       this.right_brace);
10251   }
10252   with_right_paren(right_paren){
10253     return new SwitchStatement(
10254       this.keyword,
10255       this.left_paren,
10256       this.expression,
10257       right_paren,
10258       this.left_brace,
10259       this.sections,
10260       this.right_brace);
10261   }
10262   with_left_brace(left_brace){
10263     return new SwitchStatement(
10264       this.keyword,
10265       this.left_paren,
10266       this.expression,
10267       this.right_paren,
10268       left_brace,
10269       this.sections,
10270       this.right_brace);
10271   }
10272   with_sections(sections){
10273     return new SwitchStatement(
10274       this.keyword,
10275       this.left_paren,
10276       this.expression,
10277       this.right_paren,
10278       this.left_brace,
10279       sections,
10280       this.right_brace);
10281   }
10282   with_right_brace(right_brace){
10283     return new SwitchStatement(
10284       this.keyword,
10285       this.left_paren,
10286       this.expression,
10287       this.right_paren,
10288       this.left_brace,
10289       this.sections,
10290       right_brace);
10291   }
10292   rewrite(rewriter, parents)
10293   {
10294     if (parents == undefined)
10295       parents = [];
10296     let new_parents = parents.slice();
10297     new_parents.push(this);
10298     var keyword = this.keyword.rewrite(rewriter, new_parents);
10299     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
10300     var expression = this.expression.rewrite(rewriter, new_parents);
10301     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
10302     var left_brace = this.left_brace.rewrite(rewriter, new_parents);
10303     var sections = this.sections.rewrite(rewriter, new_parents);
10304     var right_brace = this.right_brace.rewrite(rewriter, new_parents);
10305     if (
10306       keyword === this.keyword &&
10307       left_paren === this.left_paren &&
10308       expression === this.expression &&
10309       right_paren === this.right_paren &&
10310       left_brace === this.left_brace &&
10311       sections === this.sections &&
10312       right_brace === this.right_brace)
10313     {
10314       return rewriter(this, parents);
10315     }
10316     else
10317     {
10318       return rewriter(new SwitchStatement(
10319         keyword,
10320         left_paren,
10321         expression,
10322         right_paren,
10323         left_brace,
10324         sections,
10325         right_brace), parents);
10326     }
10327   }
10328   static from_json(json, position, source)
10329   {
10330     let keyword = EditableSyntax.from_json(
10331       json.switch_keyword, position, source);
10332     position += keyword.width;
10333     let left_paren = EditableSyntax.from_json(
10334       json.switch_left_paren, position, source);
10335     position += left_paren.width;
10336     let expression = EditableSyntax.from_json(
10337       json.switch_expression, position, source);
10338     position += expression.width;
10339     let right_paren = EditableSyntax.from_json(
10340       json.switch_right_paren, position, source);
10341     position += right_paren.width;
10342     let left_brace = EditableSyntax.from_json(
10343       json.switch_left_brace, position, source);
10344     position += left_brace.width;
10345     let sections = EditableSyntax.from_json(
10346       json.switch_sections, position, source);
10347     position += sections.width;
10348     let right_brace = EditableSyntax.from_json(
10349       json.switch_right_brace, position, source);
10350     position += right_brace.width;
10351     return new SwitchStatement(
10352         keyword,
10353         left_paren,
10354         expression,
10355         right_paren,
10356         left_brace,
10357         sections,
10358         right_brace);
10359   }
10360   get children_keys()
10361   {
10362     if (SwitchStatement._children_keys == null)
10363       SwitchStatement._children_keys = [
10364         'keyword',
10365         'left_paren',
10366         'expression',
10367         'right_paren',
10368         'left_brace',
10369         'sections',
10370         'right_brace'];
10371     return SwitchStatement._children_keys;
10372   }
10373 }
10374 class AlternateSwitchStatement extends EditableSyntax
10375 {
10376   constructor(
10377     keyword,
10378     left_paren,
10379     expression,
10380     right_paren,
10381     opening_colon,
10382     sections,
10383     closing_endswitch,
10384     closing_semicolon)
10385   {
10386     super('alternate_switch_statement', {
10387       keyword: keyword,
10388       left_paren: left_paren,
10389       expression: expression,
10390       right_paren: right_paren,
10391       opening_colon: opening_colon,
10392       sections: sections,
10393       closing_endswitch: closing_endswitch,
10394       closing_semicolon: closing_semicolon });
10395   }
10396   get keyword() { return this.children.keyword; }
10397   get left_paren() { return this.children.left_paren; }
10398   get expression() { return this.children.expression; }
10399   get right_paren() { return this.children.right_paren; }
10400   get opening_colon() { return this.children.opening_colon; }
10401   get sections() { return this.children.sections; }
10402   get closing_endswitch() { return this.children.closing_endswitch; }
10403   get closing_semicolon() { return this.children.closing_semicolon; }
10404   with_keyword(keyword){
10405     return new AlternateSwitchStatement(
10406       keyword,
10407       this.left_paren,
10408       this.expression,
10409       this.right_paren,
10410       this.opening_colon,
10411       this.sections,
10412       this.closing_endswitch,
10413       this.closing_semicolon);
10414   }
10415   with_left_paren(left_paren){
10416     return new AlternateSwitchStatement(
10417       this.keyword,
10418       left_paren,
10419       this.expression,
10420       this.right_paren,
10421       this.opening_colon,
10422       this.sections,
10423       this.closing_endswitch,
10424       this.closing_semicolon);
10425   }
10426   with_expression(expression){
10427     return new AlternateSwitchStatement(
10428       this.keyword,
10429       this.left_paren,
10430       expression,
10431       this.right_paren,
10432       this.opening_colon,
10433       this.sections,
10434       this.closing_endswitch,
10435       this.closing_semicolon);
10436   }
10437   with_right_paren(right_paren){
10438     return new AlternateSwitchStatement(
10439       this.keyword,
10440       this.left_paren,
10441       this.expression,
10442       right_paren,
10443       this.opening_colon,
10444       this.sections,
10445       this.closing_endswitch,
10446       this.closing_semicolon);
10447   }
10448   with_opening_colon(opening_colon){
10449     return new AlternateSwitchStatement(
10450       this.keyword,
10451       this.left_paren,
10452       this.expression,
10453       this.right_paren,
10454       opening_colon,
10455       this.sections,
10456       this.closing_endswitch,
10457       this.closing_semicolon);
10458   }
10459   with_sections(sections){
10460     return new AlternateSwitchStatement(
10461       this.keyword,
10462       this.left_paren,
10463       this.expression,
10464       this.right_paren,
10465       this.opening_colon,
10466       sections,
10467       this.closing_endswitch,
10468       this.closing_semicolon);
10469   }
10470   with_closing_endswitch(closing_endswitch){
10471     return new AlternateSwitchStatement(
10472       this.keyword,
10473       this.left_paren,
10474       this.expression,
10475       this.right_paren,
10476       this.opening_colon,
10477       this.sections,
10478       closing_endswitch,
10479       this.closing_semicolon);
10480   }
10481   with_closing_semicolon(closing_semicolon){
10482     return new AlternateSwitchStatement(
10483       this.keyword,
10484       this.left_paren,
10485       this.expression,
10486       this.right_paren,
10487       this.opening_colon,
10488       this.sections,
10489       this.closing_endswitch,
10490       closing_semicolon);
10491   }
10492   rewrite(rewriter, parents)
10493   {
10494     if (parents == undefined)
10495       parents = [];
10496     let new_parents = parents.slice();
10497     new_parents.push(this);
10498     var keyword = this.keyword.rewrite(rewriter, new_parents);
10499     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
10500     var expression = this.expression.rewrite(rewriter, new_parents);
10501     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
10502     var opening_colon = this.opening_colon.rewrite(rewriter, new_parents);
10503     var sections = this.sections.rewrite(rewriter, new_parents);
10504     var closing_endswitch = this.closing_endswitch.rewrite(rewriter, new_parents);
10505     var closing_semicolon = this.closing_semicolon.rewrite(rewriter, new_parents);
10506     if (
10507       keyword === this.keyword &&
10508       left_paren === this.left_paren &&
10509       expression === this.expression &&
10510       right_paren === this.right_paren &&
10511       opening_colon === this.opening_colon &&
10512       sections === this.sections &&
10513       closing_endswitch === this.closing_endswitch &&
10514       closing_semicolon === this.closing_semicolon)
10515     {
10516       return rewriter(this, parents);
10517     }
10518     else
10519     {
10520       return rewriter(new AlternateSwitchStatement(
10521         keyword,
10522         left_paren,
10523         expression,
10524         right_paren,
10525         opening_colon,
10526         sections,
10527         closing_endswitch,
10528         closing_semicolon), parents);
10529     }
10530   }
10531   static from_json(json, position, source)
10532   {
10533     let keyword = EditableSyntax.from_json(
10534       json.alternate_switch_keyword, position, source);
10535     position += keyword.width;
10536     let left_paren = EditableSyntax.from_json(
10537       json.alternate_switch_left_paren, position, source);
10538     position += left_paren.width;
10539     let expression = EditableSyntax.from_json(
10540       json.alternate_switch_expression, position, source);
10541     position += expression.width;
10542     let right_paren = EditableSyntax.from_json(
10543       json.alternate_switch_right_paren, position, source);
10544     position += right_paren.width;
10545     let opening_colon = EditableSyntax.from_json(
10546       json.alternate_switch_opening_colon, position, source);
10547     position += opening_colon.width;
10548     let sections = EditableSyntax.from_json(
10549       json.alternate_switch_sections, position, source);
10550     position += sections.width;
10551     let closing_endswitch = EditableSyntax.from_json(
10552       json.alternate_switch_closing_endswitch, position, source);
10553     position += closing_endswitch.width;
10554     let closing_semicolon = EditableSyntax.from_json(
10555       json.alternate_switch_closing_semicolon, position, source);
10556     position += closing_semicolon.width;
10557     return new AlternateSwitchStatement(
10558         keyword,
10559         left_paren,
10560         expression,
10561         right_paren,
10562         opening_colon,
10563         sections,
10564         closing_endswitch,
10565         closing_semicolon);
10566   }
10567   get children_keys()
10568   {
10569     if (AlternateSwitchStatement._children_keys == null)
10570       AlternateSwitchStatement._children_keys = [
10571         'keyword',
10572         'left_paren',
10573         'expression',
10574         'right_paren',
10575         'opening_colon',
10576         'sections',
10577         'closing_endswitch',
10578         'closing_semicolon'];
10579     return AlternateSwitchStatement._children_keys;
10580   }
10581 }
10582 class SwitchSection extends EditableSyntax
10583 {
10584   constructor(
10585     labels,
10586     statements,
10587     fallthrough)
10588   {
10589     super('switch_section', {
10590       labels: labels,
10591       statements: statements,
10592       fallthrough: fallthrough });
10593   }
10594   get labels() { return this.children.labels; }
10595   get statements() { return this.children.statements; }
10596   get fallthrough() { return this.children.fallthrough; }
10597   with_labels(labels){
10598     return new SwitchSection(
10599       labels,
10600       this.statements,
10601       this.fallthrough);
10602   }
10603   with_statements(statements){
10604     return new SwitchSection(
10605       this.labels,
10606       statements,
10607       this.fallthrough);
10608   }
10609   with_fallthrough(fallthrough){
10610     return new SwitchSection(
10611       this.labels,
10612       this.statements,
10613       fallthrough);
10614   }
10615   rewrite(rewriter, parents)
10616   {
10617     if (parents == undefined)
10618       parents = [];
10619     let new_parents = parents.slice();
10620     new_parents.push(this);
10621     var labels = this.labels.rewrite(rewriter, new_parents);
10622     var statements = this.statements.rewrite(rewriter, new_parents);
10623     var fallthrough = this.fallthrough.rewrite(rewriter, new_parents);
10624     if (
10625       labels === this.labels &&
10626       statements === this.statements &&
10627       fallthrough === this.fallthrough)
10628     {
10629       return rewriter(this, parents);
10630     }
10631     else
10632     {
10633       return rewriter(new SwitchSection(
10634         labels,
10635         statements,
10636         fallthrough), parents);
10637     }
10638   }
10639   static from_json(json, position, source)
10640   {
10641     let labels = EditableSyntax.from_json(
10642       json.switch_section_labels, position, source);
10643     position += labels.width;
10644     let statements = EditableSyntax.from_json(
10645       json.switch_section_statements, position, source);
10646     position += statements.width;
10647     let fallthrough = EditableSyntax.from_json(
10648       json.switch_section_fallthrough, position, source);
10649     position += fallthrough.width;
10650     return new SwitchSection(
10651         labels,
10652         statements,
10653         fallthrough);
10654   }
10655   get children_keys()
10656   {
10657     if (SwitchSection._children_keys == null)
10658       SwitchSection._children_keys = [
10659         'labels',
10660         'statements',
10661         'fallthrough'];
10662     return SwitchSection._children_keys;
10663   }
10664 }
10665 class SwitchFallthrough extends EditableSyntax
10666 {
10667   constructor(
10668     keyword,
10669     semicolon)
10670   {
10671     super('switch_fallthrough', {
10672       keyword: keyword,
10673       semicolon: semicolon });
10674   }
10675   get keyword() { return this.children.keyword; }
10676   get semicolon() { return this.children.semicolon; }
10677   with_keyword(keyword){
10678     return new SwitchFallthrough(
10679       keyword,
10680       this.semicolon);
10681   }
10682   with_semicolon(semicolon){
10683     return new SwitchFallthrough(
10684       this.keyword,
10685       semicolon);
10686   }
10687   rewrite(rewriter, parents)
10688   {
10689     if (parents == undefined)
10690       parents = [];
10691     let new_parents = parents.slice();
10692     new_parents.push(this);
10693     var keyword = this.keyword.rewrite(rewriter, new_parents);
10694     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
10695     if (
10696       keyword === this.keyword &&
10697       semicolon === this.semicolon)
10698     {
10699       return rewriter(this, parents);
10700     }
10701     else
10702     {
10703       return rewriter(new SwitchFallthrough(
10704         keyword,
10705         semicolon), parents);
10706     }
10707   }
10708   static from_json(json, position, source)
10709   {
10710     let keyword = EditableSyntax.from_json(
10711       json.fallthrough_keyword, position, source);
10712     position += keyword.width;
10713     let semicolon = EditableSyntax.from_json(
10714       json.fallthrough_semicolon, position, source);
10715     position += semicolon.width;
10716     return new SwitchFallthrough(
10717         keyword,
10718         semicolon);
10719   }
10720   get children_keys()
10721   {
10722     if (SwitchFallthrough._children_keys == null)
10723       SwitchFallthrough._children_keys = [
10724         'keyword',
10725         'semicolon'];
10726     return SwitchFallthrough._children_keys;
10727   }
10728 }
10729 class CaseLabel extends EditableSyntax
10730 {
10731   constructor(
10732     keyword,
10733     expression,
10734     colon)
10735   {
10736     super('case_label', {
10737       keyword: keyword,
10738       expression: expression,
10739       colon: colon });
10740   }
10741   get keyword() { return this.children.keyword; }
10742   get expression() { return this.children.expression; }
10743   get colon() { return this.children.colon; }
10744   with_keyword(keyword){
10745     return new CaseLabel(
10746       keyword,
10747       this.expression,
10748       this.colon);
10749   }
10750   with_expression(expression){
10751     return new CaseLabel(
10752       this.keyword,
10753       expression,
10754       this.colon);
10755   }
10756   with_colon(colon){
10757     return new CaseLabel(
10758       this.keyword,
10759       this.expression,
10760       colon);
10761   }
10762   rewrite(rewriter, parents)
10763   {
10764     if (parents == undefined)
10765       parents = [];
10766     let new_parents = parents.slice();
10767     new_parents.push(this);
10768     var keyword = this.keyword.rewrite(rewriter, new_parents);
10769     var expression = this.expression.rewrite(rewriter, new_parents);
10770     var colon = this.colon.rewrite(rewriter, new_parents);
10771     if (
10772       keyword === this.keyword &&
10773       expression === this.expression &&
10774       colon === this.colon)
10775     {
10776       return rewriter(this, parents);
10777     }
10778     else
10779     {
10780       return rewriter(new CaseLabel(
10781         keyword,
10782         expression,
10783         colon), parents);
10784     }
10785   }
10786   static from_json(json, position, source)
10787   {
10788     let keyword = EditableSyntax.from_json(
10789       json.case_keyword, position, source);
10790     position += keyword.width;
10791     let expression = EditableSyntax.from_json(
10792       json.case_expression, position, source);
10793     position += expression.width;
10794     let colon = EditableSyntax.from_json(
10795       json.case_colon, position, source);
10796     position += colon.width;
10797     return new CaseLabel(
10798         keyword,
10799         expression,
10800         colon);
10801   }
10802   get children_keys()
10803   {
10804     if (CaseLabel._children_keys == null)
10805       CaseLabel._children_keys = [
10806         'keyword',
10807         'expression',
10808         'colon'];
10809     return CaseLabel._children_keys;
10810   }
10811 }
10812 class DefaultLabel extends EditableSyntax
10813 {
10814   constructor(
10815     keyword,
10816     colon)
10817   {
10818     super('default_label', {
10819       keyword: keyword,
10820       colon: colon });
10821   }
10822   get keyword() { return this.children.keyword; }
10823   get colon() { return this.children.colon; }
10824   with_keyword(keyword){
10825     return new DefaultLabel(
10826       keyword,
10827       this.colon);
10828   }
10829   with_colon(colon){
10830     return new DefaultLabel(
10831       this.keyword,
10832       colon);
10833   }
10834   rewrite(rewriter, parents)
10835   {
10836     if (parents == undefined)
10837       parents = [];
10838     let new_parents = parents.slice();
10839     new_parents.push(this);
10840     var keyword = this.keyword.rewrite(rewriter, new_parents);
10841     var colon = this.colon.rewrite(rewriter, new_parents);
10842     if (
10843       keyword === this.keyword &&
10844       colon === this.colon)
10845     {
10846       return rewriter(this, parents);
10847     }
10848     else
10849     {
10850       return rewriter(new DefaultLabel(
10851         keyword,
10852         colon), parents);
10853     }
10854   }
10855   static from_json(json, position, source)
10856   {
10857     let keyword = EditableSyntax.from_json(
10858       json.default_keyword, position, source);
10859     position += keyword.width;
10860     let colon = EditableSyntax.from_json(
10861       json.default_colon, position, source);
10862     position += colon.width;
10863     return new DefaultLabel(
10864         keyword,
10865         colon);
10866   }
10867   get children_keys()
10868   {
10869     if (DefaultLabel._children_keys == null)
10870       DefaultLabel._children_keys = [
10871         'keyword',
10872         'colon'];
10873     return DefaultLabel._children_keys;
10874   }
10875 }
10876 class ReturnStatement extends EditableSyntax
10877 {
10878   constructor(
10879     keyword,
10880     expression,
10881     semicolon)
10882   {
10883     super('return_statement', {
10884       keyword: keyword,
10885       expression: expression,
10886       semicolon: semicolon });
10887   }
10888   get keyword() { return this.children.keyword; }
10889   get expression() { return this.children.expression; }
10890   get semicolon() { return this.children.semicolon; }
10891   with_keyword(keyword){
10892     return new ReturnStatement(
10893       keyword,
10894       this.expression,
10895       this.semicolon);
10896   }
10897   with_expression(expression){
10898     return new ReturnStatement(
10899       this.keyword,
10900       expression,
10901       this.semicolon);
10902   }
10903   with_semicolon(semicolon){
10904     return new ReturnStatement(
10905       this.keyword,
10906       this.expression,
10907       semicolon);
10908   }
10909   rewrite(rewriter, parents)
10910   {
10911     if (parents == undefined)
10912       parents = [];
10913     let new_parents = parents.slice();
10914     new_parents.push(this);
10915     var keyword = this.keyword.rewrite(rewriter, new_parents);
10916     var expression = this.expression.rewrite(rewriter, new_parents);
10917     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
10918     if (
10919       keyword === this.keyword &&
10920       expression === this.expression &&
10921       semicolon === this.semicolon)
10922     {
10923       return rewriter(this, parents);
10924     }
10925     else
10926     {
10927       return rewriter(new ReturnStatement(
10928         keyword,
10929         expression,
10930         semicolon), parents);
10931     }
10932   }
10933   static from_json(json, position, source)
10934   {
10935     let keyword = EditableSyntax.from_json(
10936       json.return_keyword, position, source);
10937     position += keyword.width;
10938     let expression = EditableSyntax.from_json(
10939       json.return_expression, position, source);
10940     position += expression.width;
10941     let semicolon = EditableSyntax.from_json(
10942       json.return_semicolon, position, source);
10943     position += semicolon.width;
10944     return new ReturnStatement(
10945         keyword,
10946         expression,
10947         semicolon);
10948   }
10949   get children_keys()
10950   {
10951     if (ReturnStatement._children_keys == null)
10952       ReturnStatement._children_keys = [
10953         'keyword',
10954         'expression',
10955         'semicolon'];
10956     return ReturnStatement._children_keys;
10957   }
10958 }
10959 class GotoLabel extends EditableSyntax
10960 {
10961   constructor(
10962     name,
10963     colon)
10964   {
10965     super('goto_label', {
10966       name: name,
10967       colon: colon });
10968   }
10969   get name() { return this.children.name; }
10970   get colon() { return this.children.colon; }
10971   with_name(name){
10972     return new GotoLabel(
10973       name,
10974       this.colon);
10975   }
10976   with_colon(colon){
10977     return new GotoLabel(
10978       this.name,
10979       colon);
10980   }
10981   rewrite(rewriter, parents)
10982   {
10983     if (parents == undefined)
10984       parents = [];
10985     let new_parents = parents.slice();
10986     new_parents.push(this);
10987     var name = this.name.rewrite(rewriter, new_parents);
10988     var colon = this.colon.rewrite(rewriter, new_parents);
10989     if (
10990       name === this.name &&
10991       colon === this.colon)
10992     {
10993       return rewriter(this, parents);
10994     }
10995     else
10996     {
10997       return rewriter(new GotoLabel(
10998         name,
10999         colon), parents);
11000     }
11001   }
11002   static from_json(json, position, source)
11003   {
11004     let name = EditableSyntax.from_json(
11005       json.goto_label_name, position, source);
11006     position += name.width;
11007     let colon = EditableSyntax.from_json(
11008       json.goto_label_colon, position, source);
11009     position += colon.width;
11010     return new GotoLabel(
11011         name,
11012         colon);
11013   }
11014   get children_keys()
11015   {
11016     if (GotoLabel._children_keys == null)
11017       GotoLabel._children_keys = [
11018         'name',
11019         'colon'];
11020     return GotoLabel._children_keys;
11021   }
11022 }
11023 class GotoStatement extends EditableSyntax
11024 {
11025   constructor(
11026     keyword,
11027     label_name,
11028     semicolon)
11029   {
11030     super('goto_statement', {
11031       keyword: keyword,
11032       label_name: label_name,
11033       semicolon: semicolon });
11034   }
11035   get keyword() { return this.children.keyword; }
11036   get label_name() { return this.children.label_name; }
11037   get semicolon() { return this.children.semicolon; }
11038   with_keyword(keyword){
11039     return new GotoStatement(
11040       keyword,
11041       this.label_name,
11042       this.semicolon);
11043   }
11044   with_label_name(label_name){
11045     return new GotoStatement(
11046       this.keyword,
11047       label_name,
11048       this.semicolon);
11049   }
11050   with_semicolon(semicolon){
11051     return new GotoStatement(
11052       this.keyword,
11053       this.label_name,
11054       semicolon);
11055   }
11056   rewrite(rewriter, parents)
11057   {
11058     if (parents == undefined)
11059       parents = [];
11060     let new_parents = parents.slice();
11061     new_parents.push(this);
11062     var keyword = this.keyword.rewrite(rewriter, new_parents);
11063     var label_name = this.label_name.rewrite(rewriter, new_parents);
11064     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
11065     if (
11066       keyword === this.keyword &&
11067       label_name === this.label_name &&
11068       semicolon === this.semicolon)
11069     {
11070       return rewriter(this, parents);
11071     }
11072     else
11073     {
11074       return rewriter(new GotoStatement(
11075         keyword,
11076         label_name,
11077         semicolon), parents);
11078     }
11079   }
11080   static from_json(json, position, source)
11081   {
11082     let keyword = EditableSyntax.from_json(
11083       json.goto_statement_keyword, position, source);
11084     position += keyword.width;
11085     let label_name = EditableSyntax.from_json(
11086       json.goto_statement_label_name, position, source);
11087     position += label_name.width;
11088     let semicolon = EditableSyntax.from_json(
11089       json.goto_statement_semicolon, position, source);
11090     position += semicolon.width;
11091     return new GotoStatement(
11092         keyword,
11093         label_name,
11094         semicolon);
11095   }
11096   get children_keys()
11097   {
11098     if (GotoStatement._children_keys == null)
11099       GotoStatement._children_keys = [
11100         'keyword',
11101         'label_name',
11102         'semicolon'];
11103     return GotoStatement._children_keys;
11104   }
11105 }
11106 class ThrowStatement extends EditableSyntax
11107 {
11108   constructor(
11109     keyword,
11110     expression,
11111     semicolon)
11112   {
11113     super('throw_statement', {
11114       keyword: keyword,
11115       expression: expression,
11116       semicolon: semicolon });
11117   }
11118   get keyword() { return this.children.keyword; }
11119   get expression() { return this.children.expression; }
11120   get semicolon() { return this.children.semicolon; }
11121   with_keyword(keyword){
11122     return new ThrowStatement(
11123       keyword,
11124       this.expression,
11125       this.semicolon);
11126   }
11127   with_expression(expression){
11128     return new ThrowStatement(
11129       this.keyword,
11130       expression,
11131       this.semicolon);
11132   }
11133   with_semicolon(semicolon){
11134     return new ThrowStatement(
11135       this.keyword,
11136       this.expression,
11137       semicolon);
11138   }
11139   rewrite(rewriter, parents)
11140   {
11141     if (parents == undefined)
11142       parents = [];
11143     let new_parents = parents.slice();
11144     new_parents.push(this);
11145     var keyword = this.keyword.rewrite(rewriter, new_parents);
11146     var expression = this.expression.rewrite(rewriter, new_parents);
11147     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
11148     if (
11149       keyword === this.keyword &&
11150       expression === this.expression &&
11151       semicolon === this.semicolon)
11152     {
11153       return rewriter(this, parents);
11154     }
11155     else
11156     {
11157       return rewriter(new ThrowStatement(
11158         keyword,
11159         expression,
11160         semicolon), parents);
11161     }
11162   }
11163   static from_json(json, position, source)
11164   {
11165     let keyword = EditableSyntax.from_json(
11166       json.throw_keyword, position, source);
11167     position += keyword.width;
11168     let expression = EditableSyntax.from_json(
11169       json.throw_expression, position, source);
11170     position += expression.width;
11171     let semicolon = EditableSyntax.from_json(
11172       json.throw_semicolon, position, source);
11173     position += semicolon.width;
11174     return new ThrowStatement(
11175         keyword,
11176         expression,
11177         semicolon);
11178   }
11179   get children_keys()
11180   {
11181     if (ThrowStatement._children_keys == null)
11182       ThrowStatement._children_keys = [
11183         'keyword',
11184         'expression',
11185         'semicolon'];
11186     return ThrowStatement._children_keys;
11187   }
11188 }
11189 class BreakStatement extends EditableSyntax
11190 {
11191   constructor(
11192     keyword,
11193     level,
11194     semicolon)
11195   {
11196     super('break_statement', {
11197       keyword: keyword,
11198       level: level,
11199       semicolon: semicolon });
11200   }
11201   get keyword() { return this.children.keyword; }
11202   get level() { return this.children.level; }
11203   get semicolon() { return this.children.semicolon; }
11204   with_keyword(keyword){
11205     return new BreakStatement(
11206       keyword,
11207       this.level,
11208       this.semicolon);
11209   }
11210   with_level(level){
11211     return new BreakStatement(
11212       this.keyword,
11213       level,
11214       this.semicolon);
11215   }
11216   with_semicolon(semicolon){
11217     return new BreakStatement(
11218       this.keyword,
11219       this.level,
11220       semicolon);
11221   }
11222   rewrite(rewriter, parents)
11223   {
11224     if (parents == undefined)
11225       parents = [];
11226     let new_parents = parents.slice();
11227     new_parents.push(this);
11228     var keyword = this.keyword.rewrite(rewriter, new_parents);
11229     var level = this.level.rewrite(rewriter, new_parents);
11230     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
11231     if (
11232       keyword === this.keyword &&
11233       level === this.level &&
11234       semicolon === this.semicolon)
11235     {
11236       return rewriter(this, parents);
11237     }
11238     else
11239     {
11240       return rewriter(new BreakStatement(
11241         keyword,
11242         level,
11243         semicolon), parents);
11244     }
11245   }
11246   static from_json(json, position, source)
11247   {
11248     let keyword = EditableSyntax.from_json(
11249       json.break_keyword, position, source);
11250     position += keyword.width;
11251     let level = EditableSyntax.from_json(
11252       json.break_level, position, source);
11253     position += level.width;
11254     let semicolon = EditableSyntax.from_json(
11255       json.break_semicolon, position, source);
11256     position += semicolon.width;
11257     return new BreakStatement(
11258         keyword,
11259         level,
11260         semicolon);
11261   }
11262   get children_keys()
11263   {
11264     if (BreakStatement._children_keys == null)
11265       BreakStatement._children_keys = [
11266         'keyword',
11267         'level',
11268         'semicolon'];
11269     return BreakStatement._children_keys;
11270   }
11271 }
11272 class ContinueStatement extends EditableSyntax
11273 {
11274   constructor(
11275     keyword,
11276     level,
11277     semicolon)
11278   {
11279     super('continue_statement', {
11280       keyword: keyword,
11281       level: level,
11282       semicolon: semicolon });
11283   }
11284   get keyword() { return this.children.keyword; }
11285   get level() { return this.children.level; }
11286   get semicolon() { return this.children.semicolon; }
11287   with_keyword(keyword){
11288     return new ContinueStatement(
11289       keyword,
11290       this.level,
11291       this.semicolon);
11292   }
11293   with_level(level){
11294     return new ContinueStatement(
11295       this.keyword,
11296       level,
11297       this.semicolon);
11298   }
11299   with_semicolon(semicolon){
11300     return new ContinueStatement(
11301       this.keyword,
11302       this.level,
11303       semicolon);
11304   }
11305   rewrite(rewriter, parents)
11306   {
11307     if (parents == undefined)
11308       parents = [];
11309     let new_parents = parents.slice();
11310     new_parents.push(this);
11311     var keyword = this.keyword.rewrite(rewriter, new_parents);
11312     var level = this.level.rewrite(rewriter, new_parents);
11313     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
11314     if (
11315       keyword === this.keyword &&
11316       level === this.level &&
11317       semicolon === this.semicolon)
11318     {
11319       return rewriter(this, parents);
11320     }
11321     else
11322     {
11323       return rewriter(new ContinueStatement(
11324         keyword,
11325         level,
11326         semicolon), parents);
11327     }
11328   }
11329   static from_json(json, position, source)
11330   {
11331     let keyword = EditableSyntax.from_json(
11332       json.continue_keyword, position, source);
11333     position += keyword.width;
11334     let level = EditableSyntax.from_json(
11335       json.continue_level, position, source);
11336     position += level.width;
11337     let semicolon = EditableSyntax.from_json(
11338       json.continue_semicolon, position, source);
11339     position += semicolon.width;
11340     return new ContinueStatement(
11341         keyword,
11342         level,
11343         semicolon);
11344   }
11345   get children_keys()
11346   {
11347     if (ContinueStatement._children_keys == null)
11348       ContinueStatement._children_keys = [
11349         'keyword',
11350         'level',
11351         'semicolon'];
11352     return ContinueStatement._children_keys;
11353   }
11354 }
11355 class FunctionStaticStatement extends EditableSyntax
11356 {
11357   constructor(
11358     static_keyword,
11359     declarations,
11360     semicolon)
11361   {
11362     super('function_static_statement', {
11363       static_keyword: static_keyword,
11364       declarations: declarations,
11365       semicolon: semicolon });
11366   }
11367   get static_keyword() { return this.children.static_keyword; }
11368   get declarations() { return this.children.declarations; }
11369   get semicolon() { return this.children.semicolon; }
11370   with_static_keyword(static_keyword){
11371     return new FunctionStaticStatement(
11372       static_keyword,
11373       this.declarations,
11374       this.semicolon);
11375   }
11376   with_declarations(declarations){
11377     return new FunctionStaticStatement(
11378       this.static_keyword,
11379       declarations,
11380       this.semicolon);
11381   }
11382   with_semicolon(semicolon){
11383     return new FunctionStaticStatement(
11384       this.static_keyword,
11385       this.declarations,
11386       semicolon);
11387   }
11388   rewrite(rewriter, parents)
11389   {
11390     if (parents == undefined)
11391       parents = [];
11392     let new_parents = parents.slice();
11393     new_parents.push(this);
11394     var static_keyword = this.static_keyword.rewrite(rewriter, new_parents);
11395     var declarations = this.declarations.rewrite(rewriter, new_parents);
11396     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
11397     if (
11398       static_keyword === this.static_keyword &&
11399       declarations === this.declarations &&
11400       semicolon === this.semicolon)
11401     {
11402       return rewriter(this, parents);
11403     }
11404     else
11405     {
11406       return rewriter(new FunctionStaticStatement(
11407         static_keyword,
11408         declarations,
11409         semicolon), parents);
11410     }
11411   }
11412   static from_json(json, position, source)
11413   {
11414     let static_keyword = EditableSyntax.from_json(
11415       json.static_static_keyword, position, source);
11416     position += static_keyword.width;
11417     let declarations = EditableSyntax.from_json(
11418       json.static_declarations, position, source);
11419     position += declarations.width;
11420     let semicolon = EditableSyntax.from_json(
11421       json.static_semicolon, position, source);
11422     position += semicolon.width;
11423     return new FunctionStaticStatement(
11424         static_keyword,
11425         declarations,
11426         semicolon);
11427   }
11428   get children_keys()
11429   {
11430     if (FunctionStaticStatement._children_keys == null)
11431       FunctionStaticStatement._children_keys = [
11432         'static_keyword',
11433         'declarations',
11434         'semicolon'];
11435     return FunctionStaticStatement._children_keys;
11436   }
11437 }
11438 class StaticDeclarator extends EditableSyntax
11439 {
11440   constructor(
11441     name,
11442     initializer)
11443   {
11444     super('static_declarator', {
11445       name: name,
11446       initializer: initializer });
11447   }
11448   get name() { return this.children.name; }
11449   get initializer() { return this.children.initializer; }
11450   with_name(name){
11451     return new StaticDeclarator(
11452       name,
11453       this.initializer);
11454   }
11455   with_initializer(initializer){
11456     return new StaticDeclarator(
11457       this.name,
11458       initializer);
11459   }
11460   rewrite(rewriter, parents)
11461   {
11462     if (parents == undefined)
11463       parents = [];
11464     let new_parents = parents.slice();
11465     new_parents.push(this);
11466     var name = this.name.rewrite(rewriter, new_parents);
11467     var initializer = this.initializer.rewrite(rewriter, new_parents);
11468     if (
11469       name === this.name &&
11470       initializer === this.initializer)
11471     {
11472       return rewriter(this, parents);
11473     }
11474     else
11475     {
11476       return rewriter(new StaticDeclarator(
11477         name,
11478         initializer), parents);
11479     }
11480   }
11481   static from_json(json, position, source)
11482   {
11483     let name = EditableSyntax.from_json(
11484       json.static_name, position, source);
11485     position += name.width;
11486     let initializer = EditableSyntax.from_json(
11487       json.static_initializer, position, source);
11488     position += initializer.width;
11489     return new StaticDeclarator(
11490         name,
11491         initializer);
11492   }
11493   get children_keys()
11494   {
11495     if (StaticDeclarator._children_keys == null)
11496       StaticDeclarator._children_keys = [
11497         'name',
11498         'initializer'];
11499     return StaticDeclarator._children_keys;
11500   }
11501 }
11502 class EchoStatement extends EditableSyntax
11503 {
11504   constructor(
11505     keyword,
11506     expressions,
11507     semicolon)
11508   {
11509     super('echo_statement', {
11510       keyword: keyword,
11511       expressions: expressions,
11512       semicolon: semicolon });
11513   }
11514   get keyword() { return this.children.keyword; }
11515   get expressions() { return this.children.expressions; }
11516   get semicolon() { return this.children.semicolon; }
11517   with_keyword(keyword){
11518     return new EchoStatement(
11519       keyword,
11520       this.expressions,
11521       this.semicolon);
11522   }
11523   with_expressions(expressions){
11524     return new EchoStatement(
11525       this.keyword,
11526       expressions,
11527       this.semicolon);
11528   }
11529   with_semicolon(semicolon){
11530     return new EchoStatement(
11531       this.keyword,
11532       this.expressions,
11533       semicolon);
11534   }
11535   rewrite(rewriter, parents)
11536   {
11537     if (parents == undefined)
11538       parents = [];
11539     let new_parents = parents.slice();
11540     new_parents.push(this);
11541     var keyword = this.keyword.rewrite(rewriter, new_parents);
11542     var expressions = this.expressions.rewrite(rewriter, new_parents);
11543     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
11544     if (
11545       keyword === this.keyword &&
11546       expressions === this.expressions &&
11547       semicolon === this.semicolon)
11548     {
11549       return rewriter(this, parents);
11550     }
11551     else
11552     {
11553       return rewriter(new EchoStatement(
11554         keyword,
11555         expressions,
11556         semicolon), parents);
11557     }
11558   }
11559   static from_json(json, position, source)
11560   {
11561     let keyword = EditableSyntax.from_json(
11562       json.echo_keyword, position, source);
11563     position += keyword.width;
11564     let expressions = EditableSyntax.from_json(
11565       json.echo_expressions, position, source);
11566     position += expressions.width;
11567     let semicolon = EditableSyntax.from_json(
11568       json.echo_semicolon, position, source);
11569     position += semicolon.width;
11570     return new EchoStatement(
11571         keyword,
11572         expressions,
11573         semicolon);
11574   }
11575   get children_keys()
11576   {
11577     if (EchoStatement._children_keys == null)
11578       EchoStatement._children_keys = [
11579         'keyword',
11580         'expressions',
11581         'semicolon'];
11582     return EchoStatement._children_keys;
11583   }
11584 }
11585 class GlobalStatement extends EditableSyntax
11586 {
11587   constructor(
11588     keyword,
11589     variables,
11590     semicolon)
11591   {
11592     super('global_statement', {
11593       keyword: keyword,
11594       variables: variables,
11595       semicolon: semicolon });
11596   }
11597   get keyword() { return this.children.keyword; }
11598   get variables() { return this.children.variables; }
11599   get semicolon() { return this.children.semicolon; }
11600   with_keyword(keyword){
11601     return new GlobalStatement(
11602       keyword,
11603       this.variables,
11604       this.semicolon);
11605   }
11606   with_variables(variables){
11607     return new GlobalStatement(
11608       this.keyword,
11609       variables,
11610       this.semicolon);
11611   }
11612   with_semicolon(semicolon){
11613     return new GlobalStatement(
11614       this.keyword,
11615       this.variables,
11616       semicolon);
11617   }
11618   rewrite(rewriter, parents)
11619   {
11620     if (parents == undefined)
11621       parents = [];
11622     let new_parents = parents.slice();
11623     new_parents.push(this);
11624     var keyword = this.keyword.rewrite(rewriter, new_parents);
11625     var variables = this.variables.rewrite(rewriter, new_parents);
11626     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
11627     if (
11628       keyword === this.keyword &&
11629       variables === this.variables &&
11630       semicolon === this.semicolon)
11631     {
11632       return rewriter(this, parents);
11633     }
11634     else
11635     {
11636       return rewriter(new GlobalStatement(
11637         keyword,
11638         variables,
11639         semicolon), parents);
11640     }
11641   }
11642   static from_json(json, position, source)
11643   {
11644     let keyword = EditableSyntax.from_json(
11645       json.global_keyword, position, source);
11646     position += keyword.width;
11647     let variables = EditableSyntax.from_json(
11648       json.global_variables, position, source);
11649     position += variables.width;
11650     let semicolon = EditableSyntax.from_json(
11651       json.global_semicolon, position, source);
11652     position += semicolon.width;
11653     return new GlobalStatement(
11654         keyword,
11655         variables,
11656         semicolon);
11657   }
11658   get children_keys()
11659   {
11660     if (GlobalStatement._children_keys == null)
11661       GlobalStatement._children_keys = [
11662         'keyword',
11663         'variables',
11664         'semicolon'];
11665     return GlobalStatement._children_keys;
11666   }
11667 }
11668 class SimpleInitializer extends EditableSyntax
11669 {
11670   constructor(
11671     equal,
11672     value)
11673   {
11674     super('simple_initializer', {
11675       equal: equal,
11676       value: value });
11677   }
11678   get equal() { return this.children.equal; }
11679   get value() { return this.children.value; }
11680   with_equal(equal){
11681     return new SimpleInitializer(
11682       equal,
11683       this.value);
11684   }
11685   with_value(value){
11686     return new SimpleInitializer(
11687       this.equal,
11688       value);
11689   }
11690   rewrite(rewriter, parents)
11691   {
11692     if (parents == undefined)
11693       parents = [];
11694     let new_parents = parents.slice();
11695     new_parents.push(this);
11696     var equal = this.equal.rewrite(rewriter, new_parents);
11697     var value = this.value.rewrite(rewriter, new_parents);
11698     if (
11699       equal === this.equal &&
11700       value === this.value)
11701     {
11702       return rewriter(this, parents);
11703     }
11704     else
11705     {
11706       return rewriter(new SimpleInitializer(
11707         equal,
11708         value), parents);
11709     }
11710   }
11711   static from_json(json, position, source)
11712   {
11713     let equal = EditableSyntax.from_json(
11714       json.simple_initializer_equal, position, source);
11715     position += equal.width;
11716     let value = EditableSyntax.from_json(
11717       json.simple_initializer_value, position, source);
11718     position += value.width;
11719     return new SimpleInitializer(
11720         equal,
11721         value);
11722   }
11723   get children_keys()
11724   {
11725     if (SimpleInitializer._children_keys == null)
11726       SimpleInitializer._children_keys = [
11727         'equal',
11728         'value'];
11729     return SimpleInitializer._children_keys;
11730   }
11731 }
11732 class AnonymousClass extends EditableSyntax
11733 {
11734   constructor(
11735     class_keyword,
11736     left_paren,
11737     argument_list,
11738     right_paren,
11739     extends_keyword,
11740     extends_list,
11741     implements_keyword,
11742     implements_list,
11743     body)
11744   {
11745     super('anonymous_class', {
11746       class_keyword: class_keyword,
11747       left_paren: left_paren,
11748       argument_list: argument_list,
11749       right_paren: right_paren,
11750       extends_keyword: extends_keyword,
11751       extends_list: extends_list,
11752       implements_keyword: implements_keyword,
11753       implements_list: implements_list,
11754       body: body });
11755   }
11756   get class_keyword() { return this.children.class_keyword; }
11757   get left_paren() { return this.children.left_paren; }
11758   get argument_list() { return this.children.argument_list; }
11759   get right_paren() { return this.children.right_paren; }
11760   get extends_keyword() { return this.children.extends_keyword; }
11761   get extends_list() { return this.children.extends_list; }
11762   get implements_keyword() { return this.children.implements_keyword; }
11763   get implements_list() { return this.children.implements_list; }
11764   get body() { return this.children.body; }
11765   with_class_keyword(class_keyword){
11766     return new AnonymousClass(
11767       class_keyword,
11768       this.left_paren,
11769       this.argument_list,
11770       this.right_paren,
11771       this.extends_keyword,
11772       this.extends_list,
11773       this.implements_keyword,
11774       this.implements_list,
11775       this.body);
11776   }
11777   with_left_paren(left_paren){
11778     return new AnonymousClass(
11779       this.class_keyword,
11780       left_paren,
11781       this.argument_list,
11782       this.right_paren,
11783       this.extends_keyword,
11784       this.extends_list,
11785       this.implements_keyword,
11786       this.implements_list,
11787       this.body);
11788   }
11789   with_argument_list(argument_list){
11790     return new AnonymousClass(
11791       this.class_keyword,
11792       this.left_paren,
11793       argument_list,
11794       this.right_paren,
11795       this.extends_keyword,
11796       this.extends_list,
11797       this.implements_keyword,
11798       this.implements_list,
11799       this.body);
11800   }
11801   with_right_paren(right_paren){
11802     return new AnonymousClass(
11803       this.class_keyword,
11804       this.left_paren,
11805       this.argument_list,
11806       right_paren,
11807       this.extends_keyword,
11808       this.extends_list,
11809       this.implements_keyword,
11810       this.implements_list,
11811       this.body);
11812   }
11813   with_extends_keyword(extends_keyword){
11814     return new AnonymousClass(
11815       this.class_keyword,
11816       this.left_paren,
11817       this.argument_list,
11818       this.right_paren,
11819       extends_keyword,
11820       this.extends_list,
11821       this.implements_keyword,
11822       this.implements_list,
11823       this.body);
11824   }
11825   with_extends_list(extends_list){
11826     return new AnonymousClass(
11827       this.class_keyword,
11828       this.left_paren,
11829       this.argument_list,
11830       this.right_paren,
11831       this.extends_keyword,
11832       extends_list,
11833       this.implements_keyword,
11834       this.implements_list,
11835       this.body);
11836   }
11837   with_implements_keyword(implements_keyword){
11838     return new AnonymousClass(
11839       this.class_keyword,
11840       this.left_paren,
11841       this.argument_list,
11842       this.right_paren,
11843       this.extends_keyword,
11844       this.extends_list,
11845       implements_keyword,
11846       this.implements_list,
11847       this.body);
11848   }
11849   with_implements_list(implements_list){
11850     return new AnonymousClass(
11851       this.class_keyword,
11852       this.left_paren,
11853       this.argument_list,
11854       this.right_paren,
11855       this.extends_keyword,
11856       this.extends_list,
11857       this.implements_keyword,
11858       implements_list,
11859       this.body);
11860   }
11861   with_body(body){
11862     return new AnonymousClass(
11863       this.class_keyword,
11864       this.left_paren,
11865       this.argument_list,
11866       this.right_paren,
11867       this.extends_keyword,
11868       this.extends_list,
11869       this.implements_keyword,
11870       this.implements_list,
11871       body);
11872   }
11873   rewrite(rewriter, parents)
11874   {
11875     if (parents == undefined)
11876       parents = [];
11877     let new_parents = parents.slice();
11878     new_parents.push(this);
11879     var class_keyword = this.class_keyword.rewrite(rewriter, new_parents);
11880     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
11881     var argument_list = this.argument_list.rewrite(rewriter, new_parents);
11882     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
11883     var extends_keyword = this.extends_keyword.rewrite(rewriter, new_parents);
11884     var extends_list = this.extends_list.rewrite(rewriter, new_parents);
11885     var implements_keyword = this.implements_keyword.rewrite(rewriter, new_parents);
11886     var implements_list = this.implements_list.rewrite(rewriter, new_parents);
11887     var body = this.body.rewrite(rewriter, new_parents);
11888     if (
11889       class_keyword === this.class_keyword &&
11890       left_paren === this.left_paren &&
11891       argument_list === this.argument_list &&
11892       right_paren === this.right_paren &&
11893       extends_keyword === this.extends_keyword &&
11894       extends_list === this.extends_list &&
11895       implements_keyword === this.implements_keyword &&
11896       implements_list === this.implements_list &&
11897       body === this.body)
11898     {
11899       return rewriter(this, parents);
11900     }
11901     else
11902     {
11903       return rewriter(new AnonymousClass(
11904         class_keyword,
11905         left_paren,
11906         argument_list,
11907         right_paren,
11908         extends_keyword,
11909         extends_list,
11910         implements_keyword,
11911         implements_list,
11912         body), parents);
11913     }
11914   }
11915   static from_json(json, position, source)
11916   {
11917     let class_keyword = EditableSyntax.from_json(
11918       json.anonymous_class_class_keyword, position, source);
11919     position += class_keyword.width;
11920     let left_paren = EditableSyntax.from_json(
11921       json.anonymous_class_left_paren, position, source);
11922     position += left_paren.width;
11923     let argument_list = EditableSyntax.from_json(
11924       json.anonymous_class_argument_list, position, source);
11925     position += argument_list.width;
11926     let right_paren = EditableSyntax.from_json(
11927       json.anonymous_class_right_paren, position, source);
11928     position += right_paren.width;
11929     let extends_keyword = EditableSyntax.from_json(
11930       json.anonymous_class_extends_keyword, position, source);
11931     position += extends_keyword.width;
11932     let extends_list = EditableSyntax.from_json(
11933       json.anonymous_class_extends_list, position, source);
11934     position += extends_list.width;
11935     let implements_keyword = EditableSyntax.from_json(
11936       json.anonymous_class_implements_keyword, position, source);
11937     position += implements_keyword.width;
11938     let implements_list = EditableSyntax.from_json(
11939       json.anonymous_class_implements_list, position, source);
11940     position += implements_list.width;
11941     let body = EditableSyntax.from_json(
11942       json.anonymous_class_body, position, source);
11943     position += body.width;
11944     return new AnonymousClass(
11945         class_keyword,
11946         left_paren,
11947         argument_list,
11948         right_paren,
11949         extends_keyword,
11950         extends_list,
11951         implements_keyword,
11952         implements_list,
11953         body);
11954   }
11955   get children_keys()
11956   {
11957     if (AnonymousClass._children_keys == null)
11958       AnonymousClass._children_keys = [
11959         'class_keyword',
11960         'left_paren',
11961         'argument_list',
11962         'right_paren',
11963         'extends_keyword',
11964         'extends_list',
11965         'implements_keyword',
11966         'implements_list',
11967         'body'];
11968     return AnonymousClass._children_keys;
11969   }
11970 }
11971 class AnonymousFunction extends EditableSyntax
11972 {
11973   constructor(
11974     static_keyword,
11975     async_keyword,
11976     coroutine_keyword,
11977     function_keyword,
11978     left_paren,
11979     parameters,
11980     right_paren,
11981     colon,
11982     type,
11983     use,
11984     body)
11985   {
11986     super('anonymous_function', {
11987       static_keyword: static_keyword,
11988       async_keyword: async_keyword,
11989       coroutine_keyword: coroutine_keyword,
11990       function_keyword: function_keyword,
11991       left_paren: left_paren,
11992       parameters: parameters,
11993       right_paren: right_paren,
11994       colon: colon,
11995       type: type,
11996       use: use,
11997       body: body });
11998   }
11999   get static_keyword() { return this.children.static_keyword; }
12000   get async_keyword() { return this.children.async_keyword; }
12001   get coroutine_keyword() { return this.children.coroutine_keyword; }
12002   get function_keyword() { return this.children.function_keyword; }
12003   get left_paren() { return this.children.left_paren; }
12004   get parameters() { return this.children.parameters; }
12005   get right_paren() { return this.children.right_paren; }
12006   get colon() { return this.children.colon; }
12007   get type() { return this.children.type; }
12008   get use() { return this.children.use; }
12009   get body() { return this.children.body; }
12010   with_static_keyword(static_keyword){
12011     return new AnonymousFunction(
12012       static_keyword,
12013       this.async_keyword,
12014       this.coroutine_keyword,
12015       this.function_keyword,
12016       this.left_paren,
12017       this.parameters,
12018       this.right_paren,
12019       this.colon,
12020       this.type,
12021       this.use,
12022       this.body);
12023   }
12024   with_async_keyword(async_keyword){
12025     return new AnonymousFunction(
12026       this.static_keyword,
12027       async_keyword,
12028       this.coroutine_keyword,
12029       this.function_keyword,
12030       this.left_paren,
12031       this.parameters,
12032       this.right_paren,
12033       this.colon,
12034       this.type,
12035       this.use,
12036       this.body);
12037   }
12038   with_coroutine_keyword(coroutine_keyword){
12039     return new AnonymousFunction(
12040       this.static_keyword,
12041       this.async_keyword,
12042       coroutine_keyword,
12043       this.function_keyword,
12044       this.left_paren,
12045       this.parameters,
12046       this.right_paren,
12047       this.colon,
12048       this.type,
12049       this.use,
12050       this.body);
12051   }
12052   with_function_keyword(function_keyword){
12053     return new AnonymousFunction(
12054       this.static_keyword,
12055       this.async_keyword,
12056       this.coroutine_keyword,
12057       function_keyword,
12058       this.left_paren,
12059       this.parameters,
12060       this.right_paren,
12061       this.colon,
12062       this.type,
12063       this.use,
12064       this.body);
12065   }
12066   with_left_paren(left_paren){
12067     return new AnonymousFunction(
12068       this.static_keyword,
12069       this.async_keyword,
12070       this.coroutine_keyword,
12071       this.function_keyword,
12072       left_paren,
12073       this.parameters,
12074       this.right_paren,
12075       this.colon,
12076       this.type,
12077       this.use,
12078       this.body);
12079   }
12080   with_parameters(parameters){
12081     return new AnonymousFunction(
12082       this.static_keyword,
12083       this.async_keyword,
12084       this.coroutine_keyword,
12085       this.function_keyword,
12086       this.left_paren,
12087       parameters,
12088       this.right_paren,
12089       this.colon,
12090       this.type,
12091       this.use,
12092       this.body);
12093   }
12094   with_right_paren(right_paren){
12095     return new AnonymousFunction(
12096       this.static_keyword,
12097       this.async_keyword,
12098       this.coroutine_keyword,
12099       this.function_keyword,
12100       this.left_paren,
12101       this.parameters,
12102       right_paren,
12103       this.colon,
12104       this.type,
12105       this.use,
12106       this.body);
12107   }
12108   with_colon(colon){
12109     return new AnonymousFunction(
12110       this.static_keyword,
12111       this.async_keyword,
12112       this.coroutine_keyword,
12113       this.function_keyword,
12114       this.left_paren,
12115       this.parameters,
12116       this.right_paren,
12117       colon,
12118       this.type,
12119       this.use,
12120       this.body);
12121   }
12122   with_type(type){
12123     return new AnonymousFunction(
12124       this.static_keyword,
12125       this.async_keyword,
12126       this.coroutine_keyword,
12127       this.function_keyword,
12128       this.left_paren,
12129       this.parameters,
12130       this.right_paren,
12131       this.colon,
12132       type,
12133       this.use,
12134       this.body);
12135   }
12136   with_use(use){
12137     return new AnonymousFunction(
12138       this.static_keyword,
12139       this.async_keyword,
12140       this.coroutine_keyword,
12141       this.function_keyword,
12142       this.left_paren,
12143       this.parameters,
12144       this.right_paren,
12145       this.colon,
12146       this.type,
12147       use,
12148       this.body);
12149   }
12150   with_body(body){
12151     return new AnonymousFunction(
12152       this.static_keyword,
12153       this.async_keyword,
12154       this.coroutine_keyword,
12155       this.function_keyword,
12156       this.left_paren,
12157       this.parameters,
12158       this.right_paren,
12159       this.colon,
12160       this.type,
12161       this.use,
12162       body);
12163   }
12164   rewrite(rewriter, parents)
12165   {
12166     if (parents == undefined)
12167       parents = [];
12168     let new_parents = parents.slice();
12169     new_parents.push(this);
12170     var static_keyword = this.static_keyword.rewrite(rewriter, new_parents);
12171     var async_keyword = this.async_keyword.rewrite(rewriter, new_parents);
12172     var coroutine_keyword = this.coroutine_keyword.rewrite(rewriter, new_parents);
12173     var function_keyword = this.function_keyword.rewrite(rewriter, new_parents);
12174     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
12175     var parameters = this.parameters.rewrite(rewriter, new_parents);
12176     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
12177     var colon = this.colon.rewrite(rewriter, new_parents);
12178     var type = this.type.rewrite(rewriter, new_parents);
12179     var use = this.use.rewrite(rewriter, new_parents);
12180     var body = this.body.rewrite(rewriter, new_parents);
12181     if (
12182       static_keyword === this.static_keyword &&
12183       async_keyword === this.async_keyword &&
12184       coroutine_keyword === this.coroutine_keyword &&
12185       function_keyword === this.function_keyword &&
12186       left_paren === this.left_paren &&
12187       parameters === this.parameters &&
12188       right_paren === this.right_paren &&
12189       colon === this.colon &&
12190       type === this.type &&
12191       use === this.use &&
12192       body === this.body)
12193     {
12194       return rewriter(this, parents);
12195     }
12196     else
12197     {
12198       return rewriter(new AnonymousFunction(
12199         static_keyword,
12200         async_keyword,
12201         coroutine_keyword,
12202         function_keyword,
12203         left_paren,
12204         parameters,
12205         right_paren,
12206         colon,
12207         type,
12208         use,
12209         body), parents);
12210     }
12211   }
12212   static from_json(json, position, source)
12213   {
12214     let static_keyword = EditableSyntax.from_json(
12215       json.anonymous_static_keyword, position, source);
12216     position += static_keyword.width;
12217     let async_keyword = EditableSyntax.from_json(
12218       json.anonymous_async_keyword, position, source);
12219     position += async_keyword.width;
12220     let coroutine_keyword = EditableSyntax.from_json(
12221       json.anonymous_coroutine_keyword, position, source);
12222     position += coroutine_keyword.width;
12223     let function_keyword = EditableSyntax.from_json(
12224       json.anonymous_function_keyword, position, source);
12225     position += function_keyword.width;
12226     let left_paren = EditableSyntax.from_json(
12227       json.anonymous_left_paren, position, source);
12228     position += left_paren.width;
12229     let parameters = EditableSyntax.from_json(
12230       json.anonymous_parameters, position, source);
12231     position += parameters.width;
12232     let right_paren = EditableSyntax.from_json(
12233       json.anonymous_right_paren, position, source);
12234     position += right_paren.width;
12235     let colon = EditableSyntax.from_json(
12236       json.anonymous_colon, position, source);
12237     position += colon.width;
12238     let type = EditableSyntax.from_json(
12239       json.anonymous_type, position, source);
12240     position += type.width;
12241     let use = EditableSyntax.from_json(
12242       json.anonymous_use, position, source);
12243     position += use.width;
12244     let body = EditableSyntax.from_json(
12245       json.anonymous_body, position, source);
12246     position += body.width;
12247     return new AnonymousFunction(
12248         static_keyword,
12249         async_keyword,
12250         coroutine_keyword,
12251         function_keyword,
12252         left_paren,
12253         parameters,
12254         right_paren,
12255         colon,
12256         type,
12257         use,
12258         body);
12259   }
12260   get children_keys()
12261   {
12262     if (AnonymousFunction._children_keys == null)
12263       AnonymousFunction._children_keys = [
12264         'static_keyword',
12265         'async_keyword',
12266         'coroutine_keyword',
12267         'function_keyword',
12268         'left_paren',
12269         'parameters',
12270         'right_paren',
12271         'colon',
12272         'type',
12273         'use',
12274         'body'];
12275     return AnonymousFunction._children_keys;
12276   }
12277 }
12278 class Php7AnonymousFunction extends EditableSyntax
12279 {
12280   constructor(
12281     static_keyword,
12282     async_keyword,
12283     coroutine_keyword,
12284     function_keyword,
12285     left_paren,
12286     parameters,
12287     right_paren,
12288     use,
12289     colon,
12290     type,
12291     body)
12292   {
12293     super('php7_anonymous_function', {
12294       static_keyword: static_keyword,
12295       async_keyword: async_keyword,
12296       coroutine_keyword: coroutine_keyword,
12297       function_keyword: function_keyword,
12298       left_paren: left_paren,
12299       parameters: parameters,
12300       right_paren: right_paren,
12301       use: use,
12302       colon: colon,
12303       type: type,
12304       body: body });
12305   }
12306   get static_keyword() { return this.children.static_keyword; }
12307   get async_keyword() { return this.children.async_keyword; }
12308   get coroutine_keyword() { return this.children.coroutine_keyword; }
12309   get function_keyword() { return this.children.function_keyword; }
12310   get left_paren() { return this.children.left_paren; }
12311   get parameters() { return this.children.parameters; }
12312   get right_paren() { return this.children.right_paren; }
12313   get use() { return this.children.use; }
12314   get colon() { return this.children.colon; }
12315   get type() { return this.children.type; }
12316   get body() { return this.children.body; }
12317   with_static_keyword(static_keyword){
12318     return new Php7AnonymousFunction(
12319       static_keyword,
12320       this.async_keyword,
12321       this.coroutine_keyword,
12322       this.function_keyword,
12323       this.left_paren,
12324       this.parameters,
12325       this.right_paren,
12326       this.use,
12327       this.colon,
12328       this.type,
12329       this.body);
12330   }
12331   with_async_keyword(async_keyword){
12332     return new Php7AnonymousFunction(
12333       this.static_keyword,
12334       async_keyword,
12335       this.coroutine_keyword,
12336       this.function_keyword,
12337       this.left_paren,
12338       this.parameters,
12339       this.right_paren,
12340       this.use,
12341       this.colon,
12342       this.type,
12343       this.body);
12344   }
12345   with_coroutine_keyword(coroutine_keyword){
12346     return new Php7AnonymousFunction(
12347       this.static_keyword,
12348       this.async_keyword,
12349       coroutine_keyword,
12350       this.function_keyword,
12351       this.left_paren,
12352       this.parameters,
12353       this.right_paren,
12354       this.use,
12355       this.colon,
12356       this.type,
12357       this.body);
12358   }
12359   with_function_keyword(function_keyword){
12360     return new Php7AnonymousFunction(
12361       this.static_keyword,
12362       this.async_keyword,
12363       this.coroutine_keyword,
12364       function_keyword,
12365       this.left_paren,
12366       this.parameters,
12367       this.right_paren,
12368       this.use,
12369       this.colon,
12370       this.type,
12371       this.body);
12372   }
12373   with_left_paren(left_paren){
12374     return new Php7AnonymousFunction(
12375       this.static_keyword,
12376       this.async_keyword,
12377       this.coroutine_keyword,
12378       this.function_keyword,
12379       left_paren,
12380       this.parameters,
12381       this.right_paren,
12382       this.use,
12383       this.colon,
12384       this.type,
12385       this.body);
12386   }
12387   with_parameters(parameters){
12388     return new Php7AnonymousFunction(
12389       this.static_keyword,
12390       this.async_keyword,
12391       this.coroutine_keyword,
12392       this.function_keyword,
12393       this.left_paren,
12394       parameters,
12395       this.right_paren,
12396       this.use,
12397       this.colon,
12398       this.type,
12399       this.body);
12400   }
12401   with_right_paren(right_paren){
12402     return new Php7AnonymousFunction(
12403       this.static_keyword,
12404       this.async_keyword,
12405       this.coroutine_keyword,
12406       this.function_keyword,
12407       this.left_paren,
12408       this.parameters,
12409       right_paren,
12410       this.use,
12411       this.colon,
12412       this.type,
12413       this.body);
12414   }
12415   with_use(use){
12416     return new Php7AnonymousFunction(
12417       this.static_keyword,
12418       this.async_keyword,
12419       this.coroutine_keyword,
12420       this.function_keyword,
12421       this.left_paren,
12422       this.parameters,
12423       this.right_paren,
12424       use,
12425       this.colon,
12426       this.type,
12427       this.body);
12428   }
12429   with_colon(colon){
12430     return new Php7AnonymousFunction(
12431       this.static_keyword,
12432       this.async_keyword,
12433       this.coroutine_keyword,
12434       this.function_keyword,
12435       this.left_paren,
12436       this.parameters,
12437       this.right_paren,
12438       this.use,
12439       colon,
12440       this.type,
12441       this.body);
12442   }
12443   with_type(type){
12444     return new Php7AnonymousFunction(
12445       this.static_keyword,
12446       this.async_keyword,
12447       this.coroutine_keyword,
12448       this.function_keyword,
12449       this.left_paren,
12450       this.parameters,
12451       this.right_paren,
12452       this.use,
12453       this.colon,
12454       type,
12455       this.body);
12456   }
12457   with_body(body){
12458     return new Php7AnonymousFunction(
12459       this.static_keyword,
12460       this.async_keyword,
12461       this.coroutine_keyword,
12462       this.function_keyword,
12463       this.left_paren,
12464       this.parameters,
12465       this.right_paren,
12466       this.use,
12467       this.colon,
12468       this.type,
12469       body);
12470   }
12471   rewrite(rewriter, parents)
12472   {
12473     if (parents == undefined)
12474       parents = [];
12475     let new_parents = parents.slice();
12476     new_parents.push(this);
12477     var static_keyword = this.static_keyword.rewrite(rewriter, new_parents);
12478     var async_keyword = this.async_keyword.rewrite(rewriter, new_parents);
12479     var coroutine_keyword = this.coroutine_keyword.rewrite(rewriter, new_parents);
12480     var function_keyword = this.function_keyword.rewrite(rewriter, new_parents);
12481     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
12482     var parameters = this.parameters.rewrite(rewriter, new_parents);
12483     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
12484     var use = this.use.rewrite(rewriter, new_parents);
12485     var colon = this.colon.rewrite(rewriter, new_parents);
12486     var type = this.type.rewrite(rewriter, new_parents);
12487     var body = this.body.rewrite(rewriter, new_parents);
12488     if (
12489       static_keyword === this.static_keyword &&
12490       async_keyword === this.async_keyword &&
12491       coroutine_keyword === this.coroutine_keyword &&
12492       function_keyword === this.function_keyword &&
12493       left_paren === this.left_paren &&
12494       parameters === this.parameters &&
12495       right_paren === this.right_paren &&
12496       use === this.use &&
12497       colon === this.colon &&
12498       type === this.type &&
12499       body === this.body)
12500     {
12501       return rewriter(this, parents);
12502     }
12503     else
12504     {
12505       return rewriter(new Php7AnonymousFunction(
12506         static_keyword,
12507         async_keyword,
12508         coroutine_keyword,
12509         function_keyword,
12510         left_paren,
12511         parameters,
12512         right_paren,
12513         use,
12514         colon,
12515         type,
12516         body), parents);
12517     }
12518   }
12519   static from_json(json, position, source)
12520   {
12521     let static_keyword = EditableSyntax.from_json(
12522       json.php7_anonymous_static_keyword, position, source);
12523     position += static_keyword.width;
12524     let async_keyword = EditableSyntax.from_json(
12525       json.php7_anonymous_async_keyword, position, source);
12526     position += async_keyword.width;
12527     let coroutine_keyword = EditableSyntax.from_json(
12528       json.php7_anonymous_coroutine_keyword, position, source);
12529     position += coroutine_keyword.width;
12530     let function_keyword = EditableSyntax.from_json(
12531       json.php7_anonymous_function_keyword, position, source);
12532     position += function_keyword.width;
12533     let left_paren = EditableSyntax.from_json(
12534       json.php7_anonymous_left_paren, position, source);
12535     position += left_paren.width;
12536     let parameters = EditableSyntax.from_json(
12537       json.php7_anonymous_parameters, position, source);
12538     position += parameters.width;
12539     let right_paren = EditableSyntax.from_json(
12540       json.php7_anonymous_right_paren, position, source);
12541     position += right_paren.width;
12542     let use = EditableSyntax.from_json(
12543       json.php7_anonymous_use, position, source);
12544     position += use.width;
12545     let colon = EditableSyntax.from_json(
12546       json.php7_anonymous_colon, position, source);
12547     position += colon.width;
12548     let type = EditableSyntax.from_json(
12549       json.php7_anonymous_type, position, source);
12550     position += type.width;
12551     let body = EditableSyntax.from_json(
12552       json.php7_anonymous_body, position, source);
12553     position += body.width;
12554     return new Php7AnonymousFunction(
12555         static_keyword,
12556         async_keyword,
12557         coroutine_keyword,
12558         function_keyword,
12559         left_paren,
12560         parameters,
12561         right_paren,
12562         use,
12563         colon,
12564         type,
12565         body);
12566   }
12567   get children_keys()
12568   {
12569     if (Php7AnonymousFunction._children_keys == null)
12570       Php7AnonymousFunction._children_keys = [
12571         'static_keyword',
12572         'async_keyword',
12573         'coroutine_keyword',
12574         'function_keyword',
12575         'left_paren',
12576         'parameters',
12577         'right_paren',
12578         'use',
12579         'colon',
12580         'type',
12581         'body'];
12582     return Php7AnonymousFunction._children_keys;
12583   }
12584 }
12585 class AnonymousFunctionUseClause extends EditableSyntax
12586 {
12587   constructor(
12588     keyword,
12589     left_paren,
12590     variables,
12591     right_paren)
12592   {
12593     super('anonymous_function_use_clause', {
12594       keyword: keyword,
12595       left_paren: left_paren,
12596       variables: variables,
12597       right_paren: right_paren });
12598   }
12599   get keyword() { return this.children.keyword; }
12600   get left_paren() { return this.children.left_paren; }
12601   get variables() { return this.children.variables; }
12602   get right_paren() { return this.children.right_paren; }
12603   with_keyword(keyword){
12604     return new AnonymousFunctionUseClause(
12605       keyword,
12606       this.left_paren,
12607       this.variables,
12608       this.right_paren);
12609   }
12610   with_left_paren(left_paren){
12611     return new AnonymousFunctionUseClause(
12612       this.keyword,
12613       left_paren,
12614       this.variables,
12615       this.right_paren);
12616   }
12617   with_variables(variables){
12618     return new AnonymousFunctionUseClause(
12619       this.keyword,
12620       this.left_paren,
12621       variables,
12622       this.right_paren);
12623   }
12624   with_right_paren(right_paren){
12625     return new AnonymousFunctionUseClause(
12626       this.keyword,
12627       this.left_paren,
12628       this.variables,
12629       right_paren);
12630   }
12631   rewrite(rewriter, parents)
12632   {
12633     if (parents == undefined)
12634       parents = [];
12635     let new_parents = parents.slice();
12636     new_parents.push(this);
12637     var keyword = this.keyword.rewrite(rewriter, new_parents);
12638     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
12639     var variables = this.variables.rewrite(rewriter, new_parents);
12640     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
12641     if (
12642       keyword === this.keyword &&
12643       left_paren === this.left_paren &&
12644       variables === this.variables &&
12645       right_paren === this.right_paren)
12646     {
12647       return rewriter(this, parents);
12648     }
12649     else
12650     {
12651       return rewriter(new AnonymousFunctionUseClause(
12652         keyword,
12653         left_paren,
12654         variables,
12655         right_paren), parents);
12656     }
12657   }
12658   static from_json(json, position, source)
12659   {
12660     let keyword = EditableSyntax.from_json(
12661       json.anonymous_use_keyword, position, source);
12662     position += keyword.width;
12663     let left_paren = EditableSyntax.from_json(
12664       json.anonymous_use_left_paren, position, source);
12665     position += left_paren.width;
12666     let variables = EditableSyntax.from_json(
12667       json.anonymous_use_variables, position, source);
12668     position += variables.width;
12669     let right_paren = EditableSyntax.from_json(
12670       json.anonymous_use_right_paren, position, source);
12671     position += right_paren.width;
12672     return new AnonymousFunctionUseClause(
12673         keyword,
12674         left_paren,
12675         variables,
12676         right_paren);
12677   }
12678   get children_keys()
12679   {
12680     if (AnonymousFunctionUseClause._children_keys == null)
12681       AnonymousFunctionUseClause._children_keys = [
12682         'keyword',
12683         'left_paren',
12684         'variables',
12685         'right_paren'];
12686     return AnonymousFunctionUseClause._children_keys;
12687   }
12688 }
12689 class LambdaExpression extends EditableSyntax
12690 {
12691   constructor(
12692     async,
12693     coroutine,
12694     signature,
12695     arrow,
12696     body)
12697   {
12698     super('lambda_expression', {
12699       async: async,
12700       coroutine: coroutine,
12701       signature: signature,
12702       arrow: arrow,
12703       body: body });
12704   }
12705   get async() { return this.children.async; }
12706   get coroutine() { return this.children.coroutine; }
12707   get signature() { return this.children.signature; }
12708   get arrow() { return this.children.arrow; }
12709   get body() { return this.children.body; }
12710   with_async(async){
12711     return new LambdaExpression(
12712       async,
12713       this.coroutine,
12714       this.signature,
12715       this.arrow,
12716       this.body);
12717   }
12718   with_coroutine(coroutine){
12719     return new LambdaExpression(
12720       this.async,
12721       coroutine,
12722       this.signature,
12723       this.arrow,
12724       this.body);
12725   }
12726   with_signature(signature){
12727     return new LambdaExpression(
12728       this.async,
12729       this.coroutine,
12730       signature,
12731       this.arrow,
12732       this.body);
12733   }
12734   with_arrow(arrow){
12735     return new LambdaExpression(
12736       this.async,
12737       this.coroutine,
12738       this.signature,
12739       arrow,
12740       this.body);
12741   }
12742   with_body(body){
12743     return new LambdaExpression(
12744       this.async,
12745       this.coroutine,
12746       this.signature,
12747       this.arrow,
12748       body);
12749   }
12750   rewrite(rewriter, parents)
12751   {
12752     if (parents == undefined)
12753       parents = [];
12754     let new_parents = parents.slice();
12755     new_parents.push(this);
12756     var async = this.async.rewrite(rewriter, new_parents);
12757     var coroutine = this.coroutine.rewrite(rewriter, new_parents);
12758     var signature = this.signature.rewrite(rewriter, new_parents);
12759     var arrow = this.arrow.rewrite(rewriter, new_parents);
12760     var body = this.body.rewrite(rewriter, new_parents);
12761     if (
12762       async === this.async &&
12763       coroutine === this.coroutine &&
12764       signature === this.signature &&
12765       arrow === this.arrow &&
12766       body === this.body)
12767     {
12768       return rewriter(this, parents);
12769     }
12770     else
12771     {
12772       return rewriter(new LambdaExpression(
12773         async,
12774         coroutine,
12775         signature,
12776         arrow,
12777         body), parents);
12778     }
12779   }
12780   static from_json(json, position, source)
12781   {
12782     let async = EditableSyntax.from_json(
12783       json.lambda_async, position, source);
12784     position += async.width;
12785     let coroutine = EditableSyntax.from_json(
12786       json.lambda_coroutine, position, source);
12787     position += coroutine.width;
12788     let signature = EditableSyntax.from_json(
12789       json.lambda_signature, position, source);
12790     position += signature.width;
12791     let arrow = EditableSyntax.from_json(
12792       json.lambda_arrow, position, source);
12793     position += arrow.width;
12794     let body = EditableSyntax.from_json(
12795       json.lambda_body, position, source);
12796     position += body.width;
12797     return new LambdaExpression(
12798         async,
12799         coroutine,
12800         signature,
12801         arrow,
12802         body);
12803   }
12804   get children_keys()
12805   {
12806     if (LambdaExpression._children_keys == null)
12807       LambdaExpression._children_keys = [
12808         'async',
12809         'coroutine',
12810         'signature',
12811         'arrow',
12812         'body'];
12813     return LambdaExpression._children_keys;
12814   }
12815 }
12816 class LambdaSignature extends EditableSyntax
12817 {
12818   constructor(
12819     left_paren,
12820     parameters,
12821     right_paren,
12822     colon,
12823     type)
12824   {
12825     super('lambda_signature', {
12826       left_paren: left_paren,
12827       parameters: parameters,
12828       right_paren: right_paren,
12829       colon: colon,
12830       type: type });
12831   }
12832   get left_paren() { return this.children.left_paren; }
12833   get parameters() { return this.children.parameters; }
12834   get right_paren() { return this.children.right_paren; }
12835   get colon() { return this.children.colon; }
12836   get type() { return this.children.type; }
12837   with_left_paren(left_paren){
12838     return new LambdaSignature(
12839       left_paren,
12840       this.parameters,
12841       this.right_paren,
12842       this.colon,
12843       this.type);
12844   }
12845   with_parameters(parameters){
12846     return new LambdaSignature(
12847       this.left_paren,
12848       parameters,
12849       this.right_paren,
12850       this.colon,
12851       this.type);
12852   }
12853   with_right_paren(right_paren){
12854     return new LambdaSignature(
12855       this.left_paren,
12856       this.parameters,
12857       right_paren,
12858       this.colon,
12859       this.type);
12860   }
12861   with_colon(colon){
12862     return new LambdaSignature(
12863       this.left_paren,
12864       this.parameters,
12865       this.right_paren,
12866       colon,
12867       this.type);
12868   }
12869   with_type(type){
12870     return new LambdaSignature(
12871       this.left_paren,
12872       this.parameters,
12873       this.right_paren,
12874       this.colon,
12875       type);
12876   }
12877   rewrite(rewriter, parents)
12878   {
12879     if (parents == undefined)
12880       parents = [];
12881     let new_parents = parents.slice();
12882     new_parents.push(this);
12883     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
12884     var parameters = this.parameters.rewrite(rewriter, new_parents);
12885     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
12886     var colon = this.colon.rewrite(rewriter, new_parents);
12887     var type = this.type.rewrite(rewriter, new_parents);
12888     if (
12889       left_paren === this.left_paren &&
12890       parameters === this.parameters &&
12891       right_paren === this.right_paren &&
12892       colon === this.colon &&
12893       type === this.type)
12894     {
12895       return rewriter(this, parents);
12896     }
12897     else
12898     {
12899       return rewriter(new LambdaSignature(
12900         left_paren,
12901         parameters,
12902         right_paren,
12903         colon,
12904         type), parents);
12905     }
12906   }
12907   static from_json(json, position, source)
12908   {
12909     let left_paren = EditableSyntax.from_json(
12910       json.lambda_left_paren, position, source);
12911     position += left_paren.width;
12912     let parameters = EditableSyntax.from_json(
12913       json.lambda_parameters, position, source);
12914     position += parameters.width;
12915     let right_paren = EditableSyntax.from_json(
12916       json.lambda_right_paren, position, source);
12917     position += right_paren.width;
12918     let colon = EditableSyntax.from_json(
12919       json.lambda_colon, position, source);
12920     position += colon.width;
12921     let type = EditableSyntax.from_json(
12922       json.lambda_type, position, source);
12923     position += type.width;
12924     return new LambdaSignature(
12925         left_paren,
12926         parameters,
12927         right_paren,
12928         colon,
12929         type);
12930   }
12931   get children_keys()
12932   {
12933     if (LambdaSignature._children_keys == null)
12934       LambdaSignature._children_keys = [
12935         'left_paren',
12936         'parameters',
12937         'right_paren',
12938         'colon',
12939         'type'];
12940     return LambdaSignature._children_keys;
12941   }
12942 }
12943 class CastExpression extends EditableSyntax
12944 {
12945   constructor(
12946     left_paren,
12947     type,
12948     right_paren,
12949     operand)
12950   {
12951     super('cast_expression', {
12952       left_paren: left_paren,
12953       type: type,
12954       right_paren: right_paren,
12955       operand: operand });
12956   }
12957   get left_paren() { return this.children.left_paren; }
12958   get type() { return this.children.type; }
12959   get right_paren() { return this.children.right_paren; }
12960   get operand() { return this.children.operand; }
12961   with_left_paren(left_paren){
12962     return new CastExpression(
12963       left_paren,
12964       this.type,
12965       this.right_paren,
12966       this.operand);
12967   }
12968   with_type(type){
12969     return new CastExpression(
12970       this.left_paren,
12971       type,
12972       this.right_paren,
12973       this.operand);
12974   }
12975   with_right_paren(right_paren){
12976     return new CastExpression(
12977       this.left_paren,
12978       this.type,
12979       right_paren,
12980       this.operand);
12981   }
12982   with_operand(operand){
12983     return new CastExpression(
12984       this.left_paren,
12985       this.type,
12986       this.right_paren,
12987       operand);
12988   }
12989   rewrite(rewriter, parents)
12990   {
12991     if (parents == undefined)
12992       parents = [];
12993     let new_parents = parents.slice();
12994     new_parents.push(this);
12995     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
12996     var type = this.type.rewrite(rewriter, new_parents);
12997     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
12998     var operand = this.operand.rewrite(rewriter, new_parents);
12999     if (
13000       left_paren === this.left_paren &&
13001       type === this.type &&
13002       right_paren === this.right_paren &&
13003       operand === this.operand)
13004     {
13005       return rewriter(this, parents);
13006     }
13007     else
13008     {
13009       return rewriter(new CastExpression(
13010         left_paren,
13011         type,
13012         right_paren,
13013         operand), parents);
13014     }
13015   }
13016   static from_json(json, position, source)
13017   {
13018     let left_paren = EditableSyntax.from_json(
13019       json.cast_left_paren, position, source);
13020     position += left_paren.width;
13021     let type = EditableSyntax.from_json(
13022       json.cast_type, position, source);
13023     position += type.width;
13024     let right_paren = EditableSyntax.from_json(
13025       json.cast_right_paren, position, source);
13026     position += right_paren.width;
13027     let operand = EditableSyntax.from_json(
13028       json.cast_operand, position, source);
13029     position += operand.width;
13030     return new CastExpression(
13031         left_paren,
13032         type,
13033         right_paren,
13034         operand);
13035   }
13036   get children_keys()
13037   {
13038     if (CastExpression._children_keys == null)
13039       CastExpression._children_keys = [
13040         'left_paren',
13041         'type',
13042         'right_paren',
13043         'operand'];
13044     return CastExpression._children_keys;
13045   }
13046 }
13047 class ScopeResolutionExpression extends EditableSyntax
13048 {
13049   constructor(
13050     qualifier,
13051     operator,
13052     name)
13053   {
13054     super('scope_resolution_expression', {
13055       qualifier: qualifier,
13056       operator: operator,
13057       name: name });
13058   }
13059   get qualifier() { return this.children.qualifier; }
13060   get operator() { return this.children.operator; }
13061   get name() { return this.children.name; }
13062   with_qualifier(qualifier){
13063     return new ScopeResolutionExpression(
13064       qualifier,
13065       this.operator,
13066       this.name);
13067   }
13068   with_operator(operator){
13069     return new ScopeResolutionExpression(
13070       this.qualifier,
13071       operator,
13072       this.name);
13073   }
13074   with_name(name){
13075     return new ScopeResolutionExpression(
13076       this.qualifier,
13077       this.operator,
13078       name);
13079   }
13080   rewrite(rewriter, parents)
13081   {
13082     if (parents == undefined)
13083       parents = [];
13084     let new_parents = parents.slice();
13085     new_parents.push(this);
13086     var qualifier = this.qualifier.rewrite(rewriter, new_parents);
13087     var operator = this.operator.rewrite(rewriter, new_parents);
13088     var name = this.name.rewrite(rewriter, new_parents);
13089     if (
13090       qualifier === this.qualifier &&
13091       operator === this.operator &&
13092       name === this.name)
13093     {
13094       return rewriter(this, parents);
13095     }
13096     else
13097     {
13098       return rewriter(new ScopeResolutionExpression(
13099         qualifier,
13100         operator,
13101         name), parents);
13102     }
13103   }
13104   static from_json(json, position, source)
13105   {
13106     let qualifier = EditableSyntax.from_json(
13107       json.scope_resolution_qualifier, position, source);
13108     position += qualifier.width;
13109     let operator = EditableSyntax.from_json(
13110       json.scope_resolution_operator, position, source);
13111     position += operator.width;
13112     let name = EditableSyntax.from_json(
13113       json.scope_resolution_name, position, source);
13114     position += name.width;
13115     return new ScopeResolutionExpression(
13116         qualifier,
13117         operator,
13118         name);
13119   }
13120   get children_keys()
13121   {
13122     if (ScopeResolutionExpression._children_keys == null)
13123       ScopeResolutionExpression._children_keys = [
13124         'qualifier',
13125         'operator',
13126         'name'];
13127     return ScopeResolutionExpression._children_keys;
13128   }
13129 }
13130 class MemberSelectionExpression extends EditableSyntax
13131 {
13132   constructor(
13133     object,
13134     operator,
13135     name)
13136   {
13137     super('member_selection_expression', {
13138       object: object,
13139       operator: operator,
13140       name: name });
13141   }
13142   get object() { return this.children.object; }
13143   get operator() { return this.children.operator; }
13144   get name() { return this.children.name; }
13145   with_object(object){
13146     return new MemberSelectionExpression(
13147       object,
13148       this.operator,
13149       this.name);
13150   }
13151   with_operator(operator){
13152     return new MemberSelectionExpression(
13153       this.object,
13154       operator,
13155       this.name);
13156   }
13157   with_name(name){
13158     return new MemberSelectionExpression(
13159       this.object,
13160       this.operator,
13161       name);
13162   }
13163   rewrite(rewriter, parents)
13164   {
13165     if (parents == undefined)
13166       parents = [];
13167     let new_parents = parents.slice();
13168     new_parents.push(this);
13169     var object = this.object.rewrite(rewriter, new_parents);
13170     var operator = this.operator.rewrite(rewriter, new_parents);
13171     var name = this.name.rewrite(rewriter, new_parents);
13172     if (
13173       object === this.object &&
13174       operator === this.operator &&
13175       name === this.name)
13176     {
13177       return rewriter(this, parents);
13178     }
13179     else
13180     {
13181       return rewriter(new MemberSelectionExpression(
13182         object,
13183         operator,
13184         name), parents);
13185     }
13186   }
13187   static from_json(json, position, source)
13188   {
13189     let object = EditableSyntax.from_json(
13190       json.member_object, position, source);
13191     position += object.width;
13192     let operator = EditableSyntax.from_json(
13193       json.member_operator, position, source);
13194     position += operator.width;
13195     let name = EditableSyntax.from_json(
13196       json.member_name, position, source);
13197     position += name.width;
13198     return new MemberSelectionExpression(
13199         object,
13200         operator,
13201         name);
13202   }
13203   get children_keys()
13204   {
13205     if (MemberSelectionExpression._children_keys == null)
13206       MemberSelectionExpression._children_keys = [
13207         'object',
13208         'operator',
13209         'name'];
13210     return MemberSelectionExpression._children_keys;
13211   }
13212 }
13213 class SafeMemberSelectionExpression extends EditableSyntax
13214 {
13215   constructor(
13216     object,
13217     operator,
13218     name)
13219   {
13220     super('safe_member_selection_expression', {
13221       object: object,
13222       operator: operator,
13223       name: name });
13224   }
13225   get object() { return this.children.object; }
13226   get operator() { return this.children.operator; }
13227   get name() { return this.children.name; }
13228   with_object(object){
13229     return new SafeMemberSelectionExpression(
13230       object,
13231       this.operator,
13232       this.name);
13233   }
13234   with_operator(operator){
13235     return new SafeMemberSelectionExpression(
13236       this.object,
13237       operator,
13238       this.name);
13239   }
13240   with_name(name){
13241     return new SafeMemberSelectionExpression(
13242       this.object,
13243       this.operator,
13244       name);
13245   }
13246   rewrite(rewriter, parents)
13247   {
13248     if (parents == undefined)
13249       parents = [];
13250     let new_parents = parents.slice();
13251     new_parents.push(this);
13252     var object = this.object.rewrite(rewriter, new_parents);
13253     var operator = this.operator.rewrite(rewriter, new_parents);
13254     var name = this.name.rewrite(rewriter, new_parents);
13255     if (
13256       object === this.object &&
13257       operator === this.operator &&
13258       name === this.name)
13259     {
13260       return rewriter(this, parents);
13261     }
13262     else
13263     {
13264       return rewriter(new SafeMemberSelectionExpression(
13265         object,
13266         operator,
13267         name), parents);
13268     }
13269   }
13270   static from_json(json, position, source)
13271   {
13272     let object = EditableSyntax.from_json(
13273       json.safe_member_object, position, source);
13274     position += object.width;
13275     let operator = EditableSyntax.from_json(
13276       json.safe_member_operator, position, source);
13277     position += operator.width;
13278     let name = EditableSyntax.from_json(
13279       json.safe_member_name, position, source);
13280     position += name.width;
13281     return new SafeMemberSelectionExpression(
13282         object,
13283         operator,
13284         name);
13285   }
13286   get children_keys()
13287   {
13288     if (SafeMemberSelectionExpression._children_keys == null)
13289       SafeMemberSelectionExpression._children_keys = [
13290         'object',
13291         'operator',
13292         'name'];
13293     return SafeMemberSelectionExpression._children_keys;
13294   }
13295 }
13296 class EmbeddedMemberSelectionExpression extends EditableSyntax
13297 {
13298   constructor(
13299     object,
13300     operator,
13301     name)
13302   {
13303     super('embedded_member_selection_expression', {
13304       object: object,
13305       operator: operator,
13306       name: name });
13307   }
13308   get object() { return this.children.object; }
13309   get operator() { return this.children.operator; }
13310   get name() { return this.children.name; }
13311   with_object(object){
13312     return new EmbeddedMemberSelectionExpression(
13313       object,
13314       this.operator,
13315       this.name);
13316   }
13317   with_operator(operator){
13318     return new EmbeddedMemberSelectionExpression(
13319       this.object,
13320       operator,
13321       this.name);
13322   }
13323   with_name(name){
13324     return new EmbeddedMemberSelectionExpression(
13325       this.object,
13326       this.operator,
13327       name);
13328   }
13329   rewrite(rewriter, parents)
13330   {
13331     if (parents == undefined)
13332       parents = [];
13333     let new_parents = parents.slice();
13334     new_parents.push(this);
13335     var object = this.object.rewrite(rewriter, new_parents);
13336     var operator = this.operator.rewrite(rewriter, new_parents);
13337     var name = this.name.rewrite(rewriter, new_parents);
13338     if (
13339       object === this.object &&
13340       operator === this.operator &&
13341       name === this.name)
13342     {
13343       return rewriter(this, parents);
13344     }
13345     else
13346     {
13347       return rewriter(new EmbeddedMemberSelectionExpression(
13348         object,
13349         operator,
13350         name), parents);
13351     }
13352   }
13353   static from_json(json, position, source)
13354   {
13355     let object = EditableSyntax.from_json(
13356       json.embedded_member_object, position, source);
13357     position += object.width;
13358     let operator = EditableSyntax.from_json(
13359       json.embedded_member_operator, position, source);
13360     position += operator.width;
13361     let name = EditableSyntax.from_json(
13362       json.embedded_member_name, position, source);
13363     position += name.width;
13364     return new EmbeddedMemberSelectionExpression(
13365         object,
13366         operator,
13367         name);
13368   }
13369   get children_keys()
13370   {
13371     if (EmbeddedMemberSelectionExpression._children_keys == null)
13372       EmbeddedMemberSelectionExpression._children_keys = [
13373         'object',
13374         'operator',
13375         'name'];
13376     return EmbeddedMemberSelectionExpression._children_keys;
13377   }
13378 }
13379 class YieldExpression extends EditableSyntax
13380 {
13381   constructor(
13382     keyword,
13383     operand)
13384   {
13385     super('yield_expression', {
13386       keyword: keyword,
13387       operand: operand });
13388   }
13389   get keyword() { return this.children.keyword; }
13390   get operand() { return this.children.operand; }
13391   with_keyword(keyword){
13392     return new YieldExpression(
13393       keyword,
13394       this.operand);
13395   }
13396   with_operand(operand){
13397     return new YieldExpression(
13398       this.keyword,
13399       operand);
13400   }
13401   rewrite(rewriter, parents)
13402   {
13403     if (parents == undefined)
13404       parents = [];
13405     let new_parents = parents.slice();
13406     new_parents.push(this);
13407     var keyword = this.keyword.rewrite(rewriter, new_parents);
13408     var operand = this.operand.rewrite(rewriter, new_parents);
13409     if (
13410       keyword === this.keyword &&
13411       operand === this.operand)
13412     {
13413       return rewriter(this, parents);
13414     }
13415     else
13416     {
13417       return rewriter(new YieldExpression(
13418         keyword,
13419         operand), parents);
13420     }
13421   }
13422   static from_json(json, position, source)
13423   {
13424     let keyword = EditableSyntax.from_json(
13425       json.yield_keyword, position, source);
13426     position += keyword.width;
13427     let operand = EditableSyntax.from_json(
13428       json.yield_operand, position, source);
13429     position += operand.width;
13430     return new YieldExpression(
13431         keyword,
13432         operand);
13433   }
13434   get children_keys()
13435   {
13436     if (YieldExpression._children_keys == null)
13437       YieldExpression._children_keys = [
13438         'keyword',
13439         'operand'];
13440     return YieldExpression._children_keys;
13441   }
13442 }
13443 class YieldFromExpression extends EditableSyntax
13444 {
13445   constructor(
13446     yield_keyword,
13447     from_keyword,
13448     operand)
13449   {
13450     super('yield_from_expression', {
13451       yield_keyword: yield_keyword,
13452       from_keyword: from_keyword,
13453       operand: operand });
13454   }
13455   get yield_keyword() { return this.children.yield_keyword; }
13456   get from_keyword() { return this.children.from_keyword; }
13457   get operand() { return this.children.operand; }
13458   with_yield_keyword(yield_keyword){
13459     return new YieldFromExpression(
13460       yield_keyword,
13461       this.from_keyword,
13462       this.operand);
13463   }
13464   with_from_keyword(from_keyword){
13465     return new YieldFromExpression(
13466       this.yield_keyword,
13467       from_keyword,
13468       this.operand);
13469   }
13470   with_operand(operand){
13471     return new YieldFromExpression(
13472       this.yield_keyword,
13473       this.from_keyword,
13474       operand);
13475   }
13476   rewrite(rewriter, parents)
13477   {
13478     if (parents == undefined)
13479       parents = [];
13480     let new_parents = parents.slice();
13481     new_parents.push(this);
13482     var yield_keyword = this.yield_keyword.rewrite(rewriter, new_parents);
13483     var from_keyword = this.from_keyword.rewrite(rewriter, new_parents);
13484     var operand = this.operand.rewrite(rewriter, new_parents);
13485     if (
13486       yield_keyword === this.yield_keyword &&
13487       from_keyword === this.from_keyword &&
13488       operand === this.operand)
13489     {
13490       return rewriter(this, parents);
13491     }
13492     else
13493     {
13494       return rewriter(new YieldFromExpression(
13495         yield_keyword,
13496         from_keyword,
13497         operand), parents);
13498     }
13499   }
13500   static from_json(json, position, source)
13501   {
13502     let yield_keyword = EditableSyntax.from_json(
13503       json.yield_from_yield_keyword, position, source);
13504     position += yield_keyword.width;
13505     let from_keyword = EditableSyntax.from_json(
13506       json.yield_from_from_keyword, position, source);
13507     position += from_keyword.width;
13508     let operand = EditableSyntax.from_json(
13509       json.yield_from_operand, position, source);
13510     position += operand.width;
13511     return new YieldFromExpression(
13512         yield_keyword,
13513         from_keyword,
13514         operand);
13515   }
13516   get children_keys()
13517   {
13518     if (YieldFromExpression._children_keys == null)
13519       YieldFromExpression._children_keys = [
13520         'yield_keyword',
13521         'from_keyword',
13522         'operand'];
13523     return YieldFromExpression._children_keys;
13524   }
13525 }
13526 class PrefixUnaryExpression extends EditableSyntax
13527 {
13528   constructor(
13529     operator,
13530     operand)
13531   {
13532     super('prefix_unary_expression', {
13533       operator: operator,
13534       operand: operand });
13535   }
13536   get operator() { return this.children.operator; }
13537   get operand() { return this.children.operand; }
13538   with_operator(operator){
13539     return new PrefixUnaryExpression(
13540       operator,
13541       this.operand);
13542   }
13543   with_operand(operand){
13544     return new PrefixUnaryExpression(
13545       this.operator,
13546       operand);
13547   }
13548   rewrite(rewriter, parents)
13549   {
13550     if (parents == undefined)
13551       parents = [];
13552     let new_parents = parents.slice();
13553     new_parents.push(this);
13554     var operator = this.operator.rewrite(rewriter, new_parents);
13555     var operand = this.operand.rewrite(rewriter, new_parents);
13556     if (
13557       operator === this.operator &&
13558       operand === this.operand)
13559     {
13560       return rewriter(this, parents);
13561     }
13562     else
13563     {
13564       return rewriter(new PrefixUnaryExpression(
13565         operator,
13566         operand), parents);
13567     }
13568   }
13569   static from_json(json, position, source)
13570   {
13571     let operator = EditableSyntax.from_json(
13572       json.prefix_unary_operator, position, source);
13573     position += operator.width;
13574     let operand = EditableSyntax.from_json(
13575       json.prefix_unary_operand, position, source);
13576     position += operand.width;
13577     return new PrefixUnaryExpression(
13578         operator,
13579         operand);
13580   }
13581   get children_keys()
13582   {
13583     if (PrefixUnaryExpression._children_keys == null)
13584       PrefixUnaryExpression._children_keys = [
13585         'operator',
13586         'operand'];
13587     return PrefixUnaryExpression._children_keys;
13588   }
13589 }
13590 class PostfixUnaryExpression extends EditableSyntax
13591 {
13592   constructor(
13593     operand,
13594     operator)
13595   {
13596     super('postfix_unary_expression', {
13597       operand: operand,
13598       operator: operator });
13599   }
13600   get operand() { return this.children.operand; }
13601   get operator() { return this.children.operator; }
13602   with_operand(operand){
13603     return new PostfixUnaryExpression(
13604       operand,
13605       this.operator);
13606   }
13607   with_operator(operator){
13608     return new PostfixUnaryExpression(
13609       this.operand,
13610       operator);
13611   }
13612   rewrite(rewriter, parents)
13613   {
13614     if (parents == undefined)
13615       parents = [];
13616     let new_parents = parents.slice();
13617     new_parents.push(this);
13618     var operand = this.operand.rewrite(rewriter, new_parents);
13619     var operator = this.operator.rewrite(rewriter, new_parents);
13620     if (
13621       operand === this.operand &&
13622       operator === this.operator)
13623     {
13624       return rewriter(this, parents);
13625     }
13626     else
13627     {
13628       return rewriter(new PostfixUnaryExpression(
13629         operand,
13630         operator), parents);
13631     }
13632   }
13633   static from_json(json, position, source)
13634   {
13635     let operand = EditableSyntax.from_json(
13636       json.postfix_unary_operand, position, source);
13637     position += operand.width;
13638     let operator = EditableSyntax.from_json(
13639       json.postfix_unary_operator, position, source);
13640     position += operator.width;
13641     return new PostfixUnaryExpression(
13642         operand,
13643         operator);
13644   }
13645   get children_keys()
13646   {
13647     if (PostfixUnaryExpression._children_keys == null)
13648       PostfixUnaryExpression._children_keys = [
13649         'operand',
13650         'operator'];
13651     return PostfixUnaryExpression._children_keys;
13652   }
13653 }
13654 class BinaryExpression extends EditableSyntax
13655 {
13656   constructor(
13657     left_operand,
13658     operator,
13659     right_operand)
13660   {
13661     super('binary_expression', {
13662       left_operand: left_operand,
13663       operator: operator,
13664       right_operand: right_operand });
13665   }
13666   get left_operand() { return this.children.left_operand; }
13667   get operator() { return this.children.operator; }
13668   get right_operand() { return this.children.right_operand; }
13669   with_left_operand(left_operand){
13670     return new BinaryExpression(
13671       left_operand,
13672       this.operator,
13673       this.right_operand);
13674   }
13675   with_operator(operator){
13676     return new BinaryExpression(
13677       this.left_operand,
13678       operator,
13679       this.right_operand);
13680   }
13681   with_right_operand(right_operand){
13682     return new BinaryExpression(
13683       this.left_operand,
13684       this.operator,
13685       right_operand);
13686   }
13687   rewrite(rewriter, parents)
13688   {
13689     if (parents == undefined)
13690       parents = [];
13691     let new_parents = parents.slice();
13692     new_parents.push(this);
13693     var left_operand = this.left_operand.rewrite(rewriter, new_parents);
13694     var operator = this.operator.rewrite(rewriter, new_parents);
13695     var right_operand = this.right_operand.rewrite(rewriter, new_parents);
13696     if (
13697       left_operand === this.left_operand &&
13698       operator === this.operator &&
13699       right_operand === this.right_operand)
13700     {
13701       return rewriter(this, parents);
13702     }
13703     else
13704     {
13705       return rewriter(new BinaryExpression(
13706         left_operand,
13707         operator,
13708         right_operand), parents);
13709     }
13710   }
13711   static from_json(json, position, source)
13712   {
13713     let left_operand = EditableSyntax.from_json(
13714       json.binary_left_operand, position, source);
13715     position += left_operand.width;
13716     let operator = EditableSyntax.from_json(
13717       json.binary_operator, position, source);
13718     position += operator.width;
13719     let right_operand = EditableSyntax.from_json(
13720       json.binary_right_operand, position, source);
13721     position += right_operand.width;
13722     return new BinaryExpression(
13723         left_operand,
13724         operator,
13725         right_operand);
13726   }
13727   get children_keys()
13728   {
13729     if (BinaryExpression._children_keys == null)
13730       BinaryExpression._children_keys = [
13731         'left_operand',
13732         'operator',
13733         'right_operand'];
13734     return BinaryExpression._children_keys;
13735   }
13736 }
13737 class InstanceofExpression extends EditableSyntax
13738 {
13739   constructor(
13740     left_operand,
13741     operator,
13742     right_operand)
13743   {
13744     super('instanceof_expression', {
13745       left_operand: left_operand,
13746       operator: operator,
13747       right_operand: right_operand });
13748   }
13749   get left_operand() { return this.children.left_operand; }
13750   get operator() { return this.children.operator; }
13751   get right_operand() { return this.children.right_operand; }
13752   with_left_operand(left_operand){
13753     return new InstanceofExpression(
13754       left_operand,
13755       this.operator,
13756       this.right_operand);
13757   }
13758   with_operator(operator){
13759     return new InstanceofExpression(
13760       this.left_operand,
13761       operator,
13762       this.right_operand);
13763   }
13764   with_right_operand(right_operand){
13765     return new InstanceofExpression(
13766       this.left_operand,
13767       this.operator,
13768       right_operand);
13769   }
13770   rewrite(rewriter, parents)
13771   {
13772     if (parents == undefined)
13773       parents = [];
13774     let new_parents = parents.slice();
13775     new_parents.push(this);
13776     var left_operand = this.left_operand.rewrite(rewriter, new_parents);
13777     var operator = this.operator.rewrite(rewriter, new_parents);
13778     var right_operand = this.right_operand.rewrite(rewriter, new_parents);
13779     if (
13780       left_operand === this.left_operand &&
13781       operator === this.operator &&
13782       right_operand === this.right_operand)
13783     {
13784       return rewriter(this, parents);
13785     }
13786     else
13787     {
13788       return rewriter(new InstanceofExpression(
13789         left_operand,
13790         operator,
13791         right_operand), parents);
13792     }
13793   }
13794   static from_json(json, position, source)
13795   {
13796     let left_operand = EditableSyntax.from_json(
13797       json.instanceof_left_operand, position, source);
13798     position += left_operand.width;
13799     let operator = EditableSyntax.from_json(
13800       json.instanceof_operator, position, source);
13801     position += operator.width;
13802     let right_operand = EditableSyntax.from_json(
13803       json.instanceof_right_operand, position, source);
13804     position += right_operand.width;
13805     return new InstanceofExpression(
13806         left_operand,
13807         operator,
13808         right_operand);
13809   }
13810   get children_keys()
13811   {
13812     if (InstanceofExpression._children_keys == null)
13813       InstanceofExpression._children_keys = [
13814         'left_operand',
13815         'operator',
13816         'right_operand'];
13817     return InstanceofExpression._children_keys;
13818   }
13819 }
13820 class IsExpression extends EditableSyntax
13821 {
13822   constructor(
13823     left_operand,
13824     operator,
13825     right_operand)
13826   {
13827     super('is_expression', {
13828       left_operand: left_operand,
13829       operator: operator,
13830       right_operand: right_operand });
13831   }
13832   get left_operand() { return this.children.left_operand; }
13833   get operator() { return this.children.operator; }
13834   get right_operand() { return this.children.right_operand; }
13835   with_left_operand(left_operand){
13836     return new IsExpression(
13837       left_operand,
13838       this.operator,
13839       this.right_operand);
13840   }
13841   with_operator(operator){
13842     return new IsExpression(
13843       this.left_operand,
13844       operator,
13845       this.right_operand);
13846   }
13847   with_right_operand(right_operand){
13848     return new IsExpression(
13849       this.left_operand,
13850       this.operator,
13851       right_operand);
13852   }
13853   rewrite(rewriter, parents)
13854   {
13855     if (parents == undefined)
13856       parents = [];
13857     let new_parents = parents.slice();
13858     new_parents.push(this);
13859     var left_operand = this.left_operand.rewrite(rewriter, new_parents);
13860     var operator = this.operator.rewrite(rewriter, new_parents);
13861     var right_operand = this.right_operand.rewrite(rewriter, new_parents);
13862     if (
13863       left_operand === this.left_operand &&
13864       operator === this.operator &&
13865       right_operand === this.right_operand)
13866     {
13867       return rewriter(this, parents);
13868     }
13869     else
13870     {
13871       return rewriter(new IsExpression(
13872         left_operand,
13873         operator,
13874         right_operand), parents);
13875     }
13876   }
13877   static from_json(json, position, source)
13878   {
13879     let left_operand = EditableSyntax.from_json(
13880       json.is_left_operand, position, source);
13881     position += left_operand.width;
13882     let operator = EditableSyntax.from_json(
13883       json.is_operator, position, source);
13884     position += operator.width;
13885     let right_operand = EditableSyntax.from_json(
13886       json.is_right_operand, position, source);
13887     position += right_operand.width;
13888     return new IsExpression(
13889         left_operand,
13890         operator,
13891         right_operand);
13892   }
13893   get children_keys()
13894   {
13895     if (IsExpression._children_keys == null)
13896       IsExpression._children_keys = [
13897         'left_operand',
13898         'operator',
13899         'right_operand'];
13900     return IsExpression._children_keys;
13901   }
13902 }
13903 class ConditionalExpression extends EditableSyntax
13904 {
13905   constructor(
13906     test,
13907     question,
13908     consequence,
13909     colon,
13910     alternative)
13911   {
13912     super('conditional_expression', {
13913       test: test,
13914       question: question,
13915       consequence: consequence,
13916       colon: colon,
13917       alternative: alternative });
13918   }
13919   get test() { return this.children.test; }
13920   get question() { return this.children.question; }
13921   get consequence() { return this.children.consequence; }
13922   get colon() { return this.children.colon; }
13923   get alternative() { return this.children.alternative; }
13924   with_test(test){
13925     return new ConditionalExpression(
13926       test,
13927       this.question,
13928       this.consequence,
13929       this.colon,
13930       this.alternative);
13931   }
13932   with_question(question){
13933     return new ConditionalExpression(
13934       this.test,
13935       question,
13936       this.consequence,
13937       this.colon,
13938       this.alternative);
13939   }
13940   with_consequence(consequence){
13941     return new ConditionalExpression(
13942       this.test,
13943       this.question,
13944       consequence,
13945       this.colon,
13946       this.alternative);
13947   }
13948   with_colon(colon){
13949     return new ConditionalExpression(
13950       this.test,
13951       this.question,
13952       this.consequence,
13953       colon,
13954       this.alternative);
13955   }
13956   with_alternative(alternative){
13957     return new ConditionalExpression(
13958       this.test,
13959       this.question,
13960       this.consequence,
13961       this.colon,
13962       alternative);
13963   }
13964   rewrite(rewriter, parents)
13965   {
13966     if (parents == undefined)
13967       parents = [];
13968     let new_parents = parents.slice();
13969     new_parents.push(this);
13970     var test = this.test.rewrite(rewriter, new_parents);
13971     var question = this.question.rewrite(rewriter, new_parents);
13972     var consequence = this.consequence.rewrite(rewriter, new_parents);
13973     var colon = this.colon.rewrite(rewriter, new_parents);
13974     var alternative = this.alternative.rewrite(rewriter, new_parents);
13975     if (
13976       test === this.test &&
13977       question === this.question &&
13978       consequence === this.consequence &&
13979       colon === this.colon &&
13980       alternative === this.alternative)
13981     {
13982       return rewriter(this, parents);
13983     }
13984     else
13985     {
13986       return rewriter(new ConditionalExpression(
13987         test,
13988         question,
13989         consequence,
13990         colon,
13991         alternative), parents);
13992     }
13993   }
13994   static from_json(json, position, source)
13995   {
13996     let test = EditableSyntax.from_json(
13997       json.conditional_test, position, source);
13998     position += test.width;
13999     let question = EditableSyntax.from_json(
14000       json.conditional_question, position, source);
14001     position += question.width;
14002     let consequence = EditableSyntax.from_json(
14003       json.conditional_consequence, position, source);
14004     position += consequence.width;
14005     let colon = EditableSyntax.from_json(
14006       json.conditional_colon, position, source);
14007     position += colon.width;
14008     let alternative = EditableSyntax.from_json(
14009       json.conditional_alternative, position, source);
14010     position += alternative.width;
14011     return new ConditionalExpression(
14012         test,
14013         question,
14014         consequence,
14015         colon,
14016         alternative);
14017   }
14018   get children_keys()
14019   {
14020     if (ConditionalExpression._children_keys == null)
14021       ConditionalExpression._children_keys = [
14022         'test',
14023         'question',
14024         'consequence',
14025         'colon',
14026         'alternative'];
14027     return ConditionalExpression._children_keys;
14028   }
14029 }
14030 class EvalExpression extends EditableSyntax
14031 {
14032   constructor(
14033     keyword,
14034     left_paren,
14035     argument,
14036     right_paren)
14037   {
14038     super('eval_expression', {
14039       keyword: keyword,
14040       left_paren: left_paren,
14041       argument: argument,
14042       right_paren: right_paren });
14043   }
14044   get keyword() { return this.children.keyword; }
14045   get left_paren() { return this.children.left_paren; }
14046   get argument() { return this.children.argument; }
14047   get right_paren() { return this.children.right_paren; }
14048   with_keyword(keyword){
14049     return new EvalExpression(
14050       keyword,
14051       this.left_paren,
14052       this.argument,
14053       this.right_paren);
14054   }
14055   with_left_paren(left_paren){
14056     return new EvalExpression(
14057       this.keyword,
14058       left_paren,
14059       this.argument,
14060       this.right_paren);
14061   }
14062   with_argument(argument){
14063     return new EvalExpression(
14064       this.keyword,
14065       this.left_paren,
14066       argument,
14067       this.right_paren);
14068   }
14069   with_right_paren(right_paren){
14070     return new EvalExpression(
14071       this.keyword,
14072       this.left_paren,
14073       this.argument,
14074       right_paren);
14075   }
14076   rewrite(rewriter, parents)
14077   {
14078     if (parents == undefined)
14079       parents = [];
14080     let new_parents = parents.slice();
14081     new_parents.push(this);
14082     var keyword = this.keyword.rewrite(rewriter, new_parents);
14083     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
14084     var argument = this.argument.rewrite(rewriter, new_parents);
14085     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
14086     if (
14087       keyword === this.keyword &&
14088       left_paren === this.left_paren &&
14089       argument === this.argument &&
14090       right_paren === this.right_paren)
14091     {
14092       return rewriter(this, parents);
14093     }
14094     else
14095     {
14096       return rewriter(new EvalExpression(
14097         keyword,
14098         left_paren,
14099         argument,
14100         right_paren), parents);
14101     }
14102   }
14103   static from_json(json, position, source)
14104   {
14105     let keyword = EditableSyntax.from_json(
14106       json.eval_keyword, position, source);
14107     position += keyword.width;
14108     let left_paren = EditableSyntax.from_json(
14109       json.eval_left_paren, position, source);
14110     position += left_paren.width;
14111     let argument = EditableSyntax.from_json(
14112       json.eval_argument, position, source);
14113     position += argument.width;
14114     let right_paren = EditableSyntax.from_json(
14115       json.eval_right_paren, position, source);
14116     position += right_paren.width;
14117     return new EvalExpression(
14118         keyword,
14119         left_paren,
14120         argument,
14121         right_paren);
14122   }
14123   get children_keys()
14124   {
14125     if (EvalExpression._children_keys == null)
14126       EvalExpression._children_keys = [
14127         'keyword',
14128         'left_paren',
14129         'argument',
14130         'right_paren'];
14131     return EvalExpression._children_keys;
14132   }
14133 }
14134 class EmptyExpression extends EditableSyntax
14135 {
14136   constructor(
14137     keyword,
14138     left_paren,
14139     argument,
14140     right_paren)
14141   {
14142     super('empty_expression', {
14143       keyword: keyword,
14144       left_paren: left_paren,
14145       argument: argument,
14146       right_paren: right_paren });
14147   }
14148   get keyword() { return this.children.keyword; }
14149   get left_paren() { return this.children.left_paren; }
14150   get argument() { return this.children.argument; }
14151   get right_paren() { return this.children.right_paren; }
14152   with_keyword(keyword){
14153     return new EmptyExpression(
14154       keyword,
14155       this.left_paren,
14156       this.argument,
14157       this.right_paren);
14158   }
14159   with_left_paren(left_paren){
14160     return new EmptyExpression(
14161       this.keyword,
14162       left_paren,
14163       this.argument,
14164       this.right_paren);
14165   }
14166   with_argument(argument){
14167     return new EmptyExpression(
14168       this.keyword,
14169       this.left_paren,
14170       argument,
14171       this.right_paren);
14172   }
14173   with_right_paren(right_paren){
14174     return new EmptyExpression(
14175       this.keyword,
14176       this.left_paren,
14177       this.argument,
14178       right_paren);
14179   }
14180   rewrite(rewriter, parents)
14181   {
14182     if (parents == undefined)
14183       parents = [];
14184     let new_parents = parents.slice();
14185     new_parents.push(this);
14186     var keyword = this.keyword.rewrite(rewriter, new_parents);
14187     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
14188     var argument = this.argument.rewrite(rewriter, new_parents);
14189     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
14190     if (
14191       keyword === this.keyword &&
14192       left_paren === this.left_paren &&
14193       argument === this.argument &&
14194       right_paren === this.right_paren)
14195     {
14196       return rewriter(this, parents);
14197     }
14198     else
14199     {
14200       return rewriter(new EmptyExpression(
14201         keyword,
14202         left_paren,
14203         argument,
14204         right_paren), parents);
14205     }
14206   }
14207   static from_json(json, position, source)
14208   {
14209     let keyword = EditableSyntax.from_json(
14210       json.empty_keyword, position, source);
14211     position += keyword.width;
14212     let left_paren = EditableSyntax.from_json(
14213       json.empty_left_paren, position, source);
14214     position += left_paren.width;
14215     let argument = EditableSyntax.from_json(
14216       json.empty_argument, position, source);
14217     position += argument.width;
14218     let right_paren = EditableSyntax.from_json(
14219       json.empty_right_paren, position, source);
14220     position += right_paren.width;
14221     return new EmptyExpression(
14222         keyword,
14223         left_paren,
14224         argument,
14225         right_paren);
14226   }
14227   get children_keys()
14228   {
14229     if (EmptyExpression._children_keys == null)
14230       EmptyExpression._children_keys = [
14231         'keyword',
14232         'left_paren',
14233         'argument',
14234         'right_paren'];
14235     return EmptyExpression._children_keys;
14236   }
14237 }
14238 class DefineExpression extends EditableSyntax
14239 {
14240   constructor(
14241     keyword,
14242     left_paren,
14243     argument_list,
14244     right_paren)
14245   {
14246     super('define_expression', {
14247       keyword: keyword,
14248       left_paren: left_paren,
14249       argument_list: argument_list,
14250       right_paren: right_paren });
14251   }
14252   get keyword() { return this.children.keyword; }
14253   get left_paren() { return this.children.left_paren; }
14254   get argument_list() { return this.children.argument_list; }
14255   get right_paren() { return this.children.right_paren; }
14256   with_keyword(keyword){
14257     return new DefineExpression(
14258       keyword,
14259       this.left_paren,
14260       this.argument_list,
14261       this.right_paren);
14262   }
14263   with_left_paren(left_paren){
14264     return new DefineExpression(
14265       this.keyword,
14266       left_paren,
14267       this.argument_list,
14268       this.right_paren);
14269   }
14270   with_argument_list(argument_list){
14271     return new DefineExpression(
14272       this.keyword,
14273       this.left_paren,
14274       argument_list,
14275       this.right_paren);
14276   }
14277   with_right_paren(right_paren){
14278     return new DefineExpression(
14279       this.keyword,
14280       this.left_paren,
14281       this.argument_list,
14282       right_paren);
14283   }
14284   rewrite(rewriter, parents)
14285   {
14286     if (parents == undefined)
14287       parents = [];
14288     let new_parents = parents.slice();
14289     new_parents.push(this);
14290     var keyword = this.keyword.rewrite(rewriter, new_parents);
14291     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
14292     var argument_list = this.argument_list.rewrite(rewriter, new_parents);
14293     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
14294     if (
14295       keyword === this.keyword &&
14296       left_paren === this.left_paren &&
14297       argument_list === this.argument_list &&
14298       right_paren === this.right_paren)
14299     {
14300       return rewriter(this, parents);
14301     }
14302     else
14303     {
14304       return rewriter(new DefineExpression(
14305         keyword,
14306         left_paren,
14307         argument_list,
14308         right_paren), parents);
14309     }
14310   }
14311   static from_json(json, position, source)
14312   {
14313     let keyword = EditableSyntax.from_json(
14314       json.define_keyword, position, source);
14315     position += keyword.width;
14316     let left_paren = EditableSyntax.from_json(
14317       json.define_left_paren, position, source);
14318     position += left_paren.width;
14319     let argument_list = EditableSyntax.from_json(
14320       json.define_argument_list, position, source);
14321     position += argument_list.width;
14322     let right_paren = EditableSyntax.from_json(
14323       json.define_right_paren, position, source);
14324     position += right_paren.width;
14325     return new DefineExpression(
14326         keyword,
14327         left_paren,
14328         argument_list,
14329         right_paren);
14330   }
14331   get children_keys()
14332   {
14333     if (DefineExpression._children_keys == null)
14334       DefineExpression._children_keys = [
14335         'keyword',
14336         'left_paren',
14337         'argument_list',
14338         'right_paren'];
14339     return DefineExpression._children_keys;
14340   }
14341 }
14342 class HaltCompilerExpression extends EditableSyntax
14343 {
14344   constructor(
14345     keyword,
14346     left_paren,
14347     argument_list,
14348     right_paren)
14349   {
14350     super('halt_compiler_expression', {
14351       keyword: keyword,
14352       left_paren: left_paren,
14353       argument_list: argument_list,
14354       right_paren: right_paren });
14355   }
14356   get keyword() { return this.children.keyword; }
14357   get left_paren() { return this.children.left_paren; }
14358   get argument_list() { return this.children.argument_list; }
14359   get right_paren() { return this.children.right_paren; }
14360   with_keyword(keyword){
14361     return new HaltCompilerExpression(
14362       keyword,
14363       this.left_paren,
14364       this.argument_list,
14365       this.right_paren);
14366   }
14367   with_left_paren(left_paren){
14368     return new HaltCompilerExpression(
14369       this.keyword,
14370       left_paren,
14371       this.argument_list,
14372       this.right_paren);
14373   }
14374   with_argument_list(argument_list){
14375     return new HaltCompilerExpression(
14376       this.keyword,
14377       this.left_paren,
14378       argument_list,
14379       this.right_paren);
14380   }
14381   with_right_paren(right_paren){
14382     return new HaltCompilerExpression(
14383       this.keyword,
14384       this.left_paren,
14385       this.argument_list,
14386       right_paren);
14387   }
14388   rewrite(rewriter, parents)
14389   {
14390     if (parents == undefined)
14391       parents = [];
14392     let new_parents = parents.slice();
14393     new_parents.push(this);
14394     var keyword = this.keyword.rewrite(rewriter, new_parents);
14395     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
14396     var argument_list = this.argument_list.rewrite(rewriter, new_parents);
14397     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
14398     if (
14399       keyword === this.keyword &&
14400       left_paren === this.left_paren &&
14401       argument_list === this.argument_list &&
14402       right_paren === this.right_paren)
14403     {
14404       return rewriter(this, parents);
14405     }
14406     else
14407     {
14408       return rewriter(new HaltCompilerExpression(
14409         keyword,
14410         left_paren,
14411         argument_list,
14412         right_paren), parents);
14413     }
14414   }
14415   static from_json(json, position, source)
14416   {
14417     let keyword = EditableSyntax.from_json(
14418       json.halt_compiler_keyword, position, source);
14419     position += keyword.width;
14420     let left_paren = EditableSyntax.from_json(
14421       json.halt_compiler_left_paren, position, source);
14422     position += left_paren.width;
14423     let argument_list = EditableSyntax.from_json(
14424       json.halt_compiler_argument_list, position, source);
14425     position += argument_list.width;
14426     let right_paren = EditableSyntax.from_json(
14427       json.halt_compiler_right_paren, position, source);
14428     position += right_paren.width;
14429     return new HaltCompilerExpression(
14430         keyword,
14431         left_paren,
14432         argument_list,
14433         right_paren);
14434   }
14435   get children_keys()
14436   {
14437     if (HaltCompilerExpression._children_keys == null)
14438       HaltCompilerExpression._children_keys = [
14439         'keyword',
14440         'left_paren',
14441         'argument_list',
14442         'right_paren'];
14443     return HaltCompilerExpression._children_keys;
14444   }
14445 }
14446 class IssetExpression extends EditableSyntax
14447 {
14448   constructor(
14449     keyword,
14450     left_paren,
14451     argument_list,
14452     right_paren)
14453   {
14454     super('isset_expression', {
14455       keyword: keyword,
14456       left_paren: left_paren,
14457       argument_list: argument_list,
14458       right_paren: right_paren });
14459   }
14460   get keyword() { return this.children.keyword; }
14461   get left_paren() { return this.children.left_paren; }
14462   get argument_list() { return this.children.argument_list; }
14463   get right_paren() { return this.children.right_paren; }
14464   with_keyword(keyword){
14465     return new IssetExpression(
14466       keyword,
14467       this.left_paren,
14468       this.argument_list,
14469       this.right_paren);
14470   }
14471   with_left_paren(left_paren){
14472     return new IssetExpression(
14473       this.keyword,
14474       left_paren,
14475       this.argument_list,
14476       this.right_paren);
14477   }
14478   with_argument_list(argument_list){
14479     return new IssetExpression(
14480       this.keyword,
14481       this.left_paren,
14482       argument_list,
14483       this.right_paren);
14484   }
14485   with_right_paren(right_paren){
14486     return new IssetExpression(
14487       this.keyword,
14488       this.left_paren,
14489       this.argument_list,
14490       right_paren);
14491   }
14492   rewrite(rewriter, parents)
14493   {
14494     if (parents == undefined)
14495       parents = [];
14496     let new_parents = parents.slice();
14497     new_parents.push(this);
14498     var keyword = this.keyword.rewrite(rewriter, new_parents);
14499     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
14500     var argument_list = this.argument_list.rewrite(rewriter, new_parents);
14501     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
14502     if (
14503       keyword === this.keyword &&
14504       left_paren === this.left_paren &&
14505       argument_list === this.argument_list &&
14506       right_paren === this.right_paren)
14507     {
14508       return rewriter(this, parents);
14509     }
14510     else
14511     {
14512       return rewriter(new IssetExpression(
14513         keyword,
14514         left_paren,
14515         argument_list,
14516         right_paren), parents);
14517     }
14518   }
14519   static from_json(json, position, source)
14520   {
14521     let keyword = EditableSyntax.from_json(
14522       json.isset_keyword, position, source);
14523     position += keyword.width;
14524     let left_paren = EditableSyntax.from_json(
14525       json.isset_left_paren, position, source);
14526     position += left_paren.width;
14527     let argument_list = EditableSyntax.from_json(
14528       json.isset_argument_list, position, source);
14529     position += argument_list.width;
14530     let right_paren = EditableSyntax.from_json(
14531       json.isset_right_paren, position, source);
14532     position += right_paren.width;
14533     return new IssetExpression(
14534         keyword,
14535         left_paren,
14536         argument_list,
14537         right_paren);
14538   }
14539   get children_keys()
14540   {
14541     if (IssetExpression._children_keys == null)
14542       IssetExpression._children_keys = [
14543         'keyword',
14544         'left_paren',
14545         'argument_list',
14546         'right_paren'];
14547     return IssetExpression._children_keys;
14548   }
14549 }
14550 class FunctionCallExpression extends EditableSyntax
14551 {
14552   constructor(
14553     receiver,
14554     left_paren,
14555     argument_list,
14556     right_paren)
14557   {
14558     super('function_call_expression', {
14559       receiver: receiver,
14560       left_paren: left_paren,
14561       argument_list: argument_list,
14562       right_paren: right_paren });
14563   }
14564   get receiver() { return this.children.receiver; }
14565   get left_paren() { return this.children.left_paren; }
14566   get argument_list() { return this.children.argument_list; }
14567   get right_paren() { return this.children.right_paren; }
14568   with_receiver(receiver){
14569     return new FunctionCallExpression(
14570       receiver,
14571       this.left_paren,
14572       this.argument_list,
14573       this.right_paren);
14574   }
14575   with_left_paren(left_paren){
14576     return new FunctionCallExpression(
14577       this.receiver,
14578       left_paren,
14579       this.argument_list,
14580       this.right_paren);
14581   }
14582   with_argument_list(argument_list){
14583     return new FunctionCallExpression(
14584       this.receiver,
14585       this.left_paren,
14586       argument_list,
14587       this.right_paren);
14588   }
14589   with_right_paren(right_paren){
14590     return new FunctionCallExpression(
14591       this.receiver,
14592       this.left_paren,
14593       this.argument_list,
14594       right_paren);
14595   }
14596   rewrite(rewriter, parents)
14597   {
14598     if (parents == undefined)
14599       parents = [];
14600     let new_parents = parents.slice();
14601     new_parents.push(this);
14602     var receiver = this.receiver.rewrite(rewriter, new_parents);
14603     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
14604     var argument_list = this.argument_list.rewrite(rewriter, new_parents);
14605     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
14606     if (
14607       receiver === this.receiver &&
14608       left_paren === this.left_paren &&
14609       argument_list === this.argument_list &&
14610       right_paren === this.right_paren)
14611     {
14612       return rewriter(this, parents);
14613     }
14614     else
14615     {
14616       return rewriter(new FunctionCallExpression(
14617         receiver,
14618         left_paren,
14619         argument_list,
14620         right_paren), parents);
14621     }
14622   }
14623   static from_json(json, position, source)
14624   {
14625     let receiver = EditableSyntax.from_json(
14626       json.function_call_receiver, position, source);
14627     position += receiver.width;
14628     let left_paren = EditableSyntax.from_json(
14629       json.function_call_left_paren, position, source);
14630     position += left_paren.width;
14631     let argument_list = EditableSyntax.from_json(
14632       json.function_call_argument_list, position, source);
14633     position += argument_list.width;
14634     let right_paren = EditableSyntax.from_json(
14635       json.function_call_right_paren, position, source);
14636     position += right_paren.width;
14637     return new FunctionCallExpression(
14638         receiver,
14639         left_paren,
14640         argument_list,
14641         right_paren);
14642   }
14643   get children_keys()
14644   {
14645     if (FunctionCallExpression._children_keys == null)
14646       FunctionCallExpression._children_keys = [
14647         'receiver',
14648         'left_paren',
14649         'argument_list',
14650         'right_paren'];
14651     return FunctionCallExpression._children_keys;
14652   }
14653 }
14654 class FunctionCallWithTypeArgumentsExpression extends EditableSyntax
14655 {
14656   constructor(
14657     receiver,
14658     type_args,
14659     left_paren,
14660     argument_list,
14661     right_paren)
14662   {
14663     super('function_call_with_type_arguments_expression', {
14664       receiver: receiver,
14665       type_args: type_args,
14666       left_paren: left_paren,
14667       argument_list: argument_list,
14668       right_paren: right_paren });
14669   }
14670   get receiver() { return this.children.receiver; }
14671   get type_args() { return this.children.type_args; }
14672   get left_paren() { return this.children.left_paren; }
14673   get argument_list() { return this.children.argument_list; }
14674   get right_paren() { return this.children.right_paren; }
14675   with_receiver(receiver){
14676     return new FunctionCallWithTypeArgumentsExpression(
14677       receiver,
14678       this.type_args,
14679       this.left_paren,
14680       this.argument_list,
14681       this.right_paren);
14682   }
14683   with_type_args(type_args){
14684     return new FunctionCallWithTypeArgumentsExpression(
14685       this.receiver,
14686       type_args,
14687       this.left_paren,
14688       this.argument_list,
14689       this.right_paren);
14690   }
14691   with_left_paren(left_paren){
14692     return new FunctionCallWithTypeArgumentsExpression(
14693       this.receiver,
14694       this.type_args,
14695       left_paren,
14696       this.argument_list,
14697       this.right_paren);
14698   }
14699   with_argument_list(argument_list){
14700     return new FunctionCallWithTypeArgumentsExpression(
14701       this.receiver,
14702       this.type_args,
14703       this.left_paren,
14704       argument_list,
14705       this.right_paren);
14706   }
14707   with_right_paren(right_paren){
14708     return new FunctionCallWithTypeArgumentsExpression(
14709       this.receiver,
14710       this.type_args,
14711       this.left_paren,
14712       this.argument_list,
14713       right_paren);
14714   }
14715   rewrite(rewriter, parents)
14716   {
14717     if (parents == undefined)
14718       parents = [];
14719     let new_parents = parents.slice();
14720     new_parents.push(this);
14721     var receiver = this.receiver.rewrite(rewriter, new_parents);
14722     var type_args = this.type_args.rewrite(rewriter, new_parents);
14723     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
14724     var argument_list = this.argument_list.rewrite(rewriter, new_parents);
14725     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
14726     if (
14727       receiver === this.receiver &&
14728       type_args === this.type_args &&
14729       left_paren === this.left_paren &&
14730       argument_list === this.argument_list &&
14731       right_paren === this.right_paren)
14732     {
14733       return rewriter(this, parents);
14734     }
14735     else
14736     {
14737       return rewriter(new FunctionCallWithTypeArgumentsExpression(
14738         receiver,
14739         type_args,
14740         left_paren,
14741         argument_list,
14742         right_paren), parents);
14743     }
14744   }
14745   static from_json(json, position, source)
14746   {
14747     let receiver = EditableSyntax.from_json(
14748       json.function_call_with_type_arguments_receiver, position, source);
14749     position += receiver.width;
14750     let type_args = EditableSyntax.from_json(
14751       json.function_call_with_type_arguments_type_args, position, source);
14752     position += type_args.width;
14753     let left_paren = EditableSyntax.from_json(
14754       json.function_call_with_type_arguments_left_paren, position, source);
14755     position += left_paren.width;
14756     let argument_list = EditableSyntax.from_json(
14757       json.function_call_with_type_arguments_argument_list, position, source);
14758     position += argument_list.width;
14759     let right_paren = EditableSyntax.from_json(
14760       json.function_call_with_type_arguments_right_paren, position, source);
14761     position += right_paren.width;
14762     return new FunctionCallWithTypeArgumentsExpression(
14763         receiver,
14764         type_args,
14765         left_paren,
14766         argument_list,
14767         right_paren);
14768   }
14769   get children_keys()
14770   {
14771     if (FunctionCallWithTypeArgumentsExpression._children_keys == null)
14772       FunctionCallWithTypeArgumentsExpression._children_keys = [
14773         'receiver',
14774         'type_args',
14775         'left_paren',
14776         'argument_list',
14777         'right_paren'];
14778     return FunctionCallWithTypeArgumentsExpression._children_keys;
14779   }
14780 }
14781 class ParenthesizedExpression extends EditableSyntax
14782 {
14783   constructor(
14784     left_paren,
14785     expression,
14786     right_paren)
14787   {
14788     super('parenthesized_expression', {
14789       left_paren: left_paren,
14790       expression: expression,
14791       right_paren: right_paren });
14792   }
14793   get left_paren() { return this.children.left_paren; }
14794   get expression() { return this.children.expression; }
14795   get right_paren() { return this.children.right_paren; }
14796   with_left_paren(left_paren){
14797     return new ParenthesizedExpression(
14798       left_paren,
14799       this.expression,
14800       this.right_paren);
14801   }
14802   with_expression(expression){
14803     return new ParenthesizedExpression(
14804       this.left_paren,
14805       expression,
14806       this.right_paren);
14807   }
14808   with_right_paren(right_paren){
14809     return new ParenthesizedExpression(
14810       this.left_paren,
14811       this.expression,
14812       right_paren);
14813   }
14814   rewrite(rewriter, parents)
14815   {
14816     if (parents == undefined)
14817       parents = [];
14818     let new_parents = parents.slice();
14819     new_parents.push(this);
14820     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
14821     var expression = this.expression.rewrite(rewriter, new_parents);
14822     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
14823     if (
14824       left_paren === this.left_paren &&
14825       expression === this.expression &&
14826       right_paren === this.right_paren)
14827     {
14828       return rewriter(this, parents);
14829     }
14830     else
14831     {
14832       return rewriter(new ParenthesizedExpression(
14833         left_paren,
14834         expression,
14835         right_paren), parents);
14836     }
14837   }
14838   static from_json(json, position, source)
14839   {
14840     let left_paren = EditableSyntax.from_json(
14841       json.parenthesized_expression_left_paren, position, source);
14842     position += left_paren.width;
14843     let expression = EditableSyntax.from_json(
14844       json.parenthesized_expression_expression, position, source);
14845     position += expression.width;
14846     let right_paren = EditableSyntax.from_json(
14847       json.parenthesized_expression_right_paren, position, source);
14848     position += right_paren.width;
14849     return new ParenthesizedExpression(
14850         left_paren,
14851         expression,
14852         right_paren);
14853   }
14854   get children_keys()
14855   {
14856     if (ParenthesizedExpression._children_keys == null)
14857       ParenthesizedExpression._children_keys = [
14858         'left_paren',
14859         'expression',
14860         'right_paren'];
14861     return ParenthesizedExpression._children_keys;
14862   }
14863 }
14864 class BracedExpression extends EditableSyntax
14865 {
14866   constructor(
14867     left_brace,
14868     expression,
14869     right_brace)
14870   {
14871     super('braced_expression', {
14872       left_brace: left_brace,
14873       expression: expression,
14874       right_brace: right_brace });
14875   }
14876   get left_brace() { return this.children.left_brace; }
14877   get expression() { return this.children.expression; }
14878   get right_brace() { return this.children.right_brace; }
14879   with_left_brace(left_brace){
14880     return new BracedExpression(
14881       left_brace,
14882       this.expression,
14883       this.right_brace);
14884   }
14885   with_expression(expression){
14886     return new BracedExpression(
14887       this.left_brace,
14888       expression,
14889       this.right_brace);
14890   }
14891   with_right_brace(right_brace){
14892     return new BracedExpression(
14893       this.left_brace,
14894       this.expression,
14895       right_brace);
14896   }
14897   rewrite(rewriter, parents)
14898   {
14899     if (parents == undefined)
14900       parents = [];
14901     let new_parents = parents.slice();
14902     new_parents.push(this);
14903     var left_brace = this.left_brace.rewrite(rewriter, new_parents);
14904     var expression = this.expression.rewrite(rewriter, new_parents);
14905     var right_brace = this.right_brace.rewrite(rewriter, new_parents);
14906     if (
14907       left_brace === this.left_brace &&
14908       expression === this.expression &&
14909       right_brace === this.right_brace)
14910     {
14911       return rewriter(this, parents);
14912     }
14913     else
14914     {
14915       return rewriter(new BracedExpression(
14916         left_brace,
14917         expression,
14918         right_brace), parents);
14919     }
14920   }
14921   static from_json(json, position, source)
14922   {
14923     let left_brace = EditableSyntax.from_json(
14924       json.braced_expression_left_brace, position, source);
14925     position += left_brace.width;
14926     let expression = EditableSyntax.from_json(
14927       json.braced_expression_expression, position, source);
14928     position += expression.width;
14929     let right_brace = EditableSyntax.from_json(
14930       json.braced_expression_right_brace, position, source);
14931     position += right_brace.width;
14932     return new BracedExpression(
14933         left_brace,
14934         expression,
14935         right_brace);
14936   }
14937   get children_keys()
14938   {
14939     if (BracedExpression._children_keys == null)
14940       BracedExpression._children_keys = [
14941         'left_brace',
14942         'expression',
14943         'right_brace'];
14944     return BracedExpression._children_keys;
14945   }
14946 }
14947 class EmbeddedBracedExpression extends EditableSyntax
14948 {
14949   constructor(
14950     left_brace,
14951     expression,
14952     right_brace)
14953   {
14954     super('embedded_braced_expression', {
14955       left_brace: left_brace,
14956       expression: expression,
14957       right_brace: right_brace });
14958   }
14959   get left_brace() { return this.children.left_brace; }
14960   get expression() { return this.children.expression; }
14961   get right_brace() { return this.children.right_brace; }
14962   with_left_brace(left_brace){
14963     return new EmbeddedBracedExpression(
14964       left_brace,
14965       this.expression,
14966       this.right_brace);
14967   }
14968   with_expression(expression){
14969     return new EmbeddedBracedExpression(
14970       this.left_brace,
14971       expression,
14972       this.right_brace);
14973   }
14974   with_right_brace(right_brace){
14975     return new EmbeddedBracedExpression(
14976       this.left_brace,
14977       this.expression,
14978       right_brace);
14979   }
14980   rewrite(rewriter, parents)
14981   {
14982     if (parents == undefined)
14983       parents = [];
14984     let new_parents = parents.slice();
14985     new_parents.push(this);
14986     var left_brace = this.left_brace.rewrite(rewriter, new_parents);
14987     var expression = this.expression.rewrite(rewriter, new_parents);
14988     var right_brace = this.right_brace.rewrite(rewriter, new_parents);
14989     if (
14990       left_brace === this.left_brace &&
14991       expression === this.expression &&
14992       right_brace === this.right_brace)
14993     {
14994       return rewriter(this, parents);
14995     }
14996     else
14997     {
14998       return rewriter(new EmbeddedBracedExpression(
14999         left_brace,
15000         expression,
15001         right_brace), parents);
15002     }
15003   }
15004   static from_json(json, position, source)
15005   {
15006     let left_brace = EditableSyntax.from_json(
15007       json.embedded_braced_expression_left_brace, position, source);
15008     position += left_brace.width;
15009     let expression = EditableSyntax.from_json(
15010       json.embedded_braced_expression_expression, position, source);
15011     position += expression.width;
15012     let right_brace = EditableSyntax.from_json(
15013       json.embedded_braced_expression_right_brace, position, source);
15014     position += right_brace.width;
15015     return new EmbeddedBracedExpression(
15016         left_brace,
15017         expression,
15018         right_brace);
15019   }
15020   get children_keys()
15021   {
15022     if (EmbeddedBracedExpression._children_keys == null)
15023       EmbeddedBracedExpression._children_keys = [
15024         'left_brace',
15025         'expression',
15026         'right_brace'];
15027     return EmbeddedBracedExpression._children_keys;
15028   }
15029 }
15030 class ListExpression extends EditableSyntax
15031 {
15032   constructor(
15033     keyword,
15034     left_paren,
15035     members,
15036     right_paren)
15037   {
15038     super('list_expression', {
15039       keyword: keyword,
15040       left_paren: left_paren,
15041       members: members,
15042       right_paren: right_paren });
15043   }
15044   get keyword() { return this.children.keyword; }
15045   get left_paren() { return this.children.left_paren; }
15046   get members() { return this.children.members; }
15047   get right_paren() { return this.children.right_paren; }
15048   with_keyword(keyword){
15049     return new ListExpression(
15050       keyword,
15051       this.left_paren,
15052       this.members,
15053       this.right_paren);
15054   }
15055   with_left_paren(left_paren){
15056     return new ListExpression(
15057       this.keyword,
15058       left_paren,
15059       this.members,
15060       this.right_paren);
15061   }
15062   with_members(members){
15063     return new ListExpression(
15064       this.keyword,
15065       this.left_paren,
15066       members,
15067       this.right_paren);
15068   }
15069   with_right_paren(right_paren){
15070     return new ListExpression(
15071       this.keyword,
15072       this.left_paren,
15073       this.members,
15074       right_paren);
15075   }
15076   rewrite(rewriter, parents)
15077   {
15078     if (parents == undefined)
15079       parents = [];
15080     let new_parents = parents.slice();
15081     new_parents.push(this);
15082     var keyword = this.keyword.rewrite(rewriter, new_parents);
15083     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
15084     var members = this.members.rewrite(rewriter, new_parents);
15085     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
15086     if (
15087       keyword === this.keyword &&
15088       left_paren === this.left_paren &&
15089       members === this.members &&
15090       right_paren === this.right_paren)
15091     {
15092       return rewriter(this, parents);
15093     }
15094     else
15095     {
15096       return rewriter(new ListExpression(
15097         keyword,
15098         left_paren,
15099         members,
15100         right_paren), parents);
15101     }
15102   }
15103   static from_json(json, position, source)
15104   {
15105     let keyword = EditableSyntax.from_json(
15106       json.list_keyword, position, source);
15107     position += keyword.width;
15108     let left_paren = EditableSyntax.from_json(
15109       json.list_left_paren, position, source);
15110     position += left_paren.width;
15111     let members = EditableSyntax.from_json(
15112       json.list_members, position, source);
15113     position += members.width;
15114     let right_paren = EditableSyntax.from_json(
15115       json.list_right_paren, position, source);
15116     position += right_paren.width;
15117     return new ListExpression(
15118         keyword,
15119         left_paren,
15120         members,
15121         right_paren);
15122   }
15123   get children_keys()
15124   {
15125     if (ListExpression._children_keys == null)
15126       ListExpression._children_keys = [
15127         'keyword',
15128         'left_paren',
15129         'members',
15130         'right_paren'];
15131     return ListExpression._children_keys;
15132   }
15133 }
15134 class CollectionLiteralExpression extends EditableSyntax
15135 {
15136   constructor(
15137     name,
15138     left_brace,
15139     initializers,
15140     right_brace)
15141   {
15142     super('collection_literal_expression', {
15143       name: name,
15144       left_brace: left_brace,
15145       initializers: initializers,
15146       right_brace: right_brace });
15147   }
15148   get name() { return this.children.name; }
15149   get left_brace() { return this.children.left_brace; }
15150   get initializers() { return this.children.initializers; }
15151   get right_brace() { return this.children.right_brace; }
15152   with_name(name){
15153     return new CollectionLiteralExpression(
15154       name,
15155       this.left_brace,
15156       this.initializers,
15157       this.right_brace);
15158   }
15159   with_left_brace(left_brace){
15160     return new CollectionLiteralExpression(
15161       this.name,
15162       left_brace,
15163       this.initializers,
15164       this.right_brace);
15165   }
15166   with_initializers(initializers){
15167     return new CollectionLiteralExpression(
15168       this.name,
15169       this.left_brace,
15170       initializers,
15171       this.right_brace);
15172   }
15173   with_right_brace(right_brace){
15174     return new CollectionLiteralExpression(
15175       this.name,
15176       this.left_brace,
15177       this.initializers,
15178       right_brace);
15179   }
15180   rewrite(rewriter, parents)
15181   {
15182     if (parents == undefined)
15183       parents = [];
15184     let new_parents = parents.slice();
15185     new_parents.push(this);
15186     var name = this.name.rewrite(rewriter, new_parents);
15187     var left_brace = this.left_brace.rewrite(rewriter, new_parents);
15188     var initializers = this.initializers.rewrite(rewriter, new_parents);
15189     var right_brace = this.right_brace.rewrite(rewriter, new_parents);
15190     if (
15191       name === this.name &&
15192       left_brace === this.left_brace &&
15193       initializers === this.initializers &&
15194       right_brace === this.right_brace)
15195     {
15196       return rewriter(this, parents);
15197     }
15198     else
15199     {
15200       return rewriter(new CollectionLiteralExpression(
15201         name,
15202         left_brace,
15203         initializers,
15204         right_brace), parents);
15205     }
15206   }
15207   static from_json(json, position, source)
15208   {
15209     let name = EditableSyntax.from_json(
15210       json.collection_literal_name, position, source);
15211     position += name.width;
15212     let left_brace = EditableSyntax.from_json(
15213       json.collection_literal_left_brace, position, source);
15214     position += left_brace.width;
15215     let initializers = EditableSyntax.from_json(
15216       json.collection_literal_initializers, position, source);
15217     position += initializers.width;
15218     let right_brace = EditableSyntax.from_json(
15219       json.collection_literal_right_brace, position, source);
15220     position += right_brace.width;
15221     return new CollectionLiteralExpression(
15222         name,
15223         left_brace,
15224         initializers,
15225         right_brace);
15226   }
15227   get children_keys()
15228   {
15229     if (CollectionLiteralExpression._children_keys == null)
15230       CollectionLiteralExpression._children_keys = [
15231         'name',
15232         'left_brace',
15233         'initializers',
15234         'right_brace'];
15235     return CollectionLiteralExpression._children_keys;
15236   }
15237 }
15238 class ObjectCreationExpression extends EditableSyntax
15239 {
15240   constructor(
15241     new_keyword,
15242     object)
15243   {
15244     super('object_creation_expression', {
15245       new_keyword: new_keyword,
15246       object: object });
15247   }
15248   get new_keyword() { return this.children.new_keyword; }
15249   get object() { return this.children.object; }
15250   with_new_keyword(new_keyword){
15251     return new ObjectCreationExpression(
15252       new_keyword,
15253       this.object);
15254   }
15255   with_object(object){
15256     return new ObjectCreationExpression(
15257       this.new_keyword,
15258       object);
15259   }
15260   rewrite(rewriter, parents)
15261   {
15262     if (parents == undefined)
15263       parents = [];
15264     let new_parents = parents.slice();
15265     new_parents.push(this);
15266     var new_keyword = this.new_keyword.rewrite(rewriter, new_parents);
15267     var object = this.object.rewrite(rewriter, new_parents);
15268     if (
15269       new_keyword === this.new_keyword &&
15270       object === this.object)
15271     {
15272       return rewriter(this, parents);
15273     }
15274     else
15275     {
15276       return rewriter(new ObjectCreationExpression(
15277         new_keyword,
15278         object), parents);
15279     }
15280   }
15281   static from_json(json, position, source)
15282   {
15283     let new_keyword = EditableSyntax.from_json(
15284       json.object_creation_new_keyword, position, source);
15285     position += new_keyword.width;
15286     let object = EditableSyntax.from_json(
15287       json.object_creation_object, position, source);
15288     position += object.width;
15289     return new ObjectCreationExpression(
15290         new_keyword,
15291         object);
15292   }
15293   get children_keys()
15294   {
15295     if (ObjectCreationExpression._children_keys == null)
15296       ObjectCreationExpression._children_keys = [
15297         'new_keyword',
15298         'object'];
15299     return ObjectCreationExpression._children_keys;
15300   }
15301 }
15302 class ConstructorCall extends EditableSyntax
15303 {
15304   constructor(
15305     type,
15306     left_paren,
15307     argument_list,
15308     right_paren)
15309   {
15310     super('constructor_call', {
15311       type: type,
15312       left_paren: left_paren,
15313       argument_list: argument_list,
15314       right_paren: right_paren });
15315   }
15316   get type() { return this.children.type; }
15317   get left_paren() { return this.children.left_paren; }
15318   get argument_list() { return this.children.argument_list; }
15319   get right_paren() { return this.children.right_paren; }
15320   with_type(type){
15321     return new ConstructorCall(
15322       type,
15323       this.left_paren,
15324       this.argument_list,
15325       this.right_paren);
15326   }
15327   with_left_paren(left_paren){
15328     return new ConstructorCall(
15329       this.type,
15330       left_paren,
15331       this.argument_list,
15332       this.right_paren);
15333   }
15334   with_argument_list(argument_list){
15335     return new ConstructorCall(
15336       this.type,
15337       this.left_paren,
15338       argument_list,
15339       this.right_paren);
15340   }
15341   with_right_paren(right_paren){
15342     return new ConstructorCall(
15343       this.type,
15344       this.left_paren,
15345       this.argument_list,
15346       right_paren);
15347   }
15348   rewrite(rewriter, parents)
15349   {
15350     if (parents == undefined)
15351       parents = [];
15352     let new_parents = parents.slice();
15353     new_parents.push(this);
15354     var type = this.type.rewrite(rewriter, new_parents);
15355     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
15356     var argument_list = this.argument_list.rewrite(rewriter, new_parents);
15357     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
15358     if (
15359       type === this.type &&
15360       left_paren === this.left_paren &&
15361       argument_list === this.argument_list &&
15362       right_paren === this.right_paren)
15363     {
15364       return rewriter(this, parents);
15365     }
15366     else
15367     {
15368       return rewriter(new ConstructorCall(
15369         type,
15370         left_paren,
15371         argument_list,
15372         right_paren), parents);
15373     }
15374   }
15375   static from_json(json, position, source)
15376   {
15377     let type = EditableSyntax.from_json(
15378       json.constructor_call_type, position, source);
15379     position += type.width;
15380     let left_paren = EditableSyntax.from_json(
15381       json.constructor_call_left_paren, position, source);
15382     position += left_paren.width;
15383     let argument_list = EditableSyntax.from_json(
15384       json.constructor_call_argument_list, position, source);
15385     position += argument_list.width;
15386     let right_paren = EditableSyntax.from_json(
15387       json.constructor_call_right_paren, position, source);
15388     position += right_paren.width;
15389     return new ConstructorCall(
15390         type,
15391         left_paren,
15392         argument_list,
15393         right_paren);
15394   }
15395   get children_keys()
15396   {
15397     if (ConstructorCall._children_keys == null)
15398       ConstructorCall._children_keys = [
15399         'type',
15400         'left_paren',
15401         'argument_list',
15402         'right_paren'];
15403     return ConstructorCall._children_keys;
15404   }
15405 }
15406 class ArrayCreationExpression extends EditableSyntax
15407 {
15408   constructor(
15409     left_bracket,
15410     members,
15411     right_bracket)
15412   {
15413     super('array_creation_expression', {
15414       left_bracket: left_bracket,
15415       members: members,
15416       right_bracket: right_bracket });
15417   }
15418   get left_bracket() { return this.children.left_bracket; }
15419   get members() { return this.children.members; }
15420   get right_bracket() { return this.children.right_bracket; }
15421   with_left_bracket(left_bracket){
15422     return new ArrayCreationExpression(
15423       left_bracket,
15424       this.members,
15425       this.right_bracket);
15426   }
15427   with_members(members){
15428     return new ArrayCreationExpression(
15429       this.left_bracket,
15430       members,
15431       this.right_bracket);
15432   }
15433   with_right_bracket(right_bracket){
15434     return new ArrayCreationExpression(
15435       this.left_bracket,
15436       this.members,
15437       right_bracket);
15438   }
15439   rewrite(rewriter, parents)
15440   {
15441     if (parents == undefined)
15442       parents = [];
15443     let new_parents = parents.slice();
15444     new_parents.push(this);
15445     var left_bracket = this.left_bracket.rewrite(rewriter, new_parents);
15446     var members = this.members.rewrite(rewriter, new_parents);
15447     var right_bracket = this.right_bracket.rewrite(rewriter, new_parents);
15448     if (
15449       left_bracket === this.left_bracket &&
15450       members === this.members &&
15451       right_bracket === this.right_bracket)
15452     {
15453       return rewriter(this, parents);
15454     }
15455     else
15456     {
15457       return rewriter(new ArrayCreationExpression(
15458         left_bracket,
15459         members,
15460         right_bracket), parents);
15461     }
15462   }
15463   static from_json(json, position, source)
15464   {
15465     let left_bracket = EditableSyntax.from_json(
15466       json.array_creation_left_bracket, position, source);
15467     position += left_bracket.width;
15468     let members = EditableSyntax.from_json(
15469       json.array_creation_members, position, source);
15470     position += members.width;
15471     let right_bracket = EditableSyntax.from_json(
15472       json.array_creation_right_bracket, position, source);
15473     position += right_bracket.width;
15474     return new ArrayCreationExpression(
15475         left_bracket,
15476         members,
15477         right_bracket);
15478   }
15479   get children_keys()
15480   {
15481     if (ArrayCreationExpression._children_keys == null)
15482       ArrayCreationExpression._children_keys = [
15483         'left_bracket',
15484         'members',
15485         'right_bracket'];
15486     return ArrayCreationExpression._children_keys;
15487   }
15488 }
15489 class ArrayIntrinsicExpression extends EditableSyntax
15490 {
15491   constructor(
15492     keyword,
15493     left_paren,
15494     members,
15495     right_paren)
15496   {
15497     super('array_intrinsic_expression', {
15498       keyword: keyword,
15499       left_paren: left_paren,
15500       members: members,
15501       right_paren: right_paren });
15502   }
15503   get keyword() { return this.children.keyword; }
15504   get left_paren() { return this.children.left_paren; }
15505   get members() { return this.children.members; }
15506   get right_paren() { return this.children.right_paren; }
15507   with_keyword(keyword){
15508     return new ArrayIntrinsicExpression(
15509       keyword,
15510       this.left_paren,
15511       this.members,
15512       this.right_paren);
15513   }
15514   with_left_paren(left_paren){
15515     return new ArrayIntrinsicExpression(
15516       this.keyword,
15517       left_paren,
15518       this.members,
15519       this.right_paren);
15520   }
15521   with_members(members){
15522     return new ArrayIntrinsicExpression(
15523       this.keyword,
15524       this.left_paren,
15525       members,
15526       this.right_paren);
15527   }
15528   with_right_paren(right_paren){
15529     return new ArrayIntrinsicExpression(
15530       this.keyword,
15531       this.left_paren,
15532       this.members,
15533       right_paren);
15534   }
15535   rewrite(rewriter, parents)
15536   {
15537     if (parents == undefined)
15538       parents = [];
15539     let new_parents = parents.slice();
15540     new_parents.push(this);
15541     var keyword = this.keyword.rewrite(rewriter, new_parents);
15542     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
15543     var members = this.members.rewrite(rewriter, new_parents);
15544     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
15545     if (
15546       keyword === this.keyword &&
15547       left_paren === this.left_paren &&
15548       members === this.members &&
15549       right_paren === this.right_paren)
15550     {
15551       return rewriter(this, parents);
15552     }
15553     else
15554     {
15555       return rewriter(new ArrayIntrinsicExpression(
15556         keyword,
15557         left_paren,
15558         members,
15559         right_paren), parents);
15560     }
15561   }
15562   static from_json(json, position, source)
15563   {
15564     let keyword = EditableSyntax.from_json(
15565       json.array_intrinsic_keyword, position, source);
15566     position += keyword.width;
15567     let left_paren = EditableSyntax.from_json(
15568       json.array_intrinsic_left_paren, position, source);
15569     position += left_paren.width;
15570     let members = EditableSyntax.from_json(
15571       json.array_intrinsic_members, position, source);
15572     position += members.width;
15573     let right_paren = EditableSyntax.from_json(
15574       json.array_intrinsic_right_paren, position, source);
15575     position += right_paren.width;
15576     return new ArrayIntrinsicExpression(
15577         keyword,
15578         left_paren,
15579         members,
15580         right_paren);
15581   }
15582   get children_keys()
15583   {
15584     if (ArrayIntrinsicExpression._children_keys == null)
15585       ArrayIntrinsicExpression._children_keys = [
15586         'keyword',
15587         'left_paren',
15588         'members',
15589         'right_paren'];
15590     return ArrayIntrinsicExpression._children_keys;
15591   }
15592 }
15593 class DarrayIntrinsicExpression extends EditableSyntax
15594 {
15595   constructor(
15596     keyword,
15597     left_bracket,
15598     members,
15599     right_bracket)
15600   {
15601     super('darray_intrinsic_expression', {
15602       keyword: keyword,
15603       left_bracket: left_bracket,
15604       members: members,
15605       right_bracket: right_bracket });
15606   }
15607   get keyword() { return this.children.keyword; }
15608   get left_bracket() { return this.children.left_bracket; }
15609   get members() { return this.children.members; }
15610   get right_bracket() { return this.children.right_bracket; }
15611   with_keyword(keyword){
15612     return new DarrayIntrinsicExpression(
15613       keyword,
15614       this.left_bracket,
15615       this.members,
15616       this.right_bracket);
15617   }
15618   with_left_bracket(left_bracket){
15619     return new DarrayIntrinsicExpression(
15620       this.keyword,
15621       left_bracket,
15622       this.members,
15623       this.right_bracket);
15624   }
15625   with_members(members){
15626     return new DarrayIntrinsicExpression(
15627       this.keyword,
15628       this.left_bracket,
15629       members,
15630       this.right_bracket);
15631   }
15632   with_right_bracket(right_bracket){
15633     return new DarrayIntrinsicExpression(
15634       this.keyword,
15635       this.left_bracket,
15636       this.members,
15637       right_bracket);
15638   }
15639   rewrite(rewriter, parents)
15640   {
15641     if (parents == undefined)
15642       parents = [];
15643     let new_parents = parents.slice();
15644     new_parents.push(this);
15645     var keyword = this.keyword.rewrite(rewriter, new_parents);
15646     var left_bracket = this.left_bracket.rewrite(rewriter, new_parents);
15647     var members = this.members.rewrite(rewriter, new_parents);
15648     var right_bracket = this.right_bracket.rewrite(rewriter, new_parents);
15649     if (
15650       keyword === this.keyword &&
15651       left_bracket === this.left_bracket &&
15652       members === this.members &&
15653       right_bracket === this.right_bracket)
15654     {
15655       return rewriter(this, parents);
15656     }
15657     else
15658     {
15659       return rewriter(new DarrayIntrinsicExpression(
15660         keyword,
15661         left_bracket,
15662         members,
15663         right_bracket), parents);
15664     }
15665   }
15666   static from_json(json, position, source)
15667   {
15668     let keyword = EditableSyntax.from_json(
15669       json.darray_intrinsic_keyword, position, source);
15670     position += keyword.width;
15671     let left_bracket = EditableSyntax.from_json(
15672       json.darray_intrinsic_left_bracket, position, source);
15673     position += left_bracket.width;
15674     let members = EditableSyntax.from_json(
15675       json.darray_intrinsic_members, position, source);
15676     position += members.width;
15677     let right_bracket = EditableSyntax.from_json(
15678       json.darray_intrinsic_right_bracket, position, source);
15679     position += right_bracket.width;
15680     return new DarrayIntrinsicExpression(
15681         keyword,
15682         left_bracket,
15683         members,
15684         right_bracket);
15685   }
15686   get children_keys()
15687   {
15688     if (DarrayIntrinsicExpression._children_keys == null)
15689       DarrayIntrinsicExpression._children_keys = [
15690         'keyword',
15691         'left_bracket',
15692         'members',
15693         'right_bracket'];
15694     return DarrayIntrinsicExpression._children_keys;
15695   }
15696 }
15697 class DictionaryIntrinsicExpression extends EditableSyntax
15698 {
15699   constructor(
15700     keyword,
15701     left_bracket,
15702     members,
15703     right_bracket)
15704   {
15705     super('dictionary_intrinsic_expression', {
15706       keyword: keyword,
15707       left_bracket: left_bracket,
15708       members: members,
15709       right_bracket: right_bracket });
15710   }
15711   get keyword() { return this.children.keyword; }
15712   get left_bracket() { return this.children.left_bracket; }
15713   get members() { return this.children.members; }
15714   get right_bracket() { return this.children.right_bracket; }
15715   with_keyword(keyword){
15716     return new DictionaryIntrinsicExpression(
15717       keyword,
15718       this.left_bracket,
15719       this.members,
15720       this.right_bracket);
15721   }
15722   with_left_bracket(left_bracket){
15723     return new DictionaryIntrinsicExpression(
15724       this.keyword,
15725       left_bracket,
15726       this.members,
15727       this.right_bracket);
15728   }
15729   with_members(members){
15730     return new DictionaryIntrinsicExpression(
15731       this.keyword,
15732       this.left_bracket,
15733       members,
15734       this.right_bracket);
15735   }
15736   with_right_bracket(right_bracket){
15737     return new DictionaryIntrinsicExpression(
15738       this.keyword,
15739       this.left_bracket,
15740       this.members,
15741       right_bracket);
15742   }
15743   rewrite(rewriter, parents)
15744   {
15745     if (parents == undefined)
15746       parents = [];
15747     let new_parents = parents.slice();
15748     new_parents.push(this);
15749     var keyword = this.keyword.rewrite(rewriter, new_parents);
15750     var left_bracket = this.left_bracket.rewrite(rewriter, new_parents);
15751     var members = this.members.rewrite(rewriter, new_parents);
15752     var right_bracket = this.right_bracket.rewrite(rewriter, new_parents);
15753     if (
15754       keyword === this.keyword &&
15755       left_bracket === this.left_bracket &&
15756       members === this.members &&
15757       right_bracket === this.right_bracket)
15758     {
15759       return rewriter(this, parents);
15760     }
15761     else
15762     {
15763       return rewriter(new DictionaryIntrinsicExpression(
15764         keyword,
15765         left_bracket,
15766         members,
15767         right_bracket), parents);
15768     }
15769   }
15770   static from_json(json, position, source)
15771   {
15772     let keyword = EditableSyntax.from_json(
15773       json.dictionary_intrinsic_keyword, position, source);
15774     position += keyword.width;
15775     let left_bracket = EditableSyntax.from_json(
15776       json.dictionary_intrinsic_left_bracket, position, source);
15777     position += left_bracket.width;
15778     let members = EditableSyntax.from_json(
15779       json.dictionary_intrinsic_members, position, source);
15780     position += members.width;
15781     let right_bracket = EditableSyntax.from_json(
15782       json.dictionary_intrinsic_right_bracket, position, source);
15783     position += right_bracket.width;
15784     return new DictionaryIntrinsicExpression(
15785         keyword,
15786         left_bracket,
15787         members,
15788         right_bracket);
15789   }
15790   get children_keys()
15791   {
15792     if (DictionaryIntrinsicExpression._children_keys == null)
15793       DictionaryIntrinsicExpression._children_keys = [
15794         'keyword',
15795         'left_bracket',
15796         'members',
15797         'right_bracket'];
15798     return DictionaryIntrinsicExpression._children_keys;
15799   }
15800 }
15801 class KeysetIntrinsicExpression extends EditableSyntax
15802 {
15803   constructor(
15804     keyword,
15805     left_bracket,
15806     members,
15807     right_bracket)
15808   {
15809     super('keyset_intrinsic_expression', {
15810       keyword: keyword,
15811       left_bracket: left_bracket,
15812       members: members,
15813       right_bracket: right_bracket });
15814   }
15815   get keyword() { return this.children.keyword; }
15816   get left_bracket() { return this.children.left_bracket; }
15817   get members() { return this.children.members; }
15818   get right_bracket() { return this.children.right_bracket; }
15819   with_keyword(keyword){
15820     return new KeysetIntrinsicExpression(
15821       keyword,
15822       this.left_bracket,
15823       this.members,
15824       this.right_bracket);
15825   }
15826   with_left_bracket(left_bracket){
15827     return new KeysetIntrinsicExpression(
15828       this.keyword,
15829       left_bracket,
15830       this.members,
15831       this.right_bracket);
15832   }
15833   with_members(members){
15834     return new KeysetIntrinsicExpression(
15835       this.keyword,
15836       this.left_bracket,
15837       members,
15838       this.right_bracket);
15839   }
15840   with_right_bracket(right_bracket){
15841     return new KeysetIntrinsicExpression(
15842       this.keyword,
15843       this.left_bracket,
15844       this.members,
15845       right_bracket);
15846   }
15847   rewrite(rewriter, parents)
15848   {
15849     if (parents == undefined)
15850       parents = [];
15851     let new_parents = parents.slice();
15852     new_parents.push(this);
15853     var keyword = this.keyword.rewrite(rewriter, new_parents);
15854     var left_bracket = this.left_bracket.rewrite(rewriter, new_parents);
15855     var members = this.members.rewrite(rewriter, new_parents);
15856     var right_bracket = this.right_bracket.rewrite(rewriter, new_parents);
15857     if (
15858       keyword === this.keyword &&
15859       left_bracket === this.left_bracket &&
15860       members === this.members &&
15861       right_bracket === this.right_bracket)
15862     {
15863       return rewriter(this, parents);
15864     }
15865     else
15866     {
15867       return rewriter(new KeysetIntrinsicExpression(
15868         keyword,
15869         left_bracket,
15870         members,
15871         right_bracket), parents);
15872     }
15873   }
15874   static from_json(json, position, source)
15875   {
15876     let keyword = EditableSyntax.from_json(
15877       json.keyset_intrinsic_keyword, position, source);
15878     position += keyword.width;
15879     let left_bracket = EditableSyntax.from_json(
15880       json.keyset_intrinsic_left_bracket, position, source);
15881     position += left_bracket.width;
15882     let members = EditableSyntax.from_json(
15883       json.keyset_intrinsic_members, position, source);
15884     position += members.width;
15885     let right_bracket = EditableSyntax.from_json(
15886       json.keyset_intrinsic_right_bracket, position, source);
15887     position += right_bracket.width;
15888     return new KeysetIntrinsicExpression(
15889         keyword,
15890         left_bracket,
15891         members,
15892         right_bracket);
15893   }
15894   get children_keys()
15895   {
15896     if (KeysetIntrinsicExpression._children_keys == null)
15897       KeysetIntrinsicExpression._children_keys = [
15898         'keyword',
15899         'left_bracket',
15900         'members',
15901         'right_bracket'];
15902     return KeysetIntrinsicExpression._children_keys;
15903   }
15904 }
15905 class VarrayIntrinsicExpression extends EditableSyntax
15906 {
15907   constructor(
15908     keyword,
15909     left_bracket,
15910     members,
15911     right_bracket)
15912   {
15913     super('varray_intrinsic_expression', {
15914       keyword: keyword,
15915       left_bracket: left_bracket,
15916       members: members,
15917       right_bracket: right_bracket });
15918   }
15919   get keyword() { return this.children.keyword; }
15920   get left_bracket() { return this.children.left_bracket; }
15921   get members() { return this.children.members; }
15922   get right_bracket() { return this.children.right_bracket; }
15923   with_keyword(keyword){
15924     return new VarrayIntrinsicExpression(
15925       keyword,
15926       this.left_bracket,
15927       this.members,
15928       this.right_bracket);
15929   }
15930   with_left_bracket(left_bracket){
15931     return new VarrayIntrinsicExpression(
15932       this.keyword,
15933       left_bracket,
15934       this.members,
15935       this.right_bracket);
15936   }
15937   with_members(members){
15938     return new VarrayIntrinsicExpression(
15939       this.keyword,
15940       this.left_bracket,
15941       members,
15942       this.right_bracket);
15943   }
15944   with_right_bracket(right_bracket){
15945     return new VarrayIntrinsicExpression(
15946       this.keyword,
15947       this.left_bracket,
15948       this.members,
15949       right_bracket);
15950   }
15951   rewrite(rewriter, parents)
15952   {
15953     if (parents == undefined)
15954       parents = [];
15955     let new_parents = parents.slice();
15956     new_parents.push(this);
15957     var keyword = this.keyword.rewrite(rewriter, new_parents);
15958     var left_bracket = this.left_bracket.rewrite(rewriter, new_parents);
15959     var members = this.members.rewrite(rewriter, new_parents);
15960     var right_bracket = this.right_bracket.rewrite(rewriter, new_parents);
15961     if (
15962       keyword === this.keyword &&
15963       left_bracket === this.left_bracket &&
15964       members === this.members &&
15965       right_bracket === this.right_bracket)
15966     {
15967       return rewriter(this, parents);
15968     }
15969     else
15970     {
15971       return rewriter(new VarrayIntrinsicExpression(
15972         keyword,
15973         left_bracket,
15974         members,
15975         right_bracket), parents);
15976     }
15977   }
15978   static from_json(json, position, source)
15979   {
15980     let keyword = EditableSyntax.from_json(
15981       json.varray_intrinsic_keyword, position, source);
15982     position += keyword.width;
15983     let left_bracket = EditableSyntax.from_json(
15984       json.varray_intrinsic_left_bracket, position, source);
15985     position += left_bracket.width;
15986     let members = EditableSyntax.from_json(
15987       json.varray_intrinsic_members, position, source);
15988     position += members.width;
15989     let right_bracket = EditableSyntax.from_json(
15990       json.varray_intrinsic_right_bracket, position, source);
15991     position += right_bracket.width;
15992     return new VarrayIntrinsicExpression(
15993         keyword,
15994         left_bracket,
15995         members,
15996         right_bracket);
15997   }
15998   get children_keys()
15999   {
16000     if (VarrayIntrinsicExpression._children_keys == null)
16001       VarrayIntrinsicExpression._children_keys = [
16002         'keyword',
16003         'left_bracket',
16004         'members',
16005         'right_bracket'];
16006     return VarrayIntrinsicExpression._children_keys;
16007   }
16008 }
16009 class VectorIntrinsicExpression extends EditableSyntax
16010 {
16011   constructor(
16012     keyword,
16013     left_bracket,
16014     members,
16015     right_bracket)
16016   {
16017     super('vector_intrinsic_expression', {
16018       keyword: keyword,
16019       left_bracket: left_bracket,
16020       members: members,
16021       right_bracket: right_bracket });
16022   }
16023   get keyword() { return this.children.keyword; }
16024   get left_bracket() { return this.children.left_bracket; }
16025   get members() { return this.children.members; }
16026   get right_bracket() { return this.children.right_bracket; }
16027   with_keyword(keyword){
16028     return new VectorIntrinsicExpression(
16029       keyword,
16030       this.left_bracket,
16031       this.members,
16032       this.right_bracket);
16033   }
16034   with_left_bracket(left_bracket){
16035     return new VectorIntrinsicExpression(
16036       this.keyword,
16037       left_bracket,
16038       this.members,
16039       this.right_bracket);
16040   }
16041   with_members(members){
16042     return new VectorIntrinsicExpression(
16043       this.keyword,
16044       this.left_bracket,
16045       members,
16046       this.right_bracket);
16047   }
16048   with_right_bracket(right_bracket){
16049     return new VectorIntrinsicExpression(
16050       this.keyword,
16051       this.left_bracket,
16052       this.members,
16053       right_bracket);
16054   }
16055   rewrite(rewriter, parents)
16056   {
16057     if (parents == undefined)
16058       parents = [];
16059     let new_parents = parents.slice();
16060     new_parents.push(this);
16061     var keyword = this.keyword.rewrite(rewriter, new_parents);
16062     var left_bracket = this.left_bracket.rewrite(rewriter, new_parents);
16063     var members = this.members.rewrite(rewriter, new_parents);
16064     var right_bracket = this.right_bracket.rewrite(rewriter, new_parents);
16065     if (
16066       keyword === this.keyword &&
16067       left_bracket === this.left_bracket &&
16068       members === this.members &&
16069       right_bracket === this.right_bracket)
16070     {
16071       return rewriter(this, parents);
16072     }
16073     else
16074     {
16075       return rewriter(new VectorIntrinsicExpression(
16076         keyword,
16077         left_bracket,
16078         members,
16079         right_bracket), parents);
16080     }
16081   }
16082   static from_json(json, position, source)
16083   {
16084     let keyword = EditableSyntax.from_json(
16085       json.vector_intrinsic_keyword, position, source);
16086     position += keyword.width;
16087     let left_bracket = EditableSyntax.from_json(
16088       json.vector_intrinsic_left_bracket, position, source);
16089     position += left_bracket.width;
16090     let members = EditableSyntax.from_json(
16091       json.vector_intrinsic_members, position, source);
16092     position += members.width;
16093     let right_bracket = EditableSyntax.from_json(
16094       json.vector_intrinsic_right_bracket, position, source);
16095     position += right_bracket.width;
16096     return new VectorIntrinsicExpression(
16097         keyword,
16098         left_bracket,
16099         members,
16100         right_bracket);
16101   }
16102   get children_keys()
16103   {
16104     if (VectorIntrinsicExpression._children_keys == null)
16105       VectorIntrinsicExpression._children_keys = [
16106         'keyword',
16107         'left_bracket',
16108         'members',
16109         'right_bracket'];
16110     return VectorIntrinsicExpression._children_keys;
16111   }
16112 }
16113 class ElementInitializer extends EditableSyntax
16114 {
16115   constructor(
16116     key,
16117     arrow,
16118     value)
16119   {
16120     super('element_initializer', {
16121       key: key,
16122       arrow: arrow,
16123       value: value });
16124   }
16125   get key() { return this.children.key; }
16126   get arrow() { return this.children.arrow; }
16127   get value() { return this.children.value; }
16128   with_key(key){
16129     return new ElementInitializer(
16130       key,
16131       this.arrow,
16132       this.value);
16133   }
16134   with_arrow(arrow){
16135     return new ElementInitializer(
16136       this.key,
16137       arrow,
16138       this.value);
16139   }
16140   with_value(value){
16141     return new ElementInitializer(
16142       this.key,
16143       this.arrow,
16144       value);
16145   }
16146   rewrite(rewriter, parents)
16147   {
16148     if (parents == undefined)
16149       parents = [];
16150     let new_parents = parents.slice();
16151     new_parents.push(this);
16152     var key = this.key.rewrite(rewriter, new_parents);
16153     var arrow = this.arrow.rewrite(rewriter, new_parents);
16154     var value = this.value.rewrite(rewriter, new_parents);
16155     if (
16156       key === this.key &&
16157       arrow === this.arrow &&
16158       value === this.value)
16159     {
16160       return rewriter(this, parents);
16161     }
16162     else
16163     {
16164       return rewriter(new ElementInitializer(
16165         key,
16166         arrow,
16167         value), parents);
16168     }
16169   }
16170   static from_json(json, position, source)
16171   {
16172     let key = EditableSyntax.from_json(
16173       json.element_key, position, source);
16174     position += key.width;
16175     let arrow = EditableSyntax.from_json(
16176       json.element_arrow, position, source);
16177     position += arrow.width;
16178     let value = EditableSyntax.from_json(
16179       json.element_value, position, source);
16180     position += value.width;
16181     return new ElementInitializer(
16182         key,
16183         arrow,
16184         value);
16185   }
16186   get children_keys()
16187   {
16188     if (ElementInitializer._children_keys == null)
16189       ElementInitializer._children_keys = [
16190         'key',
16191         'arrow',
16192         'value'];
16193     return ElementInitializer._children_keys;
16194   }
16195 }
16196 class SubscriptExpression extends EditableSyntax
16197 {
16198   constructor(
16199     receiver,
16200     left_bracket,
16201     index,
16202     right_bracket)
16203   {
16204     super('subscript_expression', {
16205       receiver: receiver,
16206       left_bracket: left_bracket,
16207       index: index,
16208       right_bracket: right_bracket });
16209   }
16210   get receiver() { return this.children.receiver; }
16211   get left_bracket() { return this.children.left_bracket; }
16212   get index() { return this.children.index; }
16213   get right_bracket() { return this.children.right_bracket; }
16214   with_receiver(receiver){
16215     return new SubscriptExpression(
16216       receiver,
16217       this.left_bracket,
16218       this.index,
16219       this.right_bracket);
16220   }
16221   with_left_bracket(left_bracket){
16222     return new SubscriptExpression(
16223       this.receiver,
16224       left_bracket,
16225       this.index,
16226       this.right_bracket);
16227   }
16228   with_index(index){
16229     return new SubscriptExpression(
16230       this.receiver,
16231       this.left_bracket,
16232       index,
16233       this.right_bracket);
16234   }
16235   with_right_bracket(right_bracket){
16236     return new SubscriptExpression(
16237       this.receiver,
16238       this.left_bracket,
16239       this.index,
16240       right_bracket);
16241   }
16242   rewrite(rewriter, parents)
16243   {
16244     if (parents == undefined)
16245       parents = [];
16246     let new_parents = parents.slice();
16247     new_parents.push(this);
16248     var receiver = this.receiver.rewrite(rewriter, new_parents);
16249     var left_bracket = this.left_bracket.rewrite(rewriter, new_parents);
16250     var index = this.index.rewrite(rewriter, new_parents);
16251     var right_bracket = this.right_bracket.rewrite(rewriter, new_parents);
16252     if (
16253       receiver === this.receiver &&
16254       left_bracket === this.left_bracket &&
16255       index === this.index &&
16256       right_bracket === this.right_bracket)
16257     {
16258       return rewriter(this, parents);
16259     }
16260     else
16261     {
16262       return rewriter(new SubscriptExpression(
16263         receiver,
16264         left_bracket,
16265         index,
16266         right_bracket), parents);
16267     }
16268   }
16269   static from_json(json, position, source)
16270   {
16271     let receiver = EditableSyntax.from_json(
16272       json.subscript_receiver, position, source);
16273     position += receiver.width;
16274     let left_bracket = EditableSyntax.from_json(
16275       json.subscript_left_bracket, position, source);
16276     position += left_bracket.width;
16277     let index = EditableSyntax.from_json(
16278       json.subscript_index, position, source);
16279     position += index.width;
16280     let right_bracket = EditableSyntax.from_json(
16281       json.subscript_right_bracket, position, source);
16282     position += right_bracket.width;
16283     return new SubscriptExpression(
16284         receiver,
16285         left_bracket,
16286         index,
16287         right_bracket);
16288   }
16289   get children_keys()
16290   {
16291     if (SubscriptExpression._children_keys == null)
16292       SubscriptExpression._children_keys = [
16293         'receiver',
16294         'left_bracket',
16295         'index',
16296         'right_bracket'];
16297     return SubscriptExpression._children_keys;
16298   }
16299 }
16300 class EmbeddedSubscriptExpression extends EditableSyntax
16301 {
16302   constructor(
16303     receiver,
16304     left_bracket,
16305     index,
16306     right_bracket)
16307   {
16308     super('embedded_subscript_expression', {
16309       receiver: receiver,
16310       left_bracket: left_bracket,
16311       index: index,
16312       right_bracket: right_bracket });
16313   }
16314   get receiver() { return this.children.receiver; }
16315   get left_bracket() { return this.children.left_bracket; }
16316   get index() { return this.children.index; }
16317   get right_bracket() { return this.children.right_bracket; }
16318   with_receiver(receiver){
16319     return new EmbeddedSubscriptExpression(
16320       receiver,
16321       this.left_bracket,
16322       this.index,
16323       this.right_bracket);
16324   }
16325   with_left_bracket(left_bracket){
16326     return new EmbeddedSubscriptExpression(
16327       this.receiver,
16328       left_bracket,
16329       this.index,
16330       this.right_bracket);
16331   }
16332   with_index(index){
16333     return new EmbeddedSubscriptExpression(
16334       this.receiver,
16335       this.left_bracket,
16336       index,
16337       this.right_bracket);
16338   }
16339   with_right_bracket(right_bracket){
16340     return new EmbeddedSubscriptExpression(
16341       this.receiver,
16342       this.left_bracket,
16343       this.index,
16344       right_bracket);
16345   }
16346   rewrite(rewriter, parents)
16347   {
16348     if (parents == undefined)
16349       parents = [];
16350     let new_parents = parents.slice();
16351     new_parents.push(this);
16352     var receiver = this.receiver.rewrite(rewriter, new_parents);
16353     var left_bracket = this.left_bracket.rewrite(rewriter, new_parents);
16354     var index = this.index.rewrite(rewriter, new_parents);
16355     var right_bracket = this.right_bracket.rewrite(rewriter, new_parents);
16356     if (
16357       receiver === this.receiver &&
16358       left_bracket === this.left_bracket &&
16359       index === this.index &&
16360       right_bracket === this.right_bracket)
16361     {
16362       return rewriter(this, parents);
16363     }
16364     else
16365     {
16366       return rewriter(new EmbeddedSubscriptExpression(
16367         receiver,
16368         left_bracket,
16369         index,
16370         right_bracket), parents);
16371     }
16372   }
16373   static from_json(json, position, source)
16374   {
16375     let receiver = EditableSyntax.from_json(
16376       json.embedded_subscript_receiver, position, source);
16377     position += receiver.width;
16378     let left_bracket = EditableSyntax.from_json(
16379       json.embedded_subscript_left_bracket, position, source);
16380     position += left_bracket.width;
16381     let index = EditableSyntax.from_json(
16382       json.embedded_subscript_index, position, source);
16383     position += index.width;
16384     let right_bracket = EditableSyntax.from_json(
16385       json.embedded_subscript_right_bracket, position, source);
16386     position += right_bracket.width;
16387     return new EmbeddedSubscriptExpression(
16388         receiver,
16389         left_bracket,
16390         index,
16391         right_bracket);
16392   }
16393   get children_keys()
16394   {
16395     if (EmbeddedSubscriptExpression._children_keys == null)
16396       EmbeddedSubscriptExpression._children_keys = [
16397         'receiver',
16398         'left_bracket',
16399         'index',
16400         'right_bracket'];
16401     return EmbeddedSubscriptExpression._children_keys;
16402   }
16403 }
16404 class AwaitableCreationExpression extends EditableSyntax
16405 {
16406   constructor(
16407     async,
16408     coroutine,
16409     compound_statement)
16410   {
16411     super('awaitable_creation_expression', {
16412       async: async,
16413       coroutine: coroutine,
16414       compound_statement: compound_statement });
16415   }
16416   get async() { return this.children.async; }
16417   get coroutine() { return this.children.coroutine; }
16418   get compound_statement() { return this.children.compound_statement; }
16419   with_async(async){
16420     return new AwaitableCreationExpression(
16421       async,
16422       this.coroutine,
16423       this.compound_statement);
16424   }
16425   with_coroutine(coroutine){
16426     return new AwaitableCreationExpression(
16427       this.async,
16428       coroutine,
16429       this.compound_statement);
16430   }
16431   with_compound_statement(compound_statement){
16432     return new AwaitableCreationExpression(
16433       this.async,
16434       this.coroutine,
16435       compound_statement);
16436   }
16437   rewrite(rewriter, parents)
16438   {
16439     if (parents == undefined)
16440       parents = [];
16441     let new_parents = parents.slice();
16442     new_parents.push(this);
16443     var async = this.async.rewrite(rewriter, new_parents);
16444     var coroutine = this.coroutine.rewrite(rewriter, new_parents);
16445     var compound_statement = this.compound_statement.rewrite(rewriter, new_parents);
16446     if (
16447       async === this.async &&
16448       coroutine === this.coroutine &&
16449       compound_statement === this.compound_statement)
16450     {
16451       return rewriter(this, parents);
16452     }
16453     else
16454     {
16455       return rewriter(new AwaitableCreationExpression(
16456         async,
16457         coroutine,
16458         compound_statement), parents);
16459     }
16460   }
16461   static from_json(json, position, source)
16462   {
16463     let async = EditableSyntax.from_json(
16464       json.awaitable_async, position, source);
16465     position += async.width;
16466     let coroutine = EditableSyntax.from_json(
16467       json.awaitable_coroutine, position, source);
16468     position += coroutine.width;
16469     let compound_statement = EditableSyntax.from_json(
16470       json.awaitable_compound_statement, position, source);
16471     position += compound_statement.width;
16472     return new AwaitableCreationExpression(
16473         async,
16474         coroutine,
16475         compound_statement);
16476   }
16477   get children_keys()
16478   {
16479     if (AwaitableCreationExpression._children_keys == null)
16480       AwaitableCreationExpression._children_keys = [
16481         'async',
16482         'coroutine',
16483         'compound_statement'];
16484     return AwaitableCreationExpression._children_keys;
16485   }
16486 }
16487 class XHPChildrenDeclaration extends EditableSyntax
16488 {
16489   constructor(
16490     keyword,
16491     expression,
16492     semicolon)
16493   {
16494     super('xhp_children_declaration', {
16495       keyword: keyword,
16496       expression: expression,
16497       semicolon: semicolon });
16498   }
16499   get keyword() { return this.children.keyword; }
16500   get expression() { return this.children.expression; }
16501   get semicolon() { return this.children.semicolon; }
16502   with_keyword(keyword){
16503     return new XHPChildrenDeclaration(
16504       keyword,
16505       this.expression,
16506       this.semicolon);
16507   }
16508   with_expression(expression){
16509     return new XHPChildrenDeclaration(
16510       this.keyword,
16511       expression,
16512       this.semicolon);
16513   }
16514   with_semicolon(semicolon){
16515     return new XHPChildrenDeclaration(
16516       this.keyword,
16517       this.expression,
16518       semicolon);
16519   }
16520   rewrite(rewriter, parents)
16521   {
16522     if (parents == undefined)
16523       parents = [];
16524     let new_parents = parents.slice();
16525     new_parents.push(this);
16526     var keyword = this.keyword.rewrite(rewriter, new_parents);
16527     var expression = this.expression.rewrite(rewriter, new_parents);
16528     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
16529     if (
16530       keyword === this.keyword &&
16531       expression === this.expression &&
16532       semicolon === this.semicolon)
16533     {
16534       return rewriter(this, parents);
16535     }
16536     else
16537     {
16538       return rewriter(new XHPChildrenDeclaration(
16539         keyword,
16540         expression,
16541         semicolon), parents);
16542     }
16543   }
16544   static from_json(json, position, source)
16545   {
16546     let keyword = EditableSyntax.from_json(
16547       json.xhp_children_keyword, position, source);
16548     position += keyword.width;
16549     let expression = EditableSyntax.from_json(
16550       json.xhp_children_expression, position, source);
16551     position += expression.width;
16552     let semicolon = EditableSyntax.from_json(
16553       json.xhp_children_semicolon, position, source);
16554     position += semicolon.width;
16555     return new XHPChildrenDeclaration(
16556         keyword,
16557         expression,
16558         semicolon);
16559   }
16560   get children_keys()
16561   {
16562     if (XHPChildrenDeclaration._children_keys == null)
16563       XHPChildrenDeclaration._children_keys = [
16564         'keyword',
16565         'expression',
16566         'semicolon'];
16567     return XHPChildrenDeclaration._children_keys;
16568   }
16569 }
16570 class XHPChildrenParenthesizedList extends EditableSyntax
16571 {
16572   constructor(
16573     left_paren,
16574     xhp_children,
16575     right_paren)
16576   {
16577     super('xhp_children_parenthesized_list', {
16578       left_paren: left_paren,
16579       xhp_children: xhp_children,
16580       right_paren: right_paren });
16581   }
16582   get left_paren() { return this.children.left_paren; }
16583   get xhp_children() { return this.children.xhp_children; }
16584   get right_paren() { return this.children.right_paren; }
16585   with_left_paren(left_paren){
16586     return new XHPChildrenParenthesizedList(
16587       left_paren,
16588       this.xhp_children,
16589       this.right_paren);
16590   }
16591   with_xhp_children(xhp_children){
16592     return new XHPChildrenParenthesizedList(
16593       this.left_paren,
16594       xhp_children,
16595       this.right_paren);
16596   }
16597   with_right_paren(right_paren){
16598     return new XHPChildrenParenthesizedList(
16599       this.left_paren,
16600       this.xhp_children,
16601       right_paren);
16602   }
16603   rewrite(rewriter, parents)
16604   {
16605     if (parents == undefined)
16606       parents = [];
16607     let new_parents = parents.slice();
16608     new_parents.push(this);
16609     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
16610     var xhp_children = this.xhp_children.rewrite(rewriter, new_parents);
16611     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
16612     if (
16613       left_paren === this.left_paren &&
16614       xhp_children === this.xhp_children &&
16615       right_paren === this.right_paren)
16616     {
16617       return rewriter(this, parents);
16618     }
16619     else
16620     {
16621       return rewriter(new XHPChildrenParenthesizedList(
16622         left_paren,
16623         xhp_children,
16624         right_paren), parents);
16625     }
16626   }
16627   static from_json(json, position, source)
16628   {
16629     let left_paren = EditableSyntax.from_json(
16630       json.xhp_children_list_left_paren, position, source);
16631     position += left_paren.width;
16632     let xhp_children = EditableSyntax.from_json(
16633       json.xhp_children_list_xhp_children, position, source);
16634     position += xhp_children.width;
16635     let right_paren = EditableSyntax.from_json(
16636       json.xhp_children_list_right_paren, position, source);
16637     position += right_paren.width;
16638     return new XHPChildrenParenthesizedList(
16639         left_paren,
16640         xhp_children,
16641         right_paren);
16642   }
16643   get children_keys()
16644   {
16645     if (XHPChildrenParenthesizedList._children_keys == null)
16646       XHPChildrenParenthesizedList._children_keys = [
16647         'left_paren',
16648         'xhp_children',
16649         'right_paren'];
16650     return XHPChildrenParenthesizedList._children_keys;
16651   }
16652 }
16653 class XHPCategoryDeclaration extends EditableSyntax
16654 {
16655   constructor(
16656     keyword,
16657     categories,
16658     semicolon)
16659   {
16660     super('xhp_category_declaration', {
16661       keyword: keyword,
16662       categories: categories,
16663       semicolon: semicolon });
16664   }
16665   get keyword() { return this.children.keyword; }
16666   get categories() { return this.children.categories; }
16667   get semicolon() { return this.children.semicolon; }
16668   with_keyword(keyword){
16669     return new XHPCategoryDeclaration(
16670       keyword,
16671       this.categories,
16672       this.semicolon);
16673   }
16674   with_categories(categories){
16675     return new XHPCategoryDeclaration(
16676       this.keyword,
16677       categories,
16678       this.semicolon);
16679   }
16680   with_semicolon(semicolon){
16681     return new XHPCategoryDeclaration(
16682       this.keyword,
16683       this.categories,
16684       semicolon);
16685   }
16686   rewrite(rewriter, parents)
16687   {
16688     if (parents == undefined)
16689       parents = [];
16690     let new_parents = parents.slice();
16691     new_parents.push(this);
16692     var keyword = this.keyword.rewrite(rewriter, new_parents);
16693     var categories = this.categories.rewrite(rewriter, new_parents);
16694     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
16695     if (
16696       keyword === this.keyword &&
16697       categories === this.categories &&
16698       semicolon === this.semicolon)
16699     {
16700       return rewriter(this, parents);
16701     }
16702     else
16703     {
16704       return rewriter(new XHPCategoryDeclaration(
16705         keyword,
16706         categories,
16707         semicolon), parents);
16708     }
16709   }
16710   static from_json(json, position, source)
16711   {
16712     let keyword = EditableSyntax.from_json(
16713       json.xhp_category_keyword, position, source);
16714     position += keyword.width;
16715     let categories = EditableSyntax.from_json(
16716       json.xhp_category_categories, position, source);
16717     position += categories.width;
16718     let semicolon = EditableSyntax.from_json(
16719       json.xhp_category_semicolon, position, source);
16720     position += semicolon.width;
16721     return new XHPCategoryDeclaration(
16722         keyword,
16723         categories,
16724         semicolon);
16725   }
16726   get children_keys()
16727   {
16728     if (XHPCategoryDeclaration._children_keys == null)
16729       XHPCategoryDeclaration._children_keys = [
16730         'keyword',
16731         'categories',
16732         'semicolon'];
16733     return XHPCategoryDeclaration._children_keys;
16734   }
16735 }
16736 class XHPEnumType extends EditableSyntax
16737 {
16738   constructor(
16739     optional,
16740     keyword,
16741     left_brace,
16742     values,
16743     right_brace)
16744   {
16745     super('xhp_enum_type', {
16746       optional: optional,
16747       keyword: keyword,
16748       left_brace: left_brace,
16749       values: values,
16750       right_brace: right_brace });
16751   }
16752   get optional() { return this.children.optional; }
16753   get keyword() { return this.children.keyword; }
16754   get left_brace() { return this.children.left_brace; }
16755   get values() { return this.children.values; }
16756   get right_brace() { return this.children.right_brace; }
16757   with_optional(optional){
16758     return new XHPEnumType(
16759       optional,
16760       this.keyword,
16761       this.left_brace,
16762       this.values,
16763       this.right_brace);
16764   }
16765   with_keyword(keyword){
16766     return new XHPEnumType(
16767       this.optional,
16768       keyword,
16769       this.left_brace,
16770       this.values,
16771       this.right_brace);
16772   }
16773   with_left_brace(left_brace){
16774     return new XHPEnumType(
16775       this.optional,
16776       this.keyword,
16777       left_brace,
16778       this.values,
16779       this.right_brace);
16780   }
16781   with_values(values){
16782     return new XHPEnumType(
16783       this.optional,
16784       this.keyword,
16785       this.left_brace,
16786       values,
16787       this.right_brace);
16788   }
16789   with_right_brace(right_brace){
16790     return new XHPEnumType(
16791       this.optional,
16792       this.keyword,
16793       this.left_brace,
16794       this.values,
16795       right_brace);
16796   }
16797   rewrite(rewriter, parents)
16798   {
16799     if (parents == undefined)
16800       parents = [];
16801     let new_parents = parents.slice();
16802     new_parents.push(this);
16803     var optional = this.optional.rewrite(rewriter, new_parents);
16804     var keyword = this.keyword.rewrite(rewriter, new_parents);
16805     var left_brace = this.left_brace.rewrite(rewriter, new_parents);
16806     var values = this.values.rewrite(rewriter, new_parents);
16807     var right_brace = this.right_brace.rewrite(rewriter, new_parents);
16808     if (
16809       optional === this.optional &&
16810       keyword === this.keyword &&
16811       left_brace === this.left_brace &&
16812       values === this.values &&
16813       right_brace === this.right_brace)
16814     {
16815       return rewriter(this, parents);
16816     }
16817     else
16818     {
16819       return rewriter(new XHPEnumType(
16820         optional,
16821         keyword,
16822         left_brace,
16823         values,
16824         right_brace), parents);
16825     }
16826   }
16827   static from_json(json, position, source)
16828   {
16829     let optional = EditableSyntax.from_json(
16830       json.xhp_enum_optional, position, source);
16831     position += optional.width;
16832     let keyword = EditableSyntax.from_json(
16833       json.xhp_enum_keyword, position, source);
16834     position += keyword.width;
16835     let left_brace = EditableSyntax.from_json(
16836       json.xhp_enum_left_brace, position, source);
16837     position += left_brace.width;
16838     let values = EditableSyntax.from_json(
16839       json.xhp_enum_values, position, source);
16840     position += values.width;
16841     let right_brace = EditableSyntax.from_json(
16842       json.xhp_enum_right_brace, position, source);
16843     position += right_brace.width;
16844     return new XHPEnumType(
16845         optional,
16846         keyword,
16847         left_brace,
16848         values,
16849         right_brace);
16850   }
16851   get children_keys()
16852   {
16853     if (XHPEnumType._children_keys == null)
16854       XHPEnumType._children_keys = [
16855         'optional',
16856         'keyword',
16857         'left_brace',
16858         'values',
16859         'right_brace'];
16860     return XHPEnumType._children_keys;
16861   }
16862 }
16863 class XHPRequired extends EditableSyntax
16864 {
16865   constructor(
16866     at,
16867     keyword)
16868   {
16869     super('xhp_required', {
16870       at: at,
16871       keyword: keyword });
16872   }
16873   get at() { return this.children.at; }
16874   get keyword() { return this.children.keyword; }
16875   with_at(at){
16876     return new XHPRequired(
16877       at,
16878       this.keyword);
16879   }
16880   with_keyword(keyword){
16881     return new XHPRequired(
16882       this.at,
16883       keyword);
16884   }
16885   rewrite(rewriter, parents)
16886   {
16887     if (parents == undefined)
16888       parents = [];
16889     let new_parents = parents.slice();
16890     new_parents.push(this);
16891     var at = this.at.rewrite(rewriter, new_parents);
16892     var keyword = this.keyword.rewrite(rewriter, new_parents);
16893     if (
16894       at === this.at &&
16895       keyword === this.keyword)
16896     {
16897       return rewriter(this, parents);
16898     }
16899     else
16900     {
16901       return rewriter(new XHPRequired(
16902         at,
16903         keyword), parents);
16904     }
16905   }
16906   static from_json(json, position, source)
16907   {
16908     let at = EditableSyntax.from_json(
16909       json.xhp_required_at, position, source);
16910     position += at.width;
16911     let keyword = EditableSyntax.from_json(
16912       json.xhp_required_keyword, position, source);
16913     position += keyword.width;
16914     return new XHPRequired(
16915         at,
16916         keyword);
16917   }
16918   get children_keys()
16919   {
16920     if (XHPRequired._children_keys == null)
16921       XHPRequired._children_keys = [
16922         'at',
16923         'keyword'];
16924     return XHPRequired._children_keys;
16925   }
16926 }
16927 class XHPClassAttributeDeclaration extends EditableSyntax
16928 {
16929   constructor(
16930     keyword,
16931     attributes,
16932     semicolon)
16933   {
16934     super('xhp_class_attribute_declaration', {
16935       keyword: keyword,
16936       attributes: attributes,
16937       semicolon: semicolon });
16938   }
16939   get keyword() { return this.children.keyword; }
16940   get attributes() { return this.children.attributes; }
16941   get semicolon() { return this.children.semicolon; }
16942   with_keyword(keyword){
16943     return new XHPClassAttributeDeclaration(
16944       keyword,
16945       this.attributes,
16946       this.semicolon);
16947   }
16948   with_attributes(attributes){
16949     return new XHPClassAttributeDeclaration(
16950       this.keyword,
16951       attributes,
16952       this.semicolon);
16953   }
16954   with_semicolon(semicolon){
16955     return new XHPClassAttributeDeclaration(
16956       this.keyword,
16957       this.attributes,
16958       semicolon);
16959   }
16960   rewrite(rewriter, parents)
16961   {
16962     if (parents == undefined)
16963       parents = [];
16964     let new_parents = parents.slice();
16965     new_parents.push(this);
16966     var keyword = this.keyword.rewrite(rewriter, new_parents);
16967     var attributes = this.attributes.rewrite(rewriter, new_parents);
16968     var semicolon = this.semicolon.rewrite(rewriter, new_parents);
16969     if (
16970       keyword === this.keyword &&
16971       attributes === this.attributes &&
16972       semicolon === this.semicolon)
16973     {
16974       return rewriter(this, parents);
16975     }
16976     else
16977     {
16978       return rewriter(new XHPClassAttributeDeclaration(
16979         keyword,
16980         attributes,
16981         semicolon), parents);
16982     }
16983   }
16984   static from_json(json, position, source)
16985   {
16986     let keyword = EditableSyntax.from_json(
16987       json.xhp_attribute_keyword, position, source);
16988     position += keyword.width;
16989     let attributes = EditableSyntax.from_json(
16990       json.xhp_attribute_attributes, position, source);
16991     position += attributes.width;
16992     let semicolon = EditableSyntax.from_json(
16993       json.xhp_attribute_semicolon, position, source);
16994     position += semicolon.width;
16995     return new XHPClassAttributeDeclaration(
16996         keyword,
16997         attributes,
16998         semicolon);
16999   }
17000   get children_keys()
17001   {
17002     if (XHPClassAttributeDeclaration._children_keys == null)
17003       XHPClassAttributeDeclaration._children_keys = [
17004         'keyword',
17005         'attributes',
17006         'semicolon'];
17007     return XHPClassAttributeDeclaration._children_keys;
17008   }
17009 }
17010 class XHPClassAttribute extends EditableSyntax
17011 {
17012   constructor(
17013     type,
17014     name,
17015     initializer,
17016     required)
17017   {
17018     super('xhp_class_attribute', {
17019       type: type,
17020       name: name,
17021       initializer: initializer,
17022       required: required });
17023   }
17024   get type() { return this.children.type; }
17025   get name() { return this.children.name; }
17026   get initializer() { return this.children.initializer; }
17027   get required() { return this.children.required; }
17028   with_type(type){
17029     return new XHPClassAttribute(
17030       type,
17031       this.name,
17032       this.initializer,
17033       this.required);
17034   }
17035   with_name(name){
17036     return new XHPClassAttribute(
17037       this.type,
17038       name,
17039       this.initializer,
17040       this.required);
17041   }
17042   with_initializer(initializer){
17043     return new XHPClassAttribute(
17044       this.type,
17045       this.name,
17046       initializer,
17047       this.required);
17048   }
17049   with_required(required){
17050     return new XHPClassAttribute(
17051       this.type,
17052       this.name,
17053       this.initializer,
17054       required);
17055   }
17056   rewrite(rewriter, parents)
17057   {
17058     if (parents == undefined)
17059       parents = [];
17060     let new_parents = parents.slice();
17061     new_parents.push(this);
17062     var type = this.type.rewrite(rewriter, new_parents);
17063     var name = this.name.rewrite(rewriter, new_parents);
17064     var initializer = this.initializer.rewrite(rewriter, new_parents);
17065     var required = this.required.rewrite(rewriter, new_parents);
17066     if (
17067       type === this.type &&
17068       name === this.name &&
17069       initializer === this.initializer &&
17070       required === this.required)
17071     {
17072       return rewriter(this, parents);
17073     }
17074     else
17075     {
17076       return rewriter(new XHPClassAttribute(
17077         type,
17078         name,
17079         initializer,
17080         required), parents);
17081     }
17082   }
17083   static from_json(json, position, source)
17084   {
17085     let type = EditableSyntax.from_json(
17086       json.xhp_attribute_decl_type, position, source);
17087     position += type.width;
17088     let name = EditableSyntax.from_json(
17089       json.xhp_attribute_decl_name, position, source);
17090     position += name.width;
17091     let initializer = EditableSyntax.from_json(
17092       json.xhp_attribute_decl_initializer, position, source);
17093     position += initializer.width;
17094     let required = EditableSyntax.from_json(
17095       json.xhp_attribute_decl_required, position, source);
17096     position += required.width;
17097     return new XHPClassAttribute(
17098         type,
17099         name,
17100         initializer,
17101         required);
17102   }
17103   get children_keys()
17104   {
17105     if (XHPClassAttribute._children_keys == null)
17106       XHPClassAttribute._children_keys = [
17107         'type',
17108         'name',
17109         'initializer',
17110         'required'];
17111     return XHPClassAttribute._children_keys;
17112   }
17113 }
17114 class XHPSimpleClassAttribute extends EditableSyntax
17115 {
17116   constructor(
17117     type)
17118   {
17119     super('xhp_simple_class_attribute', {
17120       type: type });
17121   }
17122   get type() { return this.children.type; }
17123   with_type(type){
17124     return new XHPSimpleClassAttribute(
17125       type);
17126   }
17127   rewrite(rewriter, parents)
17128   {
17129     if (parents == undefined)
17130       parents = [];
17131     let new_parents = parents.slice();
17132     new_parents.push(this);
17133     var type = this.type.rewrite(rewriter, new_parents);
17134     if (
17135       type === this.type)
17136     {
17137       return rewriter(this, parents);
17138     }
17139     else
17140     {
17141       return rewriter(new XHPSimpleClassAttribute(
17142         type), parents);
17143     }
17144   }
17145   static from_json(json, position, source)
17146   {
17147     let type = EditableSyntax.from_json(
17148       json.xhp_simple_class_attribute_type, position, source);
17149     position += type.width;
17150     return new XHPSimpleClassAttribute(
17151         type);
17152   }
17153   get children_keys()
17154   {
17155     if (XHPSimpleClassAttribute._children_keys == null)
17156       XHPSimpleClassAttribute._children_keys = [
17157         'type'];
17158     return XHPSimpleClassAttribute._children_keys;
17159   }
17160 }
17161 class XHPSimpleAttribute extends EditableSyntax
17162 {
17163   constructor(
17164     name,
17165     equal,
17166     expression)
17167   {
17168     super('xhp_simple_attribute', {
17169       name: name,
17170       equal: equal,
17171       expression: expression });
17172   }
17173   get name() { return this.children.name; }
17174   get equal() { return this.children.equal; }
17175   get expression() { return this.children.expression; }
17176   with_name(name){
17177     return new XHPSimpleAttribute(
17178       name,
17179       this.equal,
17180       this.expression);
17181   }
17182   with_equal(equal){
17183     return new XHPSimpleAttribute(
17184       this.name,
17185       equal,
17186       this.expression);
17187   }
17188   with_expression(expression){
17189     return new XHPSimpleAttribute(
17190       this.name,
17191       this.equal,
17192       expression);
17193   }
17194   rewrite(rewriter, parents)
17195   {
17196     if (parents == undefined)
17197       parents = [];
17198     let new_parents = parents.slice();
17199     new_parents.push(this);
17200     var name = this.name.rewrite(rewriter, new_parents);
17201     var equal = this.equal.rewrite(rewriter, new_parents);
17202     var expression = this.expression.rewrite(rewriter, new_parents);
17203     if (
17204       name === this.name &&
17205       equal === this.equal &&
17206       expression === this.expression)
17207     {
17208       return rewriter(this, parents);
17209     }
17210     else
17211     {
17212       return rewriter(new XHPSimpleAttribute(
17213         name,
17214         equal,
17215         expression), parents);
17216     }
17217   }
17218   static from_json(json, position, source)
17219   {
17220     let name = EditableSyntax.from_json(
17221       json.xhp_simple_attribute_name, position, source);
17222     position += name.width;
17223     let equal = EditableSyntax.from_json(
17224       json.xhp_simple_attribute_equal, position, source);
17225     position += equal.width;
17226     let expression = EditableSyntax.from_json(
17227       json.xhp_simple_attribute_expression, position, source);
17228     position += expression.width;
17229     return new XHPSimpleAttribute(
17230         name,
17231         equal,
17232         expression);
17233   }
17234   get children_keys()
17235   {
17236     if (XHPSimpleAttribute._children_keys == null)
17237       XHPSimpleAttribute._children_keys = [
17238         'name',
17239         'equal',
17240         'expression'];
17241     return XHPSimpleAttribute._children_keys;
17242   }
17243 }
17244 class XHPSpreadAttribute extends EditableSyntax
17245 {
17246   constructor(
17247     left_brace,
17248     spread_operator,
17249     expression,
17250     right_brace)
17251   {
17252     super('xhp_spread_attribute', {
17253       left_brace: left_brace,
17254       spread_operator: spread_operator,
17255       expression: expression,
17256       right_brace: right_brace });
17257   }
17258   get left_brace() { return this.children.left_brace; }
17259   get spread_operator() { return this.children.spread_operator; }
17260   get expression() { return this.children.expression; }
17261   get right_brace() { return this.children.right_brace; }
17262   with_left_brace(left_brace){
17263     return new XHPSpreadAttribute(
17264       left_brace,
17265       this.spread_operator,
17266       this.expression,
17267       this.right_brace);
17268   }
17269   with_spread_operator(spread_operator){
17270     return new XHPSpreadAttribute(
17271       this.left_brace,
17272       spread_operator,
17273       this.expression,
17274       this.right_brace);
17275   }
17276   with_expression(expression){
17277     return new XHPSpreadAttribute(
17278       this.left_brace,
17279       this.spread_operator,
17280       expression,
17281       this.right_brace);
17282   }
17283   with_right_brace(right_brace){
17284     return new XHPSpreadAttribute(
17285       this.left_brace,
17286       this.spread_operator,
17287       this.expression,
17288       right_brace);
17289   }
17290   rewrite(rewriter, parents)
17291   {
17292     if (parents == undefined)
17293       parents = [];
17294     let new_parents = parents.slice();
17295     new_parents.push(this);
17296     var left_brace = this.left_brace.rewrite(rewriter, new_parents);
17297     var spread_operator = this.spread_operator.rewrite(rewriter, new_parents);
17298     var expression = this.expression.rewrite(rewriter, new_parents);
17299     var right_brace = this.right_brace.rewrite(rewriter, new_parents);
17300     if (
17301       left_brace === this.left_brace &&
17302       spread_operator === this.spread_operator &&
17303       expression === this.expression &&
17304       right_brace === this.right_brace)
17305     {
17306       return rewriter(this, parents);
17307     }
17308     else
17309     {
17310       return rewriter(new XHPSpreadAttribute(
17311         left_brace,
17312         spread_operator,
17313         expression,
17314         right_brace), parents);
17315     }
17316   }
17317   static from_json(json, position, source)
17318   {
17319     let left_brace = EditableSyntax.from_json(
17320       json.xhp_spread_attribute_left_brace, position, source);
17321     position += left_brace.width;
17322     let spread_operator = EditableSyntax.from_json(
17323       json.xhp_spread_attribute_spread_operator, position, source);
17324     position += spread_operator.width;
17325     let expression = EditableSyntax.from_json(
17326       json.xhp_spread_attribute_expression, position, source);
17327     position += expression.width;
17328     let right_brace = EditableSyntax.from_json(
17329       json.xhp_spread_attribute_right_brace, position, source);
17330     position += right_brace.width;
17331     return new XHPSpreadAttribute(
17332         left_brace,
17333         spread_operator,
17334         expression,
17335         right_brace);
17336   }
17337   get children_keys()
17338   {
17339     if (XHPSpreadAttribute._children_keys == null)
17340       XHPSpreadAttribute._children_keys = [
17341         'left_brace',
17342         'spread_operator',
17343         'expression',
17344         'right_brace'];
17345     return XHPSpreadAttribute._children_keys;
17346   }
17347 }
17348 class XHPOpen extends EditableSyntax
17349 {
17350   constructor(
17351     left_angle,
17352     name,
17353     attributes,
17354     right_angle)
17355   {
17356     super('xhp_open', {
17357       left_angle: left_angle,
17358       name: name,
17359       attributes: attributes,
17360       right_angle: right_angle });
17361   }
17362   get left_angle() { return this.children.left_angle; }
17363   get name() { return this.children.name; }
17364   get attributes() { return this.children.attributes; }
17365   get right_angle() { return this.children.right_angle; }
17366   with_left_angle(left_angle){
17367     return new XHPOpen(
17368       left_angle,
17369       this.name,
17370       this.attributes,
17371       this.right_angle);
17372   }
17373   with_name(name){
17374     return new XHPOpen(
17375       this.left_angle,
17376       name,
17377       this.attributes,
17378       this.right_angle);
17379   }
17380   with_attributes(attributes){
17381     return new XHPOpen(
17382       this.left_angle,
17383       this.name,
17384       attributes,
17385       this.right_angle);
17386   }
17387   with_right_angle(right_angle){
17388     return new XHPOpen(
17389       this.left_angle,
17390       this.name,
17391       this.attributes,
17392       right_angle);
17393   }
17394   rewrite(rewriter, parents)
17395   {
17396     if (parents == undefined)
17397       parents = [];
17398     let new_parents = parents.slice();
17399     new_parents.push(this);
17400     var left_angle = this.left_angle.rewrite(rewriter, new_parents);
17401     var name = this.name.rewrite(rewriter, new_parents);
17402     var attributes = this.attributes.rewrite(rewriter, new_parents);
17403     var right_angle = this.right_angle.rewrite(rewriter, new_parents);
17404     if (
17405       left_angle === this.left_angle &&
17406       name === this.name &&
17407       attributes === this.attributes &&
17408       right_angle === this.right_angle)
17409     {
17410       return rewriter(this, parents);
17411     }
17412     else
17413     {
17414       return rewriter(new XHPOpen(
17415         left_angle,
17416         name,
17417         attributes,
17418         right_angle), parents);
17419     }
17420   }
17421   static from_json(json, position, source)
17422   {
17423     let left_angle = EditableSyntax.from_json(
17424       json.xhp_open_left_angle, position, source);
17425     position += left_angle.width;
17426     let name = EditableSyntax.from_json(
17427       json.xhp_open_name, position, source);
17428     position += name.width;
17429     let attributes = EditableSyntax.from_json(
17430       json.xhp_open_attributes, position, source);
17431     position += attributes.width;
17432     let right_angle = EditableSyntax.from_json(
17433       json.xhp_open_right_angle, position, source);
17434     position += right_angle.width;
17435     return new XHPOpen(
17436         left_angle,
17437         name,
17438         attributes,
17439         right_angle);
17440   }
17441   get children_keys()
17442   {
17443     if (XHPOpen._children_keys == null)
17444       XHPOpen._children_keys = [
17445         'left_angle',
17446         'name',
17447         'attributes',
17448         'right_angle'];
17449     return XHPOpen._children_keys;
17450   }
17451 }
17452 class XHPExpression extends EditableSyntax
17453 {
17454   constructor(
17455     open,
17456     body,
17457     close)
17458   {
17459     super('xhp_expression', {
17460       open: open,
17461       body: body,
17462       close: close });
17463   }
17464   get open() { return this.children.open; }
17465   get body() { return this.children.body; }
17466   get close() { return this.children.close; }
17467   with_open(open){
17468     return new XHPExpression(
17469       open,
17470       this.body,
17471       this.close);
17472   }
17473   with_body(body){
17474     return new XHPExpression(
17475       this.open,
17476       body,
17477       this.close);
17478   }
17479   with_close(close){
17480     return new XHPExpression(
17481       this.open,
17482       this.body,
17483       close);
17484   }
17485   rewrite(rewriter, parents)
17486   {
17487     if (parents == undefined)
17488       parents = [];
17489     let new_parents = parents.slice();
17490     new_parents.push(this);
17491     var open = this.open.rewrite(rewriter, new_parents);
17492     var body = this.body.rewrite(rewriter, new_parents);
17493     var close = this.close.rewrite(rewriter, new_parents);
17494     if (
17495       open === this.open &&
17496       body === this.body &&
17497       close === this.close)
17498     {
17499       return rewriter(this, parents);
17500     }
17501     else
17502     {
17503       return rewriter(new XHPExpression(
17504         open,
17505         body,
17506         close), parents);
17507     }
17508   }
17509   static from_json(json, position, source)
17510   {
17511     let open = EditableSyntax.from_json(
17512       json.xhp_open, position, source);
17513     position += open.width;
17514     let body = EditableSyntax.from_json(
17515       json.xhp_body, position, source);
17516     position += body.width;
17517     let close = EditableSyntax.from_json(
17518       json.xhp_close, position, source);
17519     position += close.width;
17520     return new XHPExpression(
17521         open,
17522         body,
17523         close);
17524   }
17525   get children_keys()
17526   {
17527     if (XHPExpression._children_keys == null)
17528       XHPExpression._children_keys = [
17529         'open',
17530         'body',
17531         'close'];
17532     return XHPExpression._children_keys;
17533   }
17534 }
17535 class XHPClose extends EditableSyntax
17536 {
17537   constructor(
17538     left_angle,
17539     name,
17540     right_angle)
17541   {
17542     super('xhp_close', {
17543       left_angle: left_angle,
17544       name: name,
17545       right_angle: right_angle });
17546   }
17547   get left_angle() { return this.children.left_angle; }
17548   get name() { return this.children.name; }
17549   get right_angle() { return this.children.right_angle; }
17550   with_left_angle(left_angle){
17551     return new XHPClose(
17552       left_angle,
17553       this.name,
17554       this.right_angle);
17555   }
17556   with_name(name){
17557     return new XHPClose(
17558       this.left_angle,
17559       name,
17560       this.right_angle);
17561   }
17562   with_right_angle(right_angle){
17563     return new XHPClose(
17564       this.left_angle,
17565       this.name,
17566       right_angle);
17567   }
17568   rewrite(rewriter, parents)
17569   {
17570     if (parents == undefined)
17571       parents = [];
17572     let new_parents = parents.slice();
17573     new_parents.push(this);
17574     var left_angle = this.left_angle.rewrite(rewriter, new_parents);
17575     var name = this.name.rewrite(rewriter, new_parents);
17576     var right_angle = this.right_angle.rewrite(rewriter, new_parents);
17577     if (
17578       left_angle === this.left_angle &&
17579       name === this.name &&
17580       right_angle === this.right_angle)
17581     {
17582       return rewriter(this, parents);
17583     }
17584     else
17585     {
17586       return rewriter(new XHPClose(
17587         left_angle,
17588         name,
17589         right_angle), parents);
17590     }
17591   }
17592   static from_json(json, position, source)
17593   {
17594     let left_angle = EditableSyntax.from_json(
17595       json.xhp_close_left_angle, position, source);
17596     position += left_angle.width;
17597     let name = EditableSyntax.from_json(
17598       json.xhp_close_name, position, source);
17599     position += name.width;
17600     let right_angle = EditableSyntax.from_json(
17601       json.xhp_close_right_angle, position, source);
17602     position += right_angle.width;
17603     return new XHPClose(
17604         left_angle,
17605         name,
17606         right_angle);
17607   }
17608   get children_keys()
17609   {
17610     if (XHPClose._children_keys == null)
17611       XHPClose._children_keys = [
17612         'left_angle',
17613         'name',
17614         'right_angle'];
17615     return XHPClose._children_keys;
17616   }
17617 }
17618 class TypeConstant extends EditableSyntax
17619 {
17620   constructor(
17621     left_type,
17622     separator,
17623     right_type)
17624   {
17625     super('type_constant', {
17626       left_type: left_type,
17627       separator: separator,
17628       right_type: right_type });
17629   }
17630   get left_type() { return this.children.left_type; }
17631   get separator() { return this.children.separator; }
17632   get right_type() { return this.children.right_type; }
17633   with_left_type(left_type){
17634     return new TypeConstant(
17635       left_type,
17636       this.separator,
17637       this.right_type);
17638   }
17639   with_separator(separator){
17640     return new TypeConstant(
17641       this.left_type,
17642       separator,
17643       this.right_type);
17644   }
17645   with_right_type(right_type){
17646     return new TypeConstant(
17647       this.left_type,
17648       this.separator,
17649       right_type);
17650   }
17651   rewrite(rewriter, parents)
17652   {
17653     if (parents == undefined)
17654       parents = [];
17655     let new_parents = parents.slice();
17656     new_parents.push(this);
17657     var left_type = this.left_type.rewrite(rewriter, new_parents);
17658     var separator = this.separator.rewrite(rewriter, new_parents);
17659     var right_type = this.right_type.rewrite(rewriter, new_parents);
17660     if (
17661       left_type === this.left_type &&
17662       separator === this.separator &&
17663       right_type === this.right_type)
17664     {
17665       return rewriter(this, parents);
17666     }
17667     else
17668     {
17669       return rewriter(new TypeConstant(
17670         left_type,
17671         separator,
17672         right_type), parents);
17673     }
17674   }
17675   static from_json(json, position, source)
17676   {
17677     let left_type = EditableSyntax.from_json(
17678       json.type_constant_left_type, position, source);
17679     position += left_type.width;
17680     let separator = EditableSyntax.from_json(
17681       json.type_constant_separator, position, source);
17682     position += separator.width;
17683     let right_type = EditableSyntax.from_json(
17684       json.type_constant_right_type, position, source);
17685     position += right_type.width;
17686     return new TypeConstant(
17687         left_type,
17688         separator,
17689         right_type);
17690   }
17691   get children_keys()
17692   {
17693     if (TypeConstant._children_keys == null)
17694       TypeConstant._children_keys = [
17695         'left_type',
17696         'separator',
17697         'right_type'];
17698     return TypeConstant._children_keys;
17699   }
17700 }
17701 class VectorTypeSpecifier extends EditableSyntax
17702 {
17703   constructor(
17704     keyword,
17705     left_angle,
17706     type,
17707     trailing_comma,
17708     right_angle)
17709   {
17710     super('vector_type_specifier', {
17711       keyword: keyword,
17712       left_angle: left_angle,
17713       type: type,
17714       trailing_comma: trailing_comma,
17715       right_angle: right_angle });
17716   }
17717   get keyword() { return this.children.keyword; }
17718   get left_angle() { return this.children.left_angle; }
17719   get type() { return this.children.type; }
17720   get trailing_comma() { return this.children.trailing_comma; }
17721   get right_angle() { return this.children.right_angle; }
17722   with_keyword(keyword){
17723     return new VectorTypeSpecifier(
17724       keyword,
17725       this.left_angle,
17726       this.type,
17727       this.trailing_comma,
17728       this.right_angle);
17729   }
17730   with_left_angle(left_angle){
17731     return new VectorTypeSpecifier(
17732       this.keyword,
17733       left_angle,
17734       this.type,
17735       this.trailing_comma,
17736       this.right_angle);
17737   }
17738   with_type(type){
17739     return new VectorTypeSpecifier(
17740       this.keyword,
17741       this.left_angle,
17742       type,
17743       this.trailing_comma,
17744       this.right_angle);
17745   }
17746   with_trailing_comma(trailing_comma){
17747     return new VectorTypeSpecifier(
17748       this.keyword,
17749       this.left_angle,
17750       this.type,
17751       trailing_comma,
17752       this.right_angle);
17753   }
17754   with_right_angle(right_angle){
17755     return new VectorTypeSpecifier(
17756       this.keyword,
17757       this.left_angle,
17758       this.type,
17759       this.trailing_comma,
17760       right_angle);
17761   }
17762   rewrite(rewriter, parents)
17763   {
17764     if (parents == undefined)
17765       parents = [];
17766     let new_parents = parents.slice();
17767     new_parents.push(this);
17768     var keyword = this.keyword.rewrite(rewriter, new_parents);
17769     var left_angle = this.left_angle.rewrite(rewriter, new_parents);
17770     var type = this.type.rewrite(rewriter, new_parents);
17771     var trailing_comma = this.trailing_comma.rewrite(rewriter, new_parents);
17772     var right_angle = this.right_angle.rewrite(rewriter, new_parents);
17773     if (
17774       keyword === this.keyword &&
17775       left_angle === this.left_angle &&
17776       type === this.type &&
17777       trailing_comma === this.trailing_comma &&
17778       right_angle === this.right_angle)
17779     {
17780       return rewriter(this, parents);
17781     }
17782     else
17783     {
17784       return rewriter(new VectorTypeSpecifier(
17785         keyword,
17786         left_angle,
17787         type,
17788         trailing_comma,
17789         right_angle), parents);
17790     }
17791   }
17792   static from_json(json, position, source)
17793   {
17794     let keyword = EditableSyntax.from_json(
17795       json.vector_type_keyword, position, source);
17796     position += keyword.width;
17797     let left_angle = EditableSyntax.from_json(
17798       json.vector_type_left_angle, position, source);
17799     position += left_angle.width;
17800     let type = EditableSyntax.from_json(
17801       json.vector_type_type, position, source);
17802     position += type.width;
17803     let trailing_comma = EditableSyntax.from_json(
17804       json.vector_type_trailing_comma, position, source);
17805     position += trailing_comma.width;
17806     let right_angle = EditableSyntax.from_json(
17807       json.vector_type_right_angle, position, source);
17808     position += right_angle.width;
17809     return new VectorTypeSpecifier(
17810         keyword,
17811         left_angle,
17812         type,
17813         trailing_comma,
17814         right_angle);
17815   }
17816   get children_keys()
17817   {
17818     if (VectorTypeSpecifier._children_keys == null)
17819       VectorTypeSpecifier._children_keys = [
17820         'keyword',
17821         'left_angle',
17822         'type',
17823         'trailing_comma',
17824         'right_angle'];
17825     return VectorTypeSpecifier._children_keys;
17826   }
17827 }
17828 class KeysetTypeSpecifier extends EditableSyntax
17829 {
17830   constructor(
17831     keyword,
17832     left_angle,
17833     type,
17834     trailing_comma,
17835     right_angle)
17836   {
17837     super('keyset_type_specifier', {
17838       keyword: keyword,
17839       left_angle: left_angle,
17840       type: type,
17841       trailing_comma: trailing_comma,
17842       right_angle: right_angle });
17843   }
17844   get keyword() { return this.children.keyword; }
17845   get left_angle() { return this.children.left_angle; }
17846   get type() { return this.children.type; }
17847   get trailing_comma() { return this.children.trailing_comma; }
17848   get right_angle() { return this.children.right_angle; }
17849   with_keyword(keyword){
17850     return new KeysetTypeSpecifier(
17851       keyword,
17852       this.left_angle,
17853       this.type,
17854       this.trailing_comma,
17855       this.right_angle);
17856   }
17857   with_left_angle(left_angle){
17858     return new KeysetTypeSpecifier(
17859       this.keyword,
17860       left_angle,
17861       this.type,
17862       this.trailing_comma,
17863       this.right_angle);
17864   }
17865   with_type(type){
17866     return new KeysetTypeSpecifier(
17867       this.keyword,
17868       this.left_angle,
17869       type,
17870       this.trailing_comma,
17871       this.right_angle);
17872   }
17873   with_trailing_comma(trailing_comma){
17874     return new KeysetTypeSpecifier(
17875       this.keyword,
17876       this.left_angle,
17877       this.type,
17878       trailing_comma,
17879       this.right_angle);
17880   }
17881   with_right_angle(right_angle){
17882     return new KeysetTypeSpecifier(
17883       this.keyword,
17884       this.left_angle,
17885       this.type,
17886       this.trailing_comma,
17887       right_angle);
17888   }
17889   rewrite(rewriter, parents)
17890   {
17891     if (parents == undefined)
17892       parents = [];
17893     let new_parents = parents.slice();
17894     new_parents.push(this);
17895     var keyword = this.keyword.rewrite(rewriter, new_parents);
17896     var left_angle = this.left_angle.rewrite(rewriter, new_parents);
17897     var type = this.type.rewrite(rewriter, new_parents);
17898     var trailing_comma = this.trailing_comma.rewrite(rewriter, new_parents);
17899     var right_angle = this.right_angle.rewrite(rewriter, new_parents);
17900     if (
17901       keyword === this.keyword &&
17902       left_angle === this.left_angle &&
17903       type === this.type &&
17904       trailing_comma === this.trailing_comma &&
17905       right_angle === this.right_angle)
17906     {
17907       return rewriter(this, parents);
17908     }
17909     else
17910     {
17911       return rewriter(new KeysetTypeSpecifier(
17912         keyword,
17913         left_angle,
17914         type,
17915         trailing_comma,
17916         right_angle), parents);
17917     }
17918   }
17919   static from_json(json, position, source)
17920   {
17921     let keyword = EditableSyntax.from_json(
17922       json.keyset_type_keyword, position, source);
17923     position += keyword.width;
17924     let left_angle = EditableSyntax.from_json(
17925       json.keyset_type_left_angle, position, source);
17926     position += left_angle.width;
17927     let type = EditableSyntax.from_json(
17928       json.keyset_type_type, position, source);
17929     position += type.width;
17930     let trailing_comma = EditableSyntax.from_json(
17931       json.keyset_type_trailing_comma, position, source);
17932     position += trailing_comma.width;
17933     let right_angle = EditableSyntax.from_json(
17934       json.keyset_type_right_angle, position, source);
17935     position += right_angle.width;
17936     return new KeysetTypeSpecifier(
17937         keyword,
17938         left_angle,
17939         type,
17940         trailing_comma,
17941         right_angle);
17942   }
17943   get children_keys()
17944   {
17945     if (KeysetTypeSpecifier._children_keys == null)
17946       KeysetTypeSpecifier._children_keys = [
17947         'keyword',
17948         'left_angle',
17949         'type',
17950         'trailing_comma',
17951         'right_angle'];
17952     return KeysetTypeSpecifier._children_keys;
17953   }
17954 }
17955 class TupleTypeExplicitSpecifier extends EditableSyntax
17956 {
17957   constructor(
17958     keyword,
17959     left_angle,
17960     types,
17961     right_angle)
17962   {
17963     super('tuple_type_explicit_specifier', {
17964       keyword: keyword,
17965       left_angle: left_angle,
17966       types: types,
17967       right_angle: right_angle });
17968   }
17969   get keyword() { return this.children.keyword; }
17970   get left_angle() { return this.children.left_angle; }
17971   get types() { return this.children.types; }
17972   get right_angle() { return this.children.right_angle; }
17973   with_keyword(keyword){
17974     return new TupleTypeExplicitSpecifier(
17975       keyword,
17976       this.left_angle,
17977       this.types,
17978       this.right_angle);
17979   }
17980   with_left_angle(left_angle){
17981     return new TupleTypeExplicitSpecifier(
17982       this.keyword,
17983       left_angle,
17984       this.types,
17985       this.right_angle);
17986   }
17987   with_types(types){
17988     return new TupleTypeExplicitSpecifier(
17989       this.keyword,
17990       this.left_angle,
17991       types,
17992       this.right_angle);
17993   }
17994   with_right_angle(right_angle){
17995     return new TupleTypeExplicitSpecifier(
17996       this.keyword,
17997       this.left_angle,
17998       this.types,
17999       right_angle);
18000   }
18001   rewrite(rewriter, parents)
18002   {
18003     if (parents == undefined)
18004       parents = [];
18005     let new_parents = parents.slice();
18006     new_parents.push(this);
18007     var keyword = this.keyword.rewrite(rewriter, new_parents);
18008     var left_angle = this.left_angle.rewrite(rewriter, new_parents);
18009     var types = this.types.rewrite(rewriter, new_parents);
18010     var right_angle = this.right_angle.rewrite(rewriter, new_parents);
18011     if (
18012       keyword === this.keyword &&
18013       left_angle === this.left_angle &&
18014       types === this.types &&
18015       right_angle === this.right_angle)
18016     {
18017       return rewriter(this, parents);
18018     }
18019     else
18020     {
18021       return rewriter(new TupleTypeExplicitSpecifier(
18022         keyword,
18023         left_angle,
18024         types,
18025         right_angle), parents);
18026     }
18027   }
18028   static from_json(json, position, source)
18029   {
18030     let keyword = EditableSyntax.from_json(
18031       json.tuple_type_keyword, position, source);
18032     position += keyword.width;
18033     let left_angle = EditableSyntax.from_json(
18034       json.tuple_type_left_angle, position, source);
18035     position += left_angle.width;
18036     let types = EditableSyntax.from_json(
18037       json.tuple_type_types, position, source);
18038     position += types.width;
18039     let right_angle = EditableSyntax.from_json(
18040       json.tuple_type_right_angle, position, source);
18041     position += right_angle.width;
18042     return new TupleTypeExplicitSpecifier(
18043         keyword,
18044         left_angle,
18045         types,
18046         right_angle);
18047   }
18048   get children_keys()
18049   {
18050     if (TupleTypeExplicitSpecifier._children_keys == null)
18051       TupleTypeExplicitSpecifier._children_keys = [
18052         'keyword',
18053         'left_angle',
18054         'types',
18055         'right_angle'];
18056     return TupleTypeExplicitSpecifier._children_keys;
18057   }
18058 }
18059 class VarrayTypeSpecifier extends EditableSyntax
18060 {
18061   constructor(
18062     keyword,
18063     left_angle,
18064     type,
18065     trailing_comma,
18066     right_angle)
18067   {
18068     super('varray_type_specifier', {
18069       keyword: keyword,
18070       left_angle: left_angle,
18071       type: type,
18072       trailing_comma: trailing_comma,
18073       right_angle: right_angle });
18074   }
18075   get keyword() { return this.children.keyword; }
18076   get left_angle() { return this.children.left_angle; }
18077   get type() { return this.children.type; }
18078   get trailing_comma() { return this.children.trailing_comma; }
18079   get right_angle() { return this.children.right_angle; }
18080   with_keyword(keyword){
18081     return new VarrayTypeSpecifier(
18082       keyword,
18083       this.left_angle,
18084       this.type,
18085       this.trailing_comma,
18086       this.right_angle);
18087   }
18088   with_left_angle(left_angle){
18089     return new VarrayTypeSpecifier(
18090       this.keyword,
18091       left_angle,
18092       this.type,
18093       this.trailing_comma,
18094       this.right_angle);
18095   }
18096   with_type(type){
18097     return new VarrayTypeSpecifier(
18098       this.keyword,
18099       this.left_angle,
18100       type,
18101       this.trailing_comma,
18102       this.right_angle);
18103   }
18104   with_trailing_comma(trailing_comma){
18105     return new VarrayTypeSpecifier(
18106       this.keyword,
18107       this.left_angle,
18108       this.type,
18109       trailing_comma,
18110       this.right_angle);
18111   }
18112   with_right_angle(right_angle){
18113     return new VarrayTypeSpecifier(
18114       this.keyword,
18115       this.left_angle,
18116       this.type,
18117       this.trailing_comma,
18118       right_angle);
18119   }
18120   rewrite(rewriter, parents)
18121   {
18122     if (parents == undefined)
18123       parents = [];
18124     let new_parents = parents.slice();
18125     new_parents.push(this);
18126     var keyword = this.keyword.rewrite(rewriter, new_parents);
18127     var left_angle = this.left_angle.rewrite(rewriter, new_parents);
18128     var type = this.type.rewrite(rewriter, new_parents);
18129     var trailing_comma = this.trailing_comma.rewrite(rewriter, new_parents);
18130     var right_angle = this.right_angle.rewrite(rewriter, new_parents);
18131     if (
18132       keyword === this.keyword &&
18133       left_angle === this.left_angle &&
18134       type === this.type &&
18135       trailing_comma === this.trailing_comma &&
18136       right_angle === this.right_angle)
18137     {
18138       return rewriter(this, parents);
18139     }
18140     else
18141     {
18142       return rewriter(new VarrayTypeSpecifier(
18143         keyword,
18144         left_angle,
18145         type,
18146         trailing_comma,
18147         right_angle), parents);
18148     }
18149   }
18150   static from_json(json, position, source)
18151   {
18152     let keyword = EditableSyntax.from_json(
18153       json.varray_keyword, position, source);
18154     position += keyword.width;
18155     let left_angle = EditableSyntax.from_json(
18156       json.varray_left_angle, position, source);
18157     position += left_angle.width;
18158     let type = EditableSyntax.from_json(
18159       json.varray_type, position, source);
18160     position += type.width;
18161     let trailing_comma = EditableSyntax.from_json(
18162       json.varray_trailing_comma, position, source);
18163     position += trailing_comma.width;
18164     let right_angle = EditableSyntax.from_json(
18165       json.varray_right_angle, position, source);
18166     position += right_angle.width;
18167     return new VarrayTypeSpecifier(
18168         keyword,
18169         left_angle,
18170         type,
18171         trailing_comma,
18172         right_angle);
18173   }
18174   get children_keys()
18175   {
18176     if (VarrayTypeSpecifier._children_keys == null)
18177       VarrayTypeSpecifier._children_keys = [
18178         'keyword',
18179         'left_angle',
18180         'type',
18181         'trailing_comma',
18182         'right_angle'];
18183     return VarrayTypeSpecifier._children_keys;
18184   }
18185 }
18186 class VectorArrayTypeSpecifier extends EditableSyntax
18187 {
18188   constructor(
18189     keyword,
18190     left_angle,
18191     type,
18192     right_angle)
18193   {
18194     super('vector_array_type_specifier', {
18195       keyword: keyword,
18196       left_angle: left_angle,
18197       type: type,
18198       right_angle: right_angle });
18199   }
18200   get keyword() { return this.children.keyword; }
18201   get left_angle() { return this.children.left_angle; }
18202   get type() { return this.children.type; }
18203   get right_angle() { return this.children.right_angle; }
18204   with_keyword(keyword){
18205     return new VectorArrayTypeSpecifier(
18206       keyword,
18207       this.left_angle,
18208       this.type,
18209       this.right_angle);
18210   }
18211   with_left_angle(left_angle){
18212     return new VectorArrayTypeSpecifier(
18213       this.keyword,
18214       left_angle,
18215       this.type,
18216       this.right_angle);
18217   }
18218   with_type(type){
18219     return new VectorArrayTypeSpecifier(
18220       this.keyword,
18221       this.left_angle,
18222       type,
18223       this.right_angle);
18224   }
18225   with_right_angle(right_angle){
18226     return new VectorArrayTypeSpecifier(
18227       this.keyword,
18228       this.left_angle,
18229       this.type,
18230       right_angle);
18231   }
18232   rewrite(rewriter, parents)
18233   {
18234     if (parents == undefined)
18235       parents = [];
18236     let new_parents = parents.slice();
18237     new_parents.push(this);
18238     var keyword = this.keyword.rewrite(rewriter, new_parents);
18239     var left_angle = this.left_angle.rewrite(rewriter, new_parents);
18240     var type = this.type.rewrite(rewriter, new_parents);
18241     var right_angle = this.right_angle.rewrite(rewriter, new_parents);
18242     if (
18243       keyword === this.keyword &&
18244       left_angle === this.left_angle &&
18245       type === this.type &&
18246       right_angle === this.right_angle)
18247     {
18248       return rewriter(this, parents);
18249     }
18250     else
18251     {
18252       return rewriter(new VectorArrayTypeSpecifier(
18253         keyword,
18254         left_angle,
18255         type,
18256         right_angle), parents);
18257     }
18258   }
18259   static from_json(json, position, source)
18260   {
18261     let keyword = EditableSyntax.from_json(
18262       json.vector_array_keyword, position, source);
18263     position += keyword.width;
18264     let left_angle = EditableSyntax.from_json(
18265       json.vector_array_left_angle, position, source);
18266     position += left_angle.width;
18267     let type = EditableSyntax.from_json(
18268       json.vector_array_type, position, source);
18269     position += type.width;
18270     let right_angle = EditableSyntax.from_json(
18271       json.vector_array_right_angle, position, source);
18272     position += right_angle.width;
18273     return new VectorArrayTypeSpecifier(
18274         keyword,
18275         left_angle,
18276         type,
18277         right_angle);
18278   }
18279   get children_keys()
18280   {
18281     if (VectorArrayTypeSpecifier._children_keys == null)
18282       VectorArrayTypeSpecifier._children_keys = [
18283         'keyword',
18284         'left_angle',
18285         'type',
18286         'right_angle'];
18287     return VectorArrayTypeSpecifier._children_keys;
18288   }
18289 }
18290 class TypeParameter extends EditableSyntax
18291 {
18292   constructor(
18293     variance,
18294     name,
18295     constraints)
18296   {
18297     super('type_parameter', {
18298       variance: variance,
18299       name: name,
18300       constraints: constraints });
18301   }
18302   get variance() { return this.children.variance; }
18303   get name() { return this.children.name; }
18304   get constraints() { return this.children.constraints; }
18305   with_variance(variance){
18306     return new TypeParameter(
18307       variance,
18308       this.name,
18309       this.constraints);
18310   }
18311   with_name(name){
18312     return new TypeParameter(
18313       this.variance,
18314       name,
18315       this.constraints);
18316   }
18317   with_constraints(constraints){
18318     return new TypeParameter(
18319       this.variance,
18320       this.name,
18321       constraints);
18322   }
18323   rewrite(rewriter, parents)
18324   {
18325     if (parents == undefined)
18326       parents = [];
18327     let new_parents = parents.slice();
18328     new_parents.push(this);
18329     var variance = this.variance.rewrite(rewriter, new_parents);
18330     var name = this.name.rewrite(rewriter, new_parents);
18331     var constraints = this.constraints.rewrite(rewriter, new_parents);
18332     if (
18333       variance === this.variance &&
18334       name === this.name &&
18335       constraints === this.constraints)
18336     {
18337       return rewriter(this, parents);
18338     }
18339     else
18340     {
18341       return rewriter(new TypeParameter(
18342         variance,
18343         name,
18344         constraints), parents);
18345     }
18346   }
18347   static from_json(json, position, source)
18348   {
18349     let variance = EditableSyntax.from_json(
18350       json.type_variance, position, source);
18351     position += variance.width;
18352     let name = EditableSyntax.from_json(
18353       json.type_name, position, source);
18354     position += name.width;
18355     let constraints = EditableSyntax.from_json(
18356       json.type_constraints, position, source);
18357     position += constraints.width;
18358     return new TypeParameter(
18359         variance,
18360         name,
18361         constraints);
18362   }
18363   get children_keys()
18364   {
18365     if (TypeParameter._children_keys == null)
18366       TypeParameter._children_keys = [
18367         'variance',
18368         'name',
18369         'constraints'];
18370     return TypeParameter._children_keys;
18371   }
18372 }
18373 class TypeConstraint extends EditableSyntax
18374 {
18375   constructor(
18376     keyword,
18377     type)
18378   {
18379     super('type_constraint', {
18380       keyword: keyword,
18381       type: type });
18382   }
18383   get keyword() { return this.children.keyword; }
18384   get type() { return this.children.type; }
18385   with_keyword(keyword){
18386     return new TypeConstraint(
18387       keyword,
18388       this.type);
18389   }
18390   with_type(type){
18391     return new TypeConstraint(
18392       this.keyword,
18393       type);
18394   }
18395   rewrite(rewriter, parents)
18396   {
18397     if (parents == undefined)
18398       parents = [];
18399     let new_parents = parents.slice();
18400     new_parents.push(this);
18401     var keyword = this.keyword.rewrite(rewriter, new_parents);
18402     var type = this.type.rewrite(rewriter, new_parents);
18403     if (
18404       keyword === this.keyword &&
18405       type === this.type)
18406     {
18407       return rewriter(this, parents);
18408     }
18409     else
18410     {
18411       return rewriter(new TypeConstraint(
18412         keyword,
18413         type), parents);
18414     }
18415   }
18416   static from_json(json, position, source)
18417   {
18418     let keyword = EditableSyntax.from_json(
18419       json.constraint_keyword, position, source);
18420     position += keyword.width;
18421     let type = EditableSyntax.from_json(
18422       json.constraint_type, position, source);
18423     position += type.width;
18424     return new TypeConstraint(
18425         keyword,
18426         type);
18427   }
18428   get children_keys()
18429   {
18430     if (TypeConstraint._children_keys == null)
18431       TypeConstraint._children_keys = [
18432         'keyword',
18433         'type'];
18434     return TypeConstraint._children_keys;
18435   }
18436 }
18437 class DarrayTypeSpecifier extends EditableSyntax
18438 {
18439   constructor(
18440     keyword,
18441     left_angle,
18442     key,
18443     comma,
18444     value,
18445     trailing_comma,
18446     right_angle)
18447   {
18448     super('darray_type_specifier', {
18449       keyword: keyword,
18450       left_angle: left_angle,
18451       key: key,
18452       comma: comma,
18453       value: value,
18454       trailing_comma: trailing_comma,
18455       right_angle: right_angle });
18456   }
18457   get keyword() { return this.children.keyword; }
18458   get left_angle() { return this.children.left_angle; }
18459   get key() { return this.children.key; }
18460   get comma() { return this.children.comma; }
18461   get value() { return this.children.value; }
18462   get trailing_comma() { return this.children.trailing_comma; }
18463   get right_angle() { return this.children.right_angle; }
18464   with_keyword(keyword){
18465     return new DarrayTypeSpecifier(
18466       keyword,
18467       this.left_angle,
18468       this.key,
18469       this.comma,
18470       this.value,
18471       this.trailing_comma,
18472       this.right_angle);
18473   }
18474   with_left_angle(left_angle){
18475     return new DarrayTypeSpecifier(
18476       this.keyword,
18477       left_angle,
18478       this.key,
18479       this.comma,
18480       this.value,
18481       this.trailing_comma,
18482       this.right_angle);
18483   }
18484   with_key(key){
18485     return new DarrayTypeSpecifier(
18486       this.keyword,
18487       this.left_angle,
18488       key,
18489       this.comma,
18490       this.value,
18491       this.trailing_comma,
18492       this.right_angle);
18493   }
18494   with_comma(comma){
18495     return new DarrayTypeSpecifier(
18496       this.keyword,
18497       this.left_angle,
18498       this.key,
18499       comma,
18500       this.value,
18501       this.trailing_comma,
18502       this.right_angle);
18503   }
18504   with_value(value){
18505     return new DarrayTypeSpecifier(
18506       this.keyword,
18507       this.left_angle,
18508       this.key,
18509       this.comma,
18510       value,
18511       this.trailing_comma,
18512       this.right_angle);
18513   }
18514   with_trailing_comma(trailing_comma){
18515     return new DarrayTypeSpecifier(
18516       this.keyword,
18517       this.left_angle,
18518       this.key,
18519       this.comma,
18520       this.value,
18521       trailing_comma,
18522       this.right_angle);
18523   }
18524   with_right_angle(right_angle){
18525     return new DarrayTypeSpecifier(
18526       this.keyword,
18527       this.left_angle,
18528       this.key,
18529       this.comma,
18530       this.value,
18531       this.trailing_comma,
18532       right_angle);
18533   }
18534   rewrite(rewriter, parents)
18535   {
18536     if (parents == undefined)
18537       parents = [];
18538     let new_parents = parents.slice();
18539     new_parents.push(this);
18540     var keyword = this.keyword.rewrite(rewriter, new_parents);
18541     var left_angle = this.left_angle.rewrite(rewriter, new_parents);
18542     var key = this.key.rewrite(rewriter, new_parents);
18543     var comma = this.comma.rewrite(rewriter, new_parents);
18544     var value = this.value.rewrite(rewriter, new_parents);
18545     var trailing_comma = this.trailing_comma.rewrite(rewriter, new_parents);
18546     var right_angle = this.right_angle.rewrite(rewriter, new_parents);
18547     if (
18548       keyword === this.keyword &&
18549       left_angle === this.left_angle &&
18550       key === this.key &&
18551       comma === this.comma &&
18552       value === this.value &&
18553       trailing_comma === this.trailing_comma &&
18554       right_angle === this.right_angle)
18555     {
18556       return rewriter(this, parents);
18557     }
18558     else
18559     {
18560       return rewriter(new DarrayTypeSpecifier(
18561         keyword,
18562         left_angle,
18563         key,
18564         comma,
18565         value,
18566         trailing_comma,
18567         right_angle), parents);
18568     }
18569   }
18570   static from_json(json, position, source)
18571   {
18572     let keyword = EditableSyntax.from_json(
18573       json.darray_keyword, position, source);
18574     position += keyword.width;
18575     let left_angle = EditableSyntax.from_json(
18576       json.darray_left_angle, position, source);
18577     position += left_angle.width;
18578     let key = EditableSyntax.from_json(
18579       json.darray_key, position, source);
18580     position += key.width;
18581     let comma = EditableSyntax.from_json(
18582       json.darray_comma, position, source);
18583     position += comma.width;
18584     let value = EditableSyntax.from_json(
18585       json.darray_value, position, source);
18586     position += value.width;
18587     let trailing_comma = EditableSyntax.from_json(
18588       json.darray_trailing_comma, position, source);
18589     position += trailing_comma.width;
18590     let right_angle = EditableSyntax.from_json(
18591       json.darray_right_angle, position, source);
18592     position += right_angle.width;
18593     return new DarrayTypeSpecifier(
18594         keyword,
18595         left_angle,
18596         key,
18597         comma,
18598         value,
18599         trailing_comma,
18600         right_angle);
18601   }
18602   get children_keys()
18603   {
18604     if (DarrayTypeSpecifier._children_keys == null)
18605       DarrayTypeSpecifier._children_keys = [
18606         'keyword',
18607         'left_angle',
18608         'key',
18609         'comma',
18610         'value',
18611         'trailing_comma',
18612         'right_angle'];
18613     return DarrayTypeSpecifier._children_keys;
18614   }
18615 }
18616 class MapArrayTypeSpecifier extends EditableSyntax
18617 {
18618   constructor(
18619     keyword,
18620     left_angle,
18621     key,
18622     comma,
18623     value,
18624     right_angle)
18625   {
18626     super('map_array_type_specifier', {
18627       keyword: keyword,
18628       left_angle: left_angle,
18629       key: key,
18630       comma: comma,
18631       value: value,
18632       right_angle: right_angle });
18633   }
18634   get keyword() { return this.children.keyword; }
18635   get left_angle() { return this.children.left_angle; }
18636   get key() { return this.children.key; }
18637   get comma() { return this.children.comma; }
18638   get value() { return this.children.value; }
18639   get right_angle() { return this.children.right_angle; }
18640   with_keyword(keyword){
18641     return new MapArrayTypeSpecifier(
18642       keyword,
18643       this.left_angle,
18644       this.key,
18645       this.comma,
18646       this.value,
18647       this.right_angle);
18648   }
18649   with_left_angle(left_angle){
18650     return new MapArrayTypeSpecifier(
18651       this.keyword,
18652       left_angle,
18653       this.key,
18654       this.comma,
18655       this.value,
18656       this.right_angle);
18657   }
18658   with_key(key){
18659     return new MapArrayTypeSpecifier(
18660       this.keyword,
18661       this.left_angle,
18662       key,
18663       this.comma,
18664       this.value,
18665       this.right_angle);
18666   }
18667   with_comma(comma){
18668     return new MapArrayTypeSpecifier(
18669       this.keyword,
18670       this.left_angle,
18671       this.key,
18672       comma,
18673       this.value,
18674       this.right_angle);
18675   }
18676   with_value(value){
18677     return new MapArrayTypeSpecifier(
18678       this.keyword,
18679       this.left_angle,
18680       this.key,
18681       this.comma,
18682       value,
18683       this.right_angle);
18684   }
18685   with_right_angle(right_angle){
18686     return new MapArrayTypeSpecifier(
18687       this.keyword,
18688       this.left_angle,
18689       this.key,
18690       this.comma,
18691       this.value,
18692       right_angle);
18693   }
18694   rewrite(rewriter, parents)
18695   {
18696     if (parents == undefined)
18697       parents = [];
18698     let new_parents = parents.slice();
18699     new_parents.push(this);
18700     var keyword = this.keyword.rewrite(rewriter, new_parents);
18701     var left_angle = this.left_angle.rewrite(rewriter, new_parents);
18702     var key = this.key.rewrite(rewriter, new_parents);
18703     var comma = this.comma.rewrite(rewriter, new_parents);
18704     var value = this.value.rewrite(rewriter, new_parents);
18705     var right_angle = this.right_angle.rewrite(rewriter, new_parents);
18706     if (
18707       keyword === this.keyword &&
18708       left_angle === this.left_angle &&
18709       key === this.key &&
18710       comma === this.comma &&
18711       value === this.value &&
18712       right_angle === this.right_angle)
18713     {
18714       return rewriter(this, parents);
18715     }
18716     else
18717     {
18718       return rewriter(new MapArrayTypeSpecifier(
18719         keyword,
18720         left_angle,
18721         key,
18722         comma,
18723         value,
18724         right_angle), parents);
18725     }
18726   }
18727   static from_json(json, position, source)
18728   {
18729     let keyword = EditableSyntax.from_json(
18730       json.map_array_keyword, position, source);
18731     position += keyword.width;
18732     let left_angle = EditableSyntax.from_json(
18733       json.map_array_left_angle, position, source);
18734     position += left_angle.width;
18735     let key = EditableSyntax.from_json(
18736       json.map_array_key, position, source);
18737     position += key.width;
18738     let comma = EditableSyntax.from_json(
18739       json.map_array_comma, position, source);
18740     position += comma.width;
18741     let value = EditableSyntax.from_json(
18742       json.map_array_value, position, source);
18743     position += value.width;
18744     let right_angle = EditableSyntax.from_json(
18745       json.map_array_right_angle, position, source);
18746     position += right_angle.width;
18747     return new MapArrayTypeSpecifier(
18748         keyword,
18749         left_angle,
18750         key,
18751         comma,
18752         value,
18753         right_angle);
18754   }
18755   get children_keys()
18756   {
18757     if (MapArrayTypeSpecifier._children_keys == null)
18758       MapArrayTypeSpecifier._children_keys = [
18759         'keyword',
18760         'left_angle',
18761         'key',
18762         'comma',
18763         'value',
18764         'right_angle'];
18765     return MapArrayTypeSpecifier._children_keys;
18766   }
18767 }
18768 class DictionaryTypeSpecifier extends EditableSyntax
18769 {
18770   constructor(
18771     keyword,
18772     left_angle,
18773     members,
18774     right_angle)
18775   {
18776     super('dictionary_type_specifier', {
18777       keyword: keyword,
18778       left_angle: left_angle,
18779       members: members,
18780       right_angle: right_angle });
18781   }
18782   get keyword() { return this.children.keyword; }
18783   get left_angle() { return this.children.left_angle; }
18784   get members() { return this.children.members; }
18785   get right_angle() { return this.children.right_angle; }
18786   with_keyword(keyword){
18787     return new DictionaryTypeSpecifier(
18788       keyword,
18789       this.left_angle,
18790       this.members,
18791       this.right_angle);
18792   }
18793   with_left_angle(left_angle){
18794     return new DictionaryTypeSpecifier(
18795       this.keyword,
18796       left_angle,
18797       this.members,
18798       this.right_angle);
18799   }
18800   with_members(members){
18801     return new DictionaryTypeSpecifier(
18802       this.keyword,
18803       this.left_angle,
18804       members,
18805       this.right_angle);
18806   }
18807   with_right_angle(right_angle){
18808     return new DictionaryTypeSpecifier(
18809       this.keyword,
18810       this.left_angle,
18811       this.members,
18812       right_angle);
18813   }
18814   rewrite(rewriter, parents)
18815   {
18816     if (parents == undefined)
18817       parents = [];
18818     let new_parents = parents.slice();
18819     new_parents.push(this);
18820     var keyword = this.keyword.rewrite(rewriter, new_parents);
18821     var left_angle = this.left_angle.rewrite(rewriter, new_parents);
18822     var members = this.members.rewrite(rewriter, new_parents);
18823     var right_angle = this.right_angle.rewrite(rewriter, new_parents);
18824     if (
18825       keyword === this.keyword &&
18826       left_angle === this.left_angle &&
18827       members === this.members &&
18828       right_angle === this.right_angle)
18829     {
18830       return rewriter(this, parents);
18831     }
18832     else
18833     {
18834       return rewriter(new DictionaryTypeSpecifier(
18835         keyword,
18836         left_angle,
18837         members,
18838         right_angle), parents);
18839     }
18840   }
18841   static from_json(json, position, source)
18842   {
18843     let keyword = EditableSyntax.from_json(
18844       json.dictionary_type_keyword, position, source);
18845     position += keyword.width;
18846     let left_angle = EditableSyntax.from_json(
18847       json.dictionary_type_left_angle, position, source);
18848     position += left_angle.width;
18849     let members = EditableSyntax.from_json(
18850       json.dictionary_type_members, position, source);
18851     position += members.width;
18852     let right_angle = EditableSyntax.from_json(
18853       json.dictionary_type_right_angle, position, source);
18854     position += right_angle.width;
18855     return new DictionaryTypeSpecifier(
18856         keyword,
18857         left_angle,
18858         members,
18859         right_angle);
18860   }
18861   get children_keys()
18862   {
18863     if (DictionaryTypeSpecifier._children_keys == null)
18864       DictionaryTypeSpecifier._children_keys = [
18865         'keyword',
18866         'left_angle',
18867         'members',
18868         'right_angle'];
18869     return DictionaryTypeSpecifier._children_keys;
18870   }
18871 }
18872 class ClosureTypeSpecifier extends EditableSyntax
18873 {
18874   constructor(
18875     outer_left_paren,
18876     coroutine,
18877     function_keyword,
18878     inner_left_paren,
18879     parameter_list,
18880     inner_right_paren,
18881     colon,
18882     return_type,
18883     outer_right_paren)
18884   {
18885     super('closure_type_specifier', {
18886       outer_left_paren: outer_left_paren,
18887       coroutine: coroutine,
18888       function_keyword: function_keyword,
18889       inner_left_paren: inner_left_paren,
18890       parameter_list: parameter_list,
18891       inner_right_paren: inner_right_paren,
18892       colon: colon,
18893       return_type: return_type,
18894       outer_right_paren: outer_right_paren });
18895   }
18896   get outer_left_paren() { return this.children.outer_left_paren; }
18897   get coroutine() { return this.children.coroutine; }
18898   get function_keyword() { return this.children.function_keyword; }
18899   get inner_left_paren() { return this.children.inner_left_paren; }
18900   get parameter_list() { return this.children.parameter_list; }
18901   get inner_right_paren() { return this.children.inner_right_paren; }
18902   get colon() { return this.children.colon; }
18903   get return_type() { return this.children.return_type; }
18904   get outer_right_paren() { return this.children.outer_right_paren; }
18905   with_outer_left_paren(outer_left_paren){
18906     return new ClosureTypeSpecifier(
18907       outer_left_paren,
18908       this.coroutine,
18909       this.function_keyword,
18910       this.inner_left_paren,
18911       this.parameter_list,
18912       this.inner_right_paren,
18913       this.colon,
18914       this.return_type,
18915       this.outer_right_paren);
18916   }
18917   with_coroutine(coroutine){
18918     return new ClosureTypeSpecifier(
18919       this.outer_left_paren,
18920       coroutine,
18921       this.function_keyword,
18922       this.inner_left_paren,
18923       this.parameter_list,
18924       this.inner_right_paren,
18925       this.colon,
18926       this.return_type,
18927       this.outer_right_paren);
18928   }
18929   with_function_keyword(function_keyword){
18930     return new ClosureTypeSpecifier(
18931       this.outer_left_paren,
18932       this.coroutine,
18933       function_keyword,
18934       this.inner_left_paren,
18935       this.parameter_list,
18936       this.inner_right_paren,
18937       this.colon,
18938       this.return_type,
18939       this.outer_right_paren);
18940   }
18941   with_inner_left_paren(inner_left_paren){
18942     return new ClosureTypeSpecifier(
18943       this.outer_left_paren,
18944       this.coroutine,
18945       this.function_keyword,
18946       inner_left_paren,
18947       this.parameter_list,
18948       this.inner_right_paren,
18949       this.colon,
18950       this.return_type,
18951       this.outer_right_paren);
18952   }
18953   with_parameter_list(parameter_list){
18954     return new ClosureTypeSpecifier(
18955       this.outer_left_paren,
18956       this.coroutine,
18957       this.function_keyword,
18958       this.inner_left_paren,
18959       parameter_list,
18960       this.inner_right_paren,
18961       this.colon,
18962       this.return_type,
18963       this.outer_right_paren);
18964   }
18965   with_inner_right_paren(inner_right_paren){
18966     return new ClosureTypeSpecifier(
18967       this.outer_left_paren,
18968       this.coroutine,
18969       this.function_keyword,
18970       this.inner_left_paren,
18971       this.parameter_list,
18972       inner_right_paren,
18973       this.colon,
18974       this.return_type,
18975       this.outer_right_paren);
18976   }
18977   with_colon(colon){
18978     return new ClosureTypeSpecifier(
18979       this.outer_left_paren,
18980       this.coroutine,
18981       this.function_keyword,
18982       this.inner_left_paren,
18983       this.parameter_list,
18984       this.inner_right_paren,
18985       colon,
18986       this.return_type,
18987       this.outer_right_paren);
18988   }
18989   with_return_type(return_type){
18990     return new ClosureTypeSpecifier(
18991       this.outer_left_paren,
18992       this.coroutine,
18993       this.function_keyword,
18994       this.inner_left_paren,
18995       this.parameter_list,
18996       this.inner_right_paren,
18997       this.colon,
18998       return_type,
18999       this.outer_right_paren);
19000   }
19001   with_outer_right_paren(outer_right_paren){
19002     return new ClosureTypeSpecifier(
19003       this.outer_left_paren,
19004       this.coroutine,
19005       this.function_keyword,
19006       this.inner_left_paren,
19007       this.parameter_list,
19008       this.inner_right_paren,
19009       this.colon,
19010       this.return_type,
19011       outer_right_paren);
19012   }
19013   rewrite(rewriter, parents)
19014   {
19015     if (parents == undefined)
19016       parents = [];
19017     let new_parents = parents.slice();
19018     new_parents.push(this);
19019     var outer_left_paren = this.outer_left_paren.rewrite(rewriter, new_parents);
19020     var coroutine = this.coroutine.rewrite(rewriter, new_parents);
19021     var function_keyword = this.function_keyword.rewrite(rewriter, new_parents);
19022     var inner_left_paren = this.inner_left_paren.rewrite(rewriter, new_parents);
19023     var parameter_list = this.parameter_list.rewrite(rewriter, new_parents);
19024     var inner_right_paren = this.inner_right_paren.rewrite(rewriter, new_parents);
19025     var colon = this.colon.rewrite(rewriter, new_parents);
19026     var return_type = this.return_type.rewrite(rewriter, new_parents);
19027     var outer_right_paren = this.outer_right_paren.rewrite(rewriter, new_parents);
19028     if (
19029       outer_left_paren === this.outer_left_paren &&
19030       coroutine === this.coroutine &&
19031       function_keyword === this.function_keyword &&
19032       inner_left_paren === this.inner_left_paren &&
19033       parameter_list === this.parameter_list &&
19034       inner_right_paren === this.inner_right_paren &&
19035       colon === this.colon &&
19036       return_type === this.return_type &&
19037       outer_right_paren === this.outer_right_paren)
19038     {
19039       return rewriter(this, parents);
19040     }
19041     else
19042     {
19043       return rewriter(new ClosureTypeSpecifier(
19044         outer_left_paren,
19045         coroutine,
19046         function_keyword,
19047         inner_left_paren,
19048         parameter_list,
19049         inner_right_paren,
19050         colon,
19051         return_type,
19052         outer_right_paren), parents);
19053     }
19054   }
19055   static from_json(json, position, source)
19056   {
19057     let outer_left_paren = EditableSyntax.from_json(
19058       json.closure_outer_left_paren, position, source);
19059     position += outer_left_paren.width;
19060     let coroutine = EditableSyntax.from_json(
19061       json.closure_coroutine, position, source);
19062     position += coroutine.width;
19063     let function_keyword = EditableSyntax.from_json(
19064       json.closure_function_keyword, position, source);
19065     position += function_keyword.width;
19066     let inner_left_paren = EditableSyntax.from_json(
19067       json.closure_inner_left_paren, position, source);
19068     position += inner_left_paren.width;
19069     let parameter_list = EditableSyntax.from_json(
19070       json.closure_parameter_list, position, source);
19071     position += parameter_list.width;
19072     let inner_right_paren = EditableSyntax.from_json(
19073       json.closure_inner_right_paren, position, source);
19074     position += inner_right_paren.width;
19075     let colon = EditableSyntax.from_json(
19076       json.closure_colon, position, source);
19077     position += colon.width;
19078     let return_type = EditableSyntax.from_json(
19079       json.closure_return_type, position, source);
19080     position += return_type.width;
19081     let outer_right_paren = EditableSyntax.from_json(
19082       json.closure_outer_right_paren, position, source);
19083     position += outer_right_paren.width;
19084     return new ClosureTypeSpecifier(
19085         outer_left_paren,
19086         coroutine,
19087         function_keyword,
19088         inner_left_paren,
19089         parameter_list,
19090         inner_right_paren,
19091         colon,
19092         return_type,
19093         outer_right_paren);
19094   }
19095   get children_keys()
19096   {
19097     if (ClosureTypeSpecifier._children_keys == null)
19098       ClosureTypeSpecifier._children_keys = [
19099         'outer_left_paren',
19100         'coroutine',
19101         'function_keyword',
19102         'inner_left_paren',
19103         'parameter_list',
19104         'inner_right_paren',
19105         'colon',
19106         'return_type',
19107         'outer_right_paren'];
19108     return ClosureTypeSpecifier._children_keys;
19109   }
19110 }
19111 class ClosureParameterTypeSpecifier extends EditableSyntax
19112 {
19113   constructor(
19114     call_convention,
19115     type)
19116   {
19117     super('closure_parameter_type_specifier', {
19118       call_convention: call_convention,
19119       type: type });
19120   }
19121   get call_convention() { return this.children.call_convention; }
19122   get type() { return this.children.type; }
19123   with_call_convention(call_convention){
19124     return new ClosureParameterTypeSpecifier(
19125       call_convention,
19126       this.type);
19127   }
19128   with_type(type){
19129     return new ClosureParameterTypeSpecifier(
19130       this.call_convention,
19131       type);
19132   }
19133   rewrite(rewriter, parents)
19134   {
19135     if (parents == undefined)
19136       parents = [];
19137     let new_parents = parents.slice();
19138     new_parents.push(this);
19139     var call_convention = this.call_convention.rewrite(rewriter, new_parents);
19140     var type = this.type.rewrite(rewriter, new_parents);
19141     if (
19142       call_convention === this.call_convention &&
19143       type === this.type)
19144     {
19145       return rewriter(this, parents);
19146     }
19147     else
19148     {
19149       return rewriter(new ClosureParameterTypeSpecifier(
19150         call_convention,
19151         type), parents);
19152     }
19153   }
19154   static from_json(json, position, source)
19155   {
19156     let call_convention = EditableSyntax.from_json(
19157       json.closure_parameter_call_convention, position, source);
19158     position += call_convention.width;
19159     let type = EditableSyntax.from_json(
19160       json.closure_parameter_type, position, source);
19161     position += type.width;
19162     return new ClosureParameterTypeSpecifier(
19163         call_convention,
19164         type);
19165   }
19166   get children_keys()
19167   {
19168     if (ClosureParameterTypeSpecifier._children_keys == null)
19169       ClosureParameterTypeSpecifier._children_keys = [
19170         'call_convention',
19171         'type'];
19172     return ClosureParameterTypeSpecifier._children_keys;
19173   }
19174 }
19175 class ClassnameTypeSpecifier extends EditableSyntax
19176 {
19177   constructor(
19178     keyword,
19179     left_angle,
19180     type,
19181     trailing_comma,
19182     right_angle)
19183   {
19184     super('classname_type_specifier', {
19185       keyword: keyword,
19186       left_angle: left_angle,
19187       type: type,
19188       trailing_comma: trailing_comma,
19189       right_angle: right_angle });
19190   }
19191   get keyword() { return this.children.keyword; }
19192   get left_angle() { return this.children.left_angle; }
19193   get type() { return this.children.type; }
19194   get trailing_comma() { return this.children.trailing_comma; }
19195   get right_angle() { return this.children.right_angle; }
19196   with_keyword(keyword){
19197     return new ClassnameTypeSpecifier(
19198       keyword,
19199       this.left_angle,
19200       this.type,
19201       this.trailing_comma,
19202       this.right_angle);
19203   }
19204   with_left_angle(left_angle){
19205     return new ClassnameTypeSpecifier(
19206       this.keyword,
19207       left_angle,
19208       this.type,
19209       this.trailing_comma,
19210       this.right_angle);
19211   }
19212   with_type(type){
19213     return new ClassnameTypeSpecifier(
19214       this.keyword,
19215       this.left_angle,
19216       type,
19217       this.trailing_comma,
19218       this.right_angle);
19219   }
19220   with_trailing_comma(trailing_comma){
19221     return new ClassnameTypeSpecifier(
19222       this.keyword,
19223       this.left_angle,
19224       this.type,
19225       trailing_comma,
19226       this.right_angle);
19227   }
19228   with_right_angle(right_angle){
19229     return new ClassnameTypeSpecifier(
19230       this.keyword,
19231       this.left_angle,
19232       this.type,
19233       this.trailing_comma,
19234       right_angle);
19235   }
19236   rewrite(rewriter, parents)
19237   {
19238     if (parents == undefined)
19239       parents = [];
19240     let new_parents = parents.slice();
19241     new_parents.push(this);
19242     var keyword = this.keyword.rewrite(rewriter, new_parents);
19243     var left_angle = this.left_angle.rewrite(rewriter, new_parents);
19244     var type = this.type.rewrite(rewriter, new_parents);
19245     var trailing_comma = this.trailing_comma.rewrite(rewriter, new_parents);
19246     var right_angle = this.right_angle.rewrite(rewriter, new_parents);
19247     if (
19248       keyword === this.keyword &&
19249       left_angle === this.left_angle &&
19250       type === this.type &&
19251       trailing_comma === this.trailing_comma &&
19252       right_angle === this.right_angle)
19253     {
19254       return rewriter(this, parents);
19255     }
19256     else
19257     {
19258       return rewriter(new ClassnameTypeSpecifier(
19259         keyword,
19260         left_angle,
19261         type,
19262         trailing_comma,
19263         right_angle), parents);
19264     }
19265   }
19266   static from_json(json, position, source)
19267   {
19268     let keyword = EditableSyntax.from_json(
19269       json.classname_keyword, position, source);
19270     position += keyword.width;
19271     let left_angle = EditableSyntax.from_json(
19272       json.classname_left_angle, position, source);
19273     position += left_angle.width;
19274     let type = EditableSyntax.from_json(
19275       json.classname_type, position, source);
19276     position += type.width;
19277     let trailing_comma = EditableSyntax.from_json(
19278       json.classname_trailing_comma, position, source);
19279     position += trailing_comma.width;
19280     let right_angle = EditableSyntax.from_json(
19281       json.classname_right_angle, position, source);
19282     position += right_angle.width;
19283     return new ClassnameTypeSpecifier(
19284         keyword,
19285         left_angle,
19286         type,
19287         trailing_comma,
19288         right_angle);
19289   }
19290   get children_keys()
19291   {
19292     if (ClassnameTypeSpecifier._children_keys == null)
19293       ClassnameTypeSpecifier._children_keys = [
19294         'keyword',
19295         'left_angle',
19296         'type',
19297         'trailing_comma',
19298         'right_angle'];
19299     return ClassnameTypeSpecifier._children_keys;
19300   }
19301 }
19302 class FieldSpecifier extends EditableSyntax
19303 {
19304   constructor(
19305     question,
19306     name,
19307     arrow,
19308     type)
19309   {
19310     super('field_specifier', {
19311       question: question,
19312       name: name,
19313       arrow: arrow,
19314       type: type });
19315   }
19316   get question() { return this.children.question; }
19317   get name() { return this.children.name; }
19318   get arrow() { return this.children.arrow; }
19319   get type() { return this.children.type; }
19320   with_question(question){
19321     return new FieldSpecifier(
19322       question,
19323       this.name,
19324       this.arrow,
19325       this.type);
19326   }
19327   with_name(name){
19328     return new FieldSpecifier(
19329       this.question,
19330       name,
19331       this.arrow,
19332       this.type);
19333   }
19334   with_arrow(arrow){
19335     return new FieldSpecifier(
19336       this.question,
19337       this.name,
19338       arrow,
19339       this.type);
19340   }
19341   with_type(type){
19342     return new FieldSpecifier(
19343       this.question,
19344       this.name,
19345       this.arrow,
19346       type);
19347   }
19348   rewrite(rewriter, parents)
19349   {
19350     if (parents == undefined)
19351       parents = [];
19352     let new_parents = parents.slice();
19353     new_parents.push(this);
19354     var question = this.question.rewrite(rewriter, new_parents);
19355     var name = this.name.rewrite(rewriter, new_parents);
19356     var arrow = this.arrow.rewrite(rewriter, new_parents);
19357     var type = this.type.rewrite(rewriter, new_parents);
19358     if (
19359       question === this.question &&
19360       name === this.name &&
19361       arrow === this.arrow &&
19362       type === this.type)
19363     {
19364       return rewriter(this, parents);
19365     }
19366     else
19367     {
19368       return rewriter(new FieldSpecifier(
19369         question,
19370         name,
19371         arrow,
19372         type), parents);
19373     }
19374   }
19375   static from_json(json, position, source)
19376   {
19377     let question = EditableSyntax.from_json(
19378       json.field_question, position, source);
19379     position += question.width;
19380     let name = EditableSyntax.from_json(
19381       json.field_name, position, source);
19382     position += name.width;
19383     let arrow = EditableSyntax.from_json(
19384       json.field_arrow, position, source);
19385     position += arrow.width;
19386     let type = EditableSyntax.from_json(
19387       json.field_type, position, source);
19388     position += type.width;
19389     return new FieldSpecifier(
19390         question,
19391         name,
19392         arrow,
19393         type);
19394   }
19395   get children_keys()
19396   {
19397     if (FieldSpecifier._children_keys == null)
19398       FieldSpecifier._children_keys = [
19399         'question',
19400         'name',
19401         'arrow',
19402         'type'];
19403     return FieldSpecifier._children_keys;
19404   }
19405 }
19406 class FieldInitializer extends EditableSyntax
19407 {
19408   constructor(
19409     name,
19410     arrow,
19411     value)
19412   {
19413     super('field_initializer', {
19414       name: name,
19415       arrow: arrow,
19416       value: value });
19417   }
19418   get name() { return this.children.name; }
19419   get arrow() { return this.children.arrow; }
19420   get value() { return this.children.value; }
19421   with_name(name){
19422     return new FieldInitializer(
19423       name,
19424       this.arrow,
19425       this.value);
19426   }
19427   with_arrow(arrow){
19428     return new FieldInitializer(
19429       this.name,
19430       arrow,
19431       this.value);
19432   }
19433   with_value(value){
19434     return new FieldInitializer(
19435       this.name,
19436       this.arrow,
19437       value);
19438   }
19439   rewrite(rewriter, parents)
19440   {
19441     if (parents == undefined)
19442       parents = [];
19443     let new_parents = parents.slice();
19444     new_parents.push(this);
19445     var name = this.name.rewrite(rewriter, new_parents);
19446     var arrow = this.arrow.rewrite(rewriter, new_parents);
19447     var value = this.value.rewrite(rewriter, new_parents);
19448     if (
19449       name === this.name &&
19450       arrow === this.arrow &&
19451       value === this.value)
19452     {
19453       return rewriter(this, parents);
19454     }
19455     else
19456     {
19457       return rewriter(new FieldInitializer(
19458         name,
19459         arrow,
19460         value), parents);
19461     }
19462   }
19463   static from_json(json, position, source)
19464   {
19465     let name = EditableSyntax.from_json(
19466       json.field_initializer_name, position, source);
19467     position += name.width;
19468     let arrow = EditableSyntax.from_json(
19469       json.field_initializer_arrow, position, source);
19470     position += arrow.width;
19471     let value = EditableSyntax.from_json(
19472       json.field_initializer_value, position, source);
19473     position += value.width;
19474     return new FieldInitializer(
19475         name,
19476         arrow,
19477         value);
19478   }
19479   get children_keys()
19480   {
19481     if (FieldInitializer._children_keys == null)
19482       FieldInitializer._children_keys = [
19483         'name',
19484         'arrow',
19485         'value'];
19486     return FieldInitializer._children_keys;
19487   }
19488 }
19489 class ShapeTypeSpecifier extends EditableSyntax
19490 {
19491   constructor(
19492     keyword,
19493     left_paren,
19494     fields,
19495     ellipsis,
19496     right_paren)
19497   {
19498     super('shape_type_specifier', {
19499       keyword: keyword,
19500       left_paren: left_paren,
19501       fields: fields,
19502       ellipsis: ellipsis,
19503       right_paren: right_paren });
19504   }
19505   get keyword() { return this.children.keyword; }
19506   get left_paren() { return this.children.left_paren; }
19507   get fields() { return this.children.fields; }
19508   get ellipsis() { return this.children.ellipsis; }
19509   get right_paren() { return this.children.right_paren; }
19510   with_keyword(keyword){
19511     return new ShapeTypeSpecifier(
19512       keyword,
19513       this.left_paren,
19514       this.fields,
19515       this.ellipsis,
19516       this.right_paren);
19517   }
19518   with_left_paren(left_paren){
19519     return new ShapeTypeSpecifier(
19520       this.keyword,
19521       left_paren,
19522       this.fields,
19523       this.ellipsis,
19524       this.right_paren);
19525   }
19526   with_fields(fields){
19527     return new ShapeTypeSpecifier(
19528       this.keyword,
19529       this.left_paren,
19530       fields,
19531       this.ellipsis,
19532       this.right_paren);
19533   }
19534   with_ellipsis(ellipsis){
19535     return new ShapeTypeSpecifier(
19536       this.keyword,
19537       this.left_paren,
19538       this.fields,
19539       ellipsis,
19540       this.right_paren);
19541   }
19542   with_right_paren(right_paren){
19543     return new ShapeTypeSpecifier(
19544       this.keyword,
19545       this.left_paren,
19546       this.fields,
19547       this.ellipsis,
19548       right_paren);
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_paren = this.left_paren.rewrite(rewriter, new_parents);
19558     var fields = this.fields.rewrite(rewriter, new_parents);
19559     var ellipsis = this.ellipsis.rewrite(rewriter, new_parents);
19560     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
19561     if (
19562       keyword === this.keyword &&
19563       left_paren === this.left_paren &&
19564       fields === this.fields &&
19565       ellipsis === this.ellipsis &&
19566       right_paren === this.right_paren)
19567     {
19568       return rewriter(this, parents);
19569     }
19570     else
19571     {
19572       return rewriter(new ShapeTypeSpecifier(
19573         keyword,
19574         left_paren,
19575         fields,
19576         ellipsis,
19577         right_paren), parents);
19578     }
19579   }
19580   static from_json(json, position, source)
19581   {
19582     let keyword = EditableSyntax.from_json(
19583       json.shape_type_keyword, position, source);
19584     position += keyword.width;
19585     let left_paren = EditableSyntax.from_json(
19586       json.shape_type_left_paren, position, source);
19587     position += left_paren.width;
19588     let fields = EditableSyntax.from_json(
19589       json.shape_type_fields, position, source);
19590     position += fields.width;
19591     let ellipsis = EditableSyntax.from_json(
19592       json.shape_type_ellipsis, position, source);
19593     position += ellipsis.width;
19594     let right_paren = EditableSyntax.from_json(
19595       json.shape_type_right_paren, position, source);
19596     position += right_paren.width;
19597     return new ShapeTypeSpecifier(
19598         keyword,
19599         left_paren,
19600         fields,
19601         ellipsis,
19602         right_paren);
19603   }
19604   get children_keys()
19605   {
19606     if (ShapeTypeSpecifier._children_keys == null)
19607       ShapeTypeSpecifier._children_keys = [
19608         'keyword',
19609         'left_paren',
19610         'fields',
19611         'ellipsis',
19612         'right_paren'];
19613     return ShapeTypeSpecifier._children_keys;
19614   }
19615 }
19616 class ShapeExpression extends EditableSyntax
19617 {
19618   constructor(
19619     keyword,
19620     left_paren,
19621     fields,
19622     right_paren)
19623   {
19624     super('shape_expression', {
19625       keyword: keyword,
19626       left_paren: left_paren,
19627       fields: fields,
19628       right_paren: right_paren });
19629   }
19630   get keyword() { return this.children.keyword; }
19631   get left_paren() { return this.children.left_paren; }
19632   get fields() { return this.children.fields; }
19633   get right_paren() { return this.children.right_paren; }
19634   with_keyword(keyword){
19635     return new ShapeExpression(
19636       keyword,
19637       this.left_paren,
19638       this.fields,
19639       this.right_paren);
19640   }
19641   with_left_paren(left_paren){
19642     return new ShapeExpression(
19643       this.keyword,
19644       left_paren,
19645       this.fields,
19646       this.right_paren);
19647   }
19648   with_fields(fields){
19649     return new ShapeExpression(
19650       this.keyword,
19651       this.left_paren,
19652       fields,
19653       this.right_paren);
19654   }
19655   with_right_paren(right_paren){
19656     return new ShapeExpression(
19657       this.keyword,
19658       this.left_paren,
19659       this.fields,
19660       right_paren);
19661   }
19662   rewrite(rewriter, parents)
19663   {
19664     if (parents == undefined)
19665       parents = [];
19666     let new_parents = parents.slice();
19667     new_parents.push(this);
19668     var keyword = this.keyword.rewrite(rewriter, new_parents);
19669     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
19670     var fields = this.fields.rewrite(rewriter, new_parents);
19671     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
19672     if (
19673       keyword === this.keyword &&
19674       left_paren === this.left_paren &&
19675       fields === this.fields &&
19676       right_paren === this.right_paren)
19677     {
19678       return rewriter(this, parents);
19679     }
19680     else
19681     {
19682       return rewriter(new ShapeExpression(
19683         keyword,
19684         left_paren,
19685         fields,
19686         right_paren), parents);
19687     }
19688   }
19689   static from_json(json, position, source)
19690   {
19691     let keyword = EditableSyntax.from_json(
19692       json.shape_expression_keyword, position, source);
19693     position += keyword.width;
19694     let left_paren = EditableSyntax.from_json(
19695       json.shape_expression_left_paren, position, source);
19696     position += left_paren.width;
19697     let fields = EditableSyntax.from_json(
19698       json.shape_expression_fields, position, source);
19699     position += fields.width;
19700     let right_paren = EditableSyntax.from_json(
19701       json.shape_expression_right_paren, position, source);
19702     position += right_paren.width;
19703     return new ShapeExpression(
19704         keyword,
19705         left_paren,
19706         fields,
19707         right_paren);
19708   }
19709   get children_keys()
19710   {
19711     if (ShapeExpression._children_keys == null)
19712       ShapeExpression._children_keys = [
19713         'keyword',
19714         'left_paren',
19715         'fields',
19716         'right_paren'];
19717     return ShapeExpression._children_keys;
19718   }
19719 }
19720 class TupleExpression extends EditableSyntax
19721 {
19722   constructor(
19723     keyword,
19724     left_paren,
19725     items,
19726     right_paren)
19727   {
19728     super('tuple_expression', {
19729       keyword: keyword,
19730       left_paren: left_paren,
19731       items: items,
19732       right_paren: right_paren });
19733   }
19734   get keyword() { return this.children.keyword; }
19735   get left_paren() { return this.children.left_paren; }
19736   get items() { return this.children.items; }
19737   get right_paren() { return this.children.right_paren; }
19738   with_keyword(keyword){
19739     return new TupleExpression(
19740       keyword,
19741       this.left_paren,
19742       this.items,
19743       this.right_paren);
19744   }
19745   with_left_paren(left_paren){
19746     return new TupleExpression(
19747       this.keyword,
19748       left_paren,
19749       this.items,
19750       this.right_paren);
19751   }
19752   with_items(items){
19753     return new TupleExpression(
19754       this.keyword,
19755       this.left_paren,
19756       items,
19757       this.right_paren);
19758   }
19759   with_right_paren(right_paren){
19760     return new TupleExpression(
19761       this.keyword,
19762       this.left_paren,
19763       this.items,
19764       right_paren);
19765   }
19766   rewrite(rewriter, parents)
19767   {
19768     if (parents == undefined)
19769       parents = [];
19770     let new_parents = parents.slice();
19771     new_parents.push(this);
19772     var keyword = this.keyword.rewrite(rewriter, new_parents);
19773     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
19774     var items = this.items.rewrite(rewriter, new_parents);
19775     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
19776     if (
19777       keyword === this.keyword &&
19778       left_paren === this.left_paren &&
19779       items === this.items &&
19780       right_paren === this.right_paren)
19781     {
19782       return rewriter(this, parents);
19783     }
19784     else
19785     {
19786       return rewriter(new TupleExpression(
19787         keyword,
19788         left_paren,
19789         items,
19790         right_paren), parents);
19791     }
19792   }
19793   static from_json(json, position, source)
19794   {
19795     let keyword = EditableSyntax.from_json(
19796       json.tuple_expression_keyword, position, source);
19797     position += keyword.width;
19798     let left_paren = EditableSyntax.from_json(
19799       json.tuple_expression_left_paren, position, source);
19800     position += left_paren.width;
19801     let items = EditableSyntax.from_json(
19802       json.tuple_expression_items, position, source);
19803     position += items.width;
19804     let right_paren = EditableSyntax.from_json(
19805       json.tuple_expression_right_paren, position, source);
19806     position += right_paren.width;
19807     return new TupleExpression(
19808         keyword,
19809         left_paren,
19810         items,
19811         right_paren);
19812   }
19813   get children_keys()
19814   {
19815     if (TupleExpression._children_keys == null)
19816       TupleExpression._children_keys = [
19817         'keyword',
19818         'left_paren',
19819         'items',
19820         'right_paren'];
19821     return TupleExpression._children_keys;
19822   }
19823 }
19824 class GenericTypeSpecifier extends EditableSyntax
19825 {
19826   constructor(
19827     class_type,
19828     argument_list)
19829   {
19830     super('generic_type_specifier', {
19831       class_type: class_type,
19832       argument_list: argument_list });
19833   }
19834   get class_type() { return this.children.class_type; }
19835   get argument_list() { return this.children.argument_list; }
19836   with_class_type(class_type){
19837     return new GenericTypeSpecifier(
19838       class_type,
19839       this.argument_list);
19840   }
19841   with_argument_list(argument_list){
19842     return new GenericTypeSpecifier(
19843       this.class_type,
19844       argument_list);
19845   }
19846   rewrite(rewriter, parents)
19847   {
19848     if (parents == undefined)
19849       parents = [];
19850     let new_parents = parents.slice();
19851     new_parents.push(this);
19852     var class_type = this.class_type.rewrite(rewriter, new_parents);
19853     var argument_list = this.argument_list.rewrite(rewriter, new_parents);
19854     if (
19855       class_type === this.class_type &&
19856       argument_list === this.argument_list)
19857     {
19858       return rewriter(this, parents);
19859     }
19860     else
19861     {
19862       return rewriter(new GenericTypeSpecifier(
19863         class_type,
19864         argument_list), parents);
19865     }
19866   }
19867   static from_json(json, position, source)
19868   {
19869     let class_type = EditableSyntax.from_json(
19870       json.generic_class_type, position, source);
19871     position += class_type.width;
19872     let argument_list = EditableSyntax.from_json(
19873       json.generic_argument_list, position, source);
19874     position += argument_list.width;
19875     return new GenericTypeSpecifier(
19876         class_type,
19877         argument_list);
19878   }
19879   get children_keys()
19880   {
19881     if (GenericTypeSpecifier._children_keys == null)
19882       GenericTypeSpecifier._children_keys = [
19883         'class_type',
19884         'argument_list'];
19885     return GenericTypeSpecifier._children_keys;
19886   }
19887 }
19888 class NullableTypeSpecifier extends EditableSyntax
19889 {
19890   constructor(
19891     question,
19892     type)
19893   {
19894     super('nullable_type_specifier', {
19895       question: question,
19896       type: type });
19897   }
19898   get question() { return this.children.question; }
19899   get type() { return this.children.type; }
19900   with_question(question){
19901     return new NullableTypeSpecifier(
19902       question,
19903       this.type);
19904   }
19905   with_type(type){
19906     return new NullableTypeSpecifier(
19907       this.question,
19908       type);
19909   }
19910   rewrite(rewriter, parents)
19911   {
19912     if (parents == undefined)
19913       parents = [];
19914     let new_parents = parents.slice();
19915     new_parents.push(this);
19916     var question = this.question.rewrite(rewriter, new_parents);
19917     var type = this.type.rewrite(rewriter, new_parents);
19918     if (
19919       question === this.question &&
19920       type === this.type)
19921     {
19922       return rewriter(this, parents);
19923     }
19924     else
19925     {
19926       return rewriter(new NullableTypeSpecifier(
19927         question,
19928         type), parents);
19929     }
19930   }
19931   static from_json(json, position, source)
19932   {
19933     let question = EditableSyntax.from_json(
19934       json.nullable_question, position, source);
19935     position += question.width;
19936     let type = EditableSyntax.from_json(
19937       json.nullable_type, position, source);
19938     position += type.width;
19939     return new NullableTypeSpecifier(
19940         question,
19941         type);
19942   }
19943   get children_keys()
19944   {
19945     if (NullableTypeSpecifier._children_keys == null)
19946       NullableTypeSpecifier._children_keys = [
19947         'question',
19948         'type'];
19949     return NullableTypeSpecifier._children_keys;
19950   }
19951 }
19952 class SoftTypeSpecifier extends EditableSyntax
19953 {
19954   constructor(
19955     at,
19956     type)
19957   {
19958     super('soft_type_specifier', {
19959       at: at,
19960       type: type });
19961   }
19962   get at() { return this.children.at; }
19963   get type() { return this.children.type; }
19964   with_at(at){
19965     return new SoftTypeSpecifier(
19966       at,
19967       this.type);
19968   }
19969   with_type(type){
19970     return new SoftTypeSpecifier(
19971       this.at,
19972       type);
19973   }
19974   rewrite(rewriter, parents)
19975   {
19976     if (parents == undefined)
19977       parents = [];
19978     let new_parents = parents.slice();
19979     new_parents.push(this);
19980     var at = this.at.rewrite(rewriter, new_parents);
19981     var type = this.type.rewrite(rewriter, new_parents);
19982     if (
19983       at === this.at &&
19984       type === this.type)
19985     {
19986       return rewriter(this, parents);
19987     }
19988     else
19989     {
19990       return rewriter(new SoftTypeSpecifier(
19991         at,
19992         type), parents);
19993     }
19994   }
19995   static from_json(json, position, source)
19996   {
19997     let at = EditableSyntax.from_json(
19998       json.soft_at, position, source);
19999     position += at.width;
20000     let type = EditableSyntax.from_json(
20001       json.soft_type, position, source);
20002     position += type.width;
20003     return new SoftTypeSpecifier(
20004         at,
20005         type);
20006   }
20007   get children_keys()
20008   {
20009     if (SoftTypeSpecifier._children_keys == null)
20010       SoftTypeSpecifier._children_keys = [
20011         'at',
20012         'type'];
20013     return SoftTypeSpecifier._children_keys;
20014   }
20015 }
20016 class TypeArguments extends EditableSyntax
20017 {
20018   constructor(
20019     left_angle,
20020     types,
20021     right_angle)
20022   {
20023     super('type_arguments', {
20024       left_angle: left_angle,
20025       types: types,
20026       right_angle: right_angle });
20027   }
20028   get left_angle() { return this.children.left_angle; }
20029   get types() { return this.children.types; }
20030   get right_angle() { return this.children.right_angle; }
20031   with_left_angle(left_angle){
20032     return new TypeArguments(
20033       left_angle,
20034       this.types,
20035       this.right_angle);
20036   }
20037   with_types(types){
20038     return new TypeArguments(
20039       this.left_angle,
20040       types,
20041       this.right_angle);
20042   }
20043   with_right_angle(right_angle){
20044     return new TypeArguments(
20045       this.left_angle,
20046       this.types,
20047       right_angle);
20048   }
20049   rewrite(rewriter, parents)
20050   {
20051     if (parents == undefined)
20052       parents = [];
20053     let new_parents = parents.slice();
20054     new_parents.push(this);
20055     var left_angle = this.left_angle.rewrite(rewriter, new_parents);
20056     var types = this.types.rewrite(rewriter, new_parents);
20057     var right_angle = this.right_angle.rewrite(rewriter, new_parents);
20058     if (
20059       left_angle === this.left_angle &&
20060       types === this.types &&
20061       right_angle === this.right_angle)
20062     {
20063       return rewriter(this, parents);
20064     }
20065     else
20066     {
20067       return rewriter(new TypeArguments(
20068         left_angle,
20069         types,
20070         right_angle), parents);
20071     }
20072   }
20073   static from_json(json, position, source)
20074   {
20075     let left_angle = EditableSyntax.from_json(
20076       json.type_arguments_left_angle, position, source);
20077     position += left_angle.width;
20078     let types = EditableSyntax.from_json(
20079       json.type_arguments_types, position, source);
20080     position += types.width;
20081     let right_angle = EditableSyntax.from_json(
20082       json.type_arguments_right_angle, position, source);
20083     position += right_angle.width;
20084     return new TypeArguments(
20085         left_angle,
20086         types,
20087         right_angle);
20088   }
20089   get children_keys()
20090   {
20091     if (TypeArguments._children_keys == null)
20092       TypeArguments._children_keys = [
20093         'left_angle',
20094         'types',
20095         'right_angle'];
20096     return TypeArguments._children_keys;
20097   }
20098 }
20099 class TypeParameters extends EditableSyntax
20100 {
20101   constructor(
20102     left_angle,
20103     parameters,
20104     right_angle)
20105   {
20106     super('type_parameters', {
20107       left_angle: left_angle,
20108       parameters: parameters,
20109       right_angle: right_angle });
20110   }
20111   get left_angle() { return this.children.left_angle; }
20112   get parameters() { return this.children.parameters; }
20113   get right_angle() { return this.children.right_angle; }
20114   with_left_angle(left_angle){
20115     return new TypeParameters(
20116       left_angle,
20117       this.parameters,
20118       this.right_angle);
20119   }
20120   with_parameters(parameters){
20121     return new TypeParameters(
20122       this.left_angle,
20123       parameters,
20124       this.right_angle);
20125   }
20126   with_right_angle(right_angle){
20127     return new TypeParameters(
20128       this.left_angle,
20129       this.parameters,
20130       right_angle);
20131   }
20132   rewrite(rewriter, parents)
20133   {
20134     if (parents == undefined)
20135       parents = [];
20136     let new_parents = parents.slice();
20137     new_parents.push(this);
20138     var left_angle = this.left_angle.rewrite(rewriter, new_parents);
20139     var parameters = this.parameters.rewrite(rewriter, new_parents);
20140     var right_angle = this.right_angle.rewrite(rewriter, new_parents);
20141     if (
20142       left_angle === this.left_angle &&
20143       parameters === this.parameters &&
20144       right_angle === this.right_angle)
20145     {
20146       return rewriter(this, parents);
20147     }
20148     else
20149     {
20150       return rewriter(new TypeParameters(
20151         left_angle,
20152         parameters,
20153         right_angle), parents);
20154     }
20155   }
20156   static from_json(json, position, source)
20157   {
20158     let left_angle = EditableSyntax.from_json(
20159       json.type_parameters_left_angle, position, source);
20160     position += left_angle.width;
20161     let parameters = EditableSyntax.from_json(
20162       json.type_parameters_parameters, position, source);
20163     position += parameters.width;
20164     let right_angle = EditableSyntax.from_json(
20165       json.type_parameters_right_angle, position, source);
20166     position += right_angle.width;
20167     return new TypeParameters(
20168         left_angle,
20169         parameters,
20170         right_angle);
20171   }
20172   get children_keys()
20173   {
20174     if (TypeParameters._children_keys == null)
20175       TypeParameters._children_keys = [
20176         'left_angle',
20177         'parameters',
20178         'right_angle'];
20179     return TypeParameters._children_keys;
20180   }
20181 }
20182 class TupleTypeSpecifier extends EditableSyntax
20183 {
20184   constructor(
20185     left_paren,
20186     types,
20187     right_paren)
20188   {
20189     super('tuple_type_specifier', {
20190       left_paren: left_paren,
20191       types: types,
20192       right_paren: right_paren });
20193   }
20194   get left_paren() { return this.children.left_paren; }
20195   get types() { return this.children.types; }
20196   get right_paren() { return this.children.right_paren; }
20197   with_left_paren(left_paren){
20198     return new TupleTypeSpecifier(
20199       left_paren,
20200       this.types,
20201       this.right_paren);
20202   }
20203   with_types(types){
20204     return new TupleTypeSpecifier(
20205       this.left_paren,
20206       types,
20207       this.right_paren);
20208   }
20209   with_right_paren(right_paren){
20210     return new TupleTypeSpecifier(
20211       this.left_paren,
20212       this.types,
20213       right_paren);
20214   }
20215   rewrite(rewriter, parents)
20216   {
20217     if (parents == undefined)
20218       parents = [];
20219     let new_parents = parents.slice();
20220     new_parents.push(this);
20221     var left_paren = this.left_paren.rewrite(rewriter, new_parents);
20222     var types = this.types.rewrite(rewriter, new_parents);
20223     var right_paren = this.right_paren.rewrite(rewriter, new_parents);
20224     if (
20225       left_paren === this.left_paren &&
20226       types === this.types &&
20227       right_paren === this.right_paren)
20228     {
20229       return rewriter(this, parents);
20230     }
20231     else
20232     {
20233       return rewriter(new TupleTypeSpecifier(
20234         left_paren,
20235         types,
20236         right_paren), parents);
20237     }
20238   }
20239   static from_json(json, position, source)
20240   {
20241     let left_paren = EditableSyntax.from_json(
20242       json.tuple_left_paren, position, source);
20243     position += left_paren.width;
20244     let types = EditableSyntax.from_json(
20245       json.tuple_types, position, source);
20246     position += types.width;
20247     let right_paren = EditableSyntax.from_json(
20248       json.tuple_right_paren, position, source);
20249     position += right_paren.width;
20250     return new TupleTypeSpecifier(
20251         left_paren,
20252         types,
20253         right_paren);
20254   }
20255   get children_keys()
20256   {
20257     if (TupleTypeSpecifier._children_keys == null)
20258       TupleTypeSpecifier._children_keys = [
20259         'left_paren',
20260         'types',
20261         'right_paren'];
20262     return TupleTypeSpecifier._children_keys;
20263   }
20264 }
20265 class ErrorSyntax extends EditableSyntax
20266 {
20267   constructor(
20268     error)
20269   {
20270     super('error', {
20271       error: error });
20272   }
20273   get error() { return this.children.error; }
20274   with_error(error){
20275     return new ErrorSyntax(
20276       error);
20277   }
20278   rewrite(rewriter, parents)
20279   {
20280     if (parents == undefined)
20281       parents = [];
20282     let new_parents = parents.slice();
20283     new_parents.push(this);
20284     var error = this.error.rewrite(rewriter, new_parents);
20285     if (
20286       error === this.error)
20287     {
20288       return rewriter(this, parents);
20289     }
20290     else
20291     {
20292       return rewriter(new ErrorSyntax(
20293         error), parents);
20294     }
20295   }
20296   static from_json(json, position, source)
20297   {
20298     let error = EditableSyntax.from_json(
20299       json.error_error, position, source);
20300     position += error.width;
20301     return new ErrorSyntax(
20302         error);
20303   }
20304   get children_keys()
20305   {
20306     if (ErrorSyntax._children_keys == null)
20307       ErrorSyntax._children_keys = [
20308         'error'];
20309     return ErrorSyntax._children_keys;
20310   }
20311 }
20312 class ListItem extends EditableSyntax
20313 {
20314   constructor(
20315     item,
20316     separator)
20317   {
20318     super('list_item', {
20319       item: item,
20320       separator: separator });
20321   }
20322   get item() { return this.children.item; }
20323   get separator() { return this.children.separator; }
20324   with_item(item){
20325     return new ListItem(
20326       item,
20327       this.separator);
20328   }
20329   with_separator(separator){
20330     return new ListItem(
20331       this.item,
20332       separator);
20333   }
20334   rewrite(rewriter, parents)
20335   {
20336     if (parents == undefined)
20337       parents = [];
20338     let new_parents = parents.slice();
20339     new_parents.push(this);
20340     var item = this.item.rewrite(rewriter, new_parents);
20341     var separator = this.separator.rewrite(rewriter, new_parents);
20342     if (
20343       item === this.item &&
20344       separator === this.separator)
20345     {
20346       return rewriter(this, parents);
20347     }
20348     else
20349     {
20350       return rewriter(new ListItem(
20351         item,
20352         separator), parents);
20353     }
20354   }
20355   static from_json(json, position, source)
20356   {
20357     let item = EditableSyntax.from_json(
20358       json.list_item, position, source);
20359     position += item.width;
20360     let separator = EditableSyntax.from_json(
20361       json.list_separator, position, source);
20362     position += separator.width;
20363     return new ListItem(
20364         item,
20365         separator);
20366   }
20367   get children_keys()
20368   {
20369     if (ListItem._children_keys == null)
20370       ListItem._children_keys = [
20371         'item',
20372         'separator'];
20373     return ListItem._children_keys;
20374   }
20375 }
20376
20377
20378 function from_json(json)
20379 {
20380   return EditableSyntax.from_json(json.parse_tree, 0, json.program_text);
20381 }
20382
20383 exports.from_json = from_json;
20384 exports.EditableSyntax = EditableSyntax;
20385 exports.EditableList = EditableList;
20386 exports.EditableToken = EditableToken;
20387 exports.EndOfFileToken = EndOfFileToken;
20388
20389 exports.AbstractToken = AbstractToken;
20390 exports.AndToken = AndToken;
20391 exports.ArrayToken = ArrayToken;
20392 exports.ArraykeyToken = ArraykeyToken;
20393 exports.AsToken = AsToken;
20394 exports.AsyncToken = AsyncToken;
20395 exports.AttributeToken = AttributeToken;
20396 exports.AwaitToken = AwaitToken;
20397 exports.BackslashToken = BackslashToken;
20398 exports.BoolToken = BoolToken;
20399 exports.BreakToken = BreakToken;
20400 exports.CaseToken = CaseToken;
20401 exports.CatchToken = CatchToken;
20402 exports.CategoryToken = CategoryToken;
20403 exports.ChildrenToken = ChildrenToken;
20404 exports.ClassToken = ClassToken;
20405 exports.ClassnameToken = ClassnameToken;
20406 exports.CloneToken = CloneToken;
20407 exports.ConstToken = ConstToken;
20408 exports.ConstructToken = ConstructToken;
20409 exports.ContinueToken = ContinueToken;
20410 exports.CoroutineToken = CoroutineToken;
20411 exports.DarrayToken = DarrayToken;
20412 exports.DeclareToken = DeclareToken;
20413 exports.DefaultToken = DefaultToken;
20414 exports.DefineToken = DefineToken;
20415 exports.DestructToken = DestructToken;
20416 exports.DictToken = DictToken;
20417 exports.DoToken = DoToken;
20418 exports.DoubleToken = DoubleToken;
20419 exports.EchoToken = EchoToken;
20420 exports.ElseToken = ElseToken;
20421 exports.ElseifToken = ElseifToken;
20422 exports.EmptyToken = EmptyToken;
20423 exports.EndforToken = EndforToken;
20424 exports.EndforeachToken = EndforeachToken;
20425 exports.EnddeclareToken = EnddeclareToken;
20426 exports.EndifToken = EndifToken;
20427 exports.EndswitchToken = EndswitchToken;
20428 exports.EndwhileToken = EndwhileToken;
20429 exports.EnumToken = EnumToken;
20430 exports.EvalToken = EvalToken;
20431 exports.ExtendsToken = ExtendsToken;
20432 exports.FallthroughToken = FallthroughToken;
20433 exports.FloatToken = FloatToken;
20434 exports.FinalToken = FinalToken;
20435 exports.FinallyToken = FinallyToken;
20436 exports.ForToken = ForToken;
20437 exports.ForeachToken = ForeachToken;
20438 exports.FromToken = FromToken;
20439 exports.FunctionToken = FunctionToken;
20440 exports.GlobalToken = GlobalToken;
20441 exports.GotoToken = GotoToken;
20442 exports.IfToken = IfToken;
20443 exports.ImplementsToken = ImplementsToken;
20444 exports.IncludeToken = IncludeToken;
20445 exports.Include_onceToken = Include_onceToken;
20446 exports.InoutToken = InoutToken;
20447 exports.InstanceofToken = InstanceofToken;
20448 exports.InsteadofToken = InsteadofToken;
20449 exports.IntToken = IntToken;
20450 exports.InterfaceToken = InterfaceToken;
20451 exports.IsToken = IsToken;
20452 exports.IssetToken = IssetToken;
20453 exports.KeysetToken = KeysetToken;
20454 exports.ListToken = ListToken;
20455 exports.MixedToken = MixedToken;
20456 exports.NamespaceToken = NamespaceToken;
20457 exports.NewToken = NewToken;
20458 exports.NewtypeToken = NewtypeToken;
20459 exports.NoreturnToken = NoreturnToken;
20460 exports.NumToken = NumToken;
20461 exports.ObjectToken = ObjectToken;
20462 exports.OrToken = OrToken;
20463 exports.ParentToken = ParentToken;
20464 exports.PrintToken = PrintToken;
20465 exports.PrivateToken = PrivateToken;
20466 exports.ProtectedToken = ProtectedToken;
20467 exports.PublicToken = PublicToken;
20468 exports.RequireToken = RequireToken;
20469 exports.Require_onceToken = Require_onceToken;
20470 exports.RequiredToken = RequiredToken;
20471 exports.ResourceToken = ResourceToken;
20472 exports.ReturnToken = ReturnToken;
20473 exports.SelfToken = SelfToken;
20474 exports.ShapeToken = ShapeToken;
20475 exports.StaticToken = StaticToken;
20476 exports.StringToken = StringToken;
20477 exports.SuperToken = SuperToken;
20478 exports.SuspendToken = SuspendToken;
20479 exports.SwitchToken = SwitchToken;
20480 exports.ThisToken = ThisToken;
20481 exports.ThrowToken = ThrowToken;
20482 exports.TraitToken = TraitToken;
20483 exports.TryToken = TryToken;
20484 exports.TupleToken = TupleToken;
20485 exports.TypeToken = TypeToken;
20486 exports.UnsetToken = UnsetToken;
20487 exports.UseToken = UseToken;
20488 exports.UsingToken = UsingToken;
20489 exports.VarToken = VarToken;
20490 exports.VarrayToken = VarrayToken;
20491 exports.VecToken = VecToken;
20492 exports.VoidToken = VoidToken;
20493 exports.WhereToken = WhereToken;
20494 exports.WhileToken = WhileToken;
20495 exports.XorToken = XorToken;
20496 exports.YieldToken = YieldToken;
20497 exports.LeftBracketToken = LeftBracketToken;
20498 exports.RightBracketToken = RightBracketToken;
20499 exports.LeftParenToken = LeftParenToken;
20500 exports.RightParenToken = RightParenToken;
20501 exports.LeftBraceToken = LeftBraceToken;
20502 exports.RightBraceToken = RightBraceToken;
20503 exports.DotToken = DotToken;
20504 exports.MinusGreaterThanToken = MinusGreaterThanToken;
20505 exports.PlusPlusToken = PlusPlusToken;
20506 exports.MinusMinusToken = MinusMinusToken;
20507 exports.StarStarToken = StarStarToken;
20508 exports.StarToken = StarToken;
20509 exports.PlusToken = PlusToken;
20510 exports.MinusToken = MinusToken;
20511 exports.TildeToken = TildeToken;
20512 exports.ExclamationToken = ExclamationToken;
20513 exports.DollarToken = DollarToken;
20514 exports.SlashToken = SlashToken;
20515 exports.PercentToken = PercentToken;
20516 exports.LessThanGreaterThanToken = LessThanGreaterThanToken;
20517 exports.LessThanEqualGreaterThanToken = LessThanEqualGreaterThanToken;
20518 exports.LessThanLessThanToken = LessThanLessThanToken;
20519 exports.GreaterThanGreaterThanToken = GreaterThanGreaterThanToken;
20520 exports.LessThanToken = LessThanToken;
20521 exports.GreaterThanToken = GreaterThanToken;
20522 exports.LessThanEqualToken = LessThanEqualToken;
20523 exports.GreaterThanEqualToken = GreaterThanEqualToken;
20524 exports.EqualEqualToken = EqualEqualToken;
20525 exports.EqualEqualEqualToken = EqualEqualEqualToken;
20526 exports.ExclamationEqualToken = ExclamationEqualToken;
20527 exports.ExclamationEqualEqualToken = ExclamationEqualEqualToken;
20528 exports.CaratToken = CaratToken;
20529 exports.BarToken = BarToken;
20530 exports.AmpersandToken = AmpersandToken;
20531 exports.AmpersandAmpersandToken = AmpersandAmpersandToken;
20532 exports.BarBarToken = BarBarToken;
20533 exports.QuestionToken = QuestionToken;
20534 exports.QuestionColonToken = QuestionColonToken;
20535 exports.QuestionQuestionToken = QuestionQuestionToken;
20536 exports.ColonToken = ColonToken;
20537 exports.SemicolonToken = SemicolonToken;
20538 exports.EqualToken = EqualToken;
20539 exports.StarStarEqualToken = StarStarEqualToken;
20540 exports.StarEqualToken = StarEqualToken;
20541 exports.SlashEqualToken = SlashEqualToken;
20542 exports.PercentEqualToken = PercentEqualToken;
20543 exports.PlusEqualToken = PlusEqualToken;
20544 exports.MinusEqualToken = MinusEqualToken;
20545 exports.DotEqualToken = DotEqualToken;
20546 exports.LessThanLessThanEqualToken = LessThanLessThanEqualToken;
20547 exports.GreaterThanGreaterThanEqualToken = GreaterThanGreaterThanEqualToken;
20548 exports.AmpersandEqualToken = AmpersandEqualToken;
20549 exports.CaratEqualToken = CaratEqualToken;
20550 exports.BarEqualToken = BarEqualToken;
20551 exports.CommaToken = CommaToken;
20552 exports.AtToken = AtToken;
20553 exports.ColonColonToken = ColonColonToken;
20554 exports.EqualGreaterThanToken = EqualGreaterThanToken;
20555 exports.EqualEqualGreaterThanToken = EqualEqualGreaterThanToken;
20556 exports.QuestionMinusGreaterThanToken = QuestionMinusGreaterThanToken;
20557 exports.DotDotDotToken = DotDotDotToken;
20558 exports.DollarDollarToken = DollarDollarToken;
20559 exports.BarGreaterThanToken = BarGreaterThanToken;
20560 exports.NullLiteralToken = NullLiteralToken;
20561 exports.SlashGreaterThanToken = SlashGreaterThanToken;
20562 exports.LessThanSlashToken = LessThanSlashToken;
20563 exports.LessThanQuestionToken = LessThanQuestionToken;
20564 exports.QuestionGreaterThanToken = QuestionGreaterThanToken;
20565 exports.HaltCompilerToken = HaltCompilerToken;
20566
20567 exports.ErrorTokenToken = ErrorTokenToken;
20568 exports.NameToken = NameToken;
20569 exports.VariableToken = VariableToken;
20570 exports.DecimalLiteralToken = DecimalLiteralToken;
20571 exports.OctalLiteralToken = OctalLiteralToken;
20572 exports.HexadecimalLiteralToken = HexadecimalLiteralToken;
20573 exports.BinaryLiteralToken = BinaryLiteralToken;
20574 exports.FloatingLiteralToken = FloatingLiteralToken;
20575 exports.ExecutionStringLiteralToken = ExecutionStringLiteralToken;
20576 exports.ExecutionStringLiteralHeadToken = ExecutionStringLiteralHeadToken;
20577 exports.ExecutionStringLiteralTailToken = ExecutionStringLiteralTailToken;
20578 exports.SingleQuotedStringLiteralToken = SingleQuotedStringLiteralToken;
20579 exports.DoubleQuotedStringLiteralToken = DoubleQuotedStringLiteralToken;
20580 exports.DoubleQuotedStringLiteralHeadToken = DoubleQuotedStringLiteralHeadToken;
20581 exports.StringLiteralBodyToken = StringLiteralBodyToken;
20582 exports.DoubleQuotedStringLiteralTailToken = DoubleQuotedStringLiteralTailToken;
20583 exports.HeredocStringLiteralToken = HeredocStringLiteralToken;
20584 exports.HeredocStringLiteralHeadToken = HeredocStringLiteralHeadToken;
20585 exports.HeredocStringLiteralTailToken = HeredocStringLiteralTailToken;
20586 exports.NowdocStringLiteralToken = NowdocStringLiteralToken;
20587 exports.BooleanLiteralToken = BooleanLiteralToken;
20588 exports.XHPCategoryNameToken = XHPCategoryNameToken;
20589 exports.XHPElementNameToken = XHPElementNameToken;
20590 exports.XHPClassNameToken = XHPClassNameToken;
20591 exports.XHPStringLiteralToken = XHPStringLiteralToken;
20592 exports.XHPBodyToken = XHPBodyToken;
20593 exports.XHPCommentToken = XHPCommentToken;
20594 exports.MarkupToken = MarkupToken;
20595
20596 exports.EditableTrivia = EditableTrivia;
20597 exports.WhiteSpace = WhiteSpace;
20598 exports.EndOfLine = EndOfLine;
20599 exports.DelimitedComment = DelimitedComment;
20600 exports.SingleLineComment = SingleLineComment;
20601 exports.Unsafe = Unsafe;
20602 exports.UnsafeExpression = UnsafeExpression;
20603 exports.FixMe = FixMe;
20604 exports.IgnoreError = IgnoreError;
20605 exports.FallThrough = FallThrough;
20606 exports.ExtraTokenError = ExtraTokenError;
20607 exports.AfterHaltCompiler = AfterHaltCompiler;
20608
20609 exports.EndOfFile = EndOfFile;
20610 exports.Script = Script;
20611 exports.QualifiedName = QualifiedName;
20612 exports.SimpleTypeSpecifier = SimpleTypeSpecifier;
20613 exports.LiteralExpression = LiteralExpression;
20614 exports.VariableExpression = VariableExpression;
20615 exports.PipeVariableExpression = PipeVariableExpression;
20616 exports.EnumDeclaration = EnumDeclaration;
20617 exports.Enumerator = Enumerator;
20618 exports.AliasDeclaration = AliasDeclaration;
20619 exports.PropertyDeclaration = PropertyDeclaration;
20620 exports.PropertyDeclarator = PropertyDeclarator;
20621 exports.NamespaceDeclaration = NamespaceDeclaration;
20622 exports.NamespaceBody = NamespaceBody;
20623 exports.NamespaceEmptyBody = NamespaceEmptyBody;
20624 exports.NamespaceUseDeclaration = NamespaceUseDeclaration;
20625 exports.NamespaceGroupUseDeclaration = NamespaceGroupUseDeclaration;
20626 exports.NamespaceUseClause = NamespaceUseClause;
20627 exports.FunctionDeclaration = FunctionDeclaration;
20628 exports.FunctionDeclarationHeader = FunctionDeclarationHeader;
20629 exports.WhereClause = WhereClause;
20630 exports.WhereConstraint = WhereConstraint;
20631 exports.MethodishDeclaration = MethodishDeclaration;
20632 exports.ClassishDeclaration = ClassishDeclaration;
20633 exports.ClassishBody = ClassishBody;
20634 exports.TraitUsePrecedenceItem = TraitUsePrecedenceItem;
20635 exports.TraitUseAliasItem = TraitUseAliasItem;
20636 exports.TraitUseConflictResolution = TraitUseConflictResolution;
20637 exports.TraitUse = TraitUse;
20638 exports.RequireClause = RequireClause;
20639 exports.ConstDeclaration = ConstDeclaration;
20640 exports.ConstantDeclarator = ConstantDeclarator;
20641 exports.TypeConstDeclaration = TypeConstDeclaration;
20642 exports.DecoratedExpression = DecoratedExpression;
20643 exports.ParameterDeclaration = ParameterDeclaration;
20644 exports.VariadicParameter = VariadicParameter;
20645 exports.AttributeSpecification = AttributeSpecification;
20646 exports.Attribute = Attribute;
20647 exports.InclusionExpression = InclusionExpression;
20648 exports.InclusionDirective = InclusionDirective;
20649 exports.CompoundStatement = CompoundStatement;
20650 exports.AlternateLoopStatement = AlternateLoopStatement;
20651 exports.ExpressionStatement = ExpressionStatement;
20652 exports.MarkupSection = MarkupSection;
20653 exports.MarkupSuffix = MarkupSuffix;
20654 exports.UnsetStatement = UnsetStatement;
20655 exports.UsingStatementBlockScoped = UsingStatementBlockScoped;
20656 exports.UsingStatementFunctionScoped = UsingStatementFunctionScoped;
20657 exports.DeclareDirectiveStatement = DeclareDirectiveStatement;
20658 exports.DeclareBlockStatement = DeclareBlockStatement;
20659 exports.WhileStatement = WhileStatement;
20660 exports.IfStatement = IfStatement;
20661 exports.ElseifClause = ElseifClause;
20662 exports.ElseClause = ElseClause;
20663 exports.IfEndIfStatement = IfEndIfStatement;
20664 exports.ElseifColonClause = ElseifColonClause;
20665 exports.ElseColonClause = ElseColonClause;
20666 exports.TryStatement = TryStatement;
20667 exports.CatchClause = CatchClause;
20668 exports.FinallyClause = FinallyClause;
20669 exports.DoStatement = DoStatement;
20670 exports.ForStatement = ForStatement;
20671 exports.ForeachStatement = ForeachStatement;
20672 exports.SwitchStatement = SwitchStatement;
20673 exports.AlternateSwitchStatement = AlternateSwitchStatement;
20674 exports.SwitchSection = SwitchSection;
20675 exports.SwitchFallthrough = SwitchFallthrough;
20676 exports.CaseLabel = CaseLabel;
20677 exports.DefaultLabel = DefaultLabel;
20678 exports.ReturnStatement = ReturnStatement;
20679 exports.GotoLabel = GotoLabel;
20680 exports.GotoStatement = GotoStatement;
20681 exports.ThrowStatement = ThrowStatement;
20682 exports.BreakStatement = BreakStatement;
20683 exports.ContinueStatement = ContinueStatement;
20684 exports.FunctionStaticStatement = FunctionStaticStatement;
20685 exports.StaticDeclarator = StaticDeclarator;
20686 exports.EchoStatement = EchoStatement;
20687 exports.GlobalStatement = GlobalStatement;
20688 exports.SimpleInitializer = SimpleInitializer;
20689 exports.AnonymousClass = AnonymousClass;
20690 exports.AnonymousFunction = AnonymousFunction;
20691 exports.Php7AnonymousFunction = Php7AnonymousFunction;
20692 exports.AnonymousFunctionUseClause = AnonymousFunctionUseClause;
20693 exports.LambdaExpression = LambdaExpression;
20694 exports.LambdaSignature = LambdaSignature;
20695 exports.CastExpression = CastExpression;
20696 exports.ScopeResolutionExpression = ScopeResolutionExpression;
20697 exports.MemberSelectionExpression = MemberSelectionExpression;
20698 exports.SafeMemberSelectionExpression = SafeMemberSelectionExpression;
20699 exports.EmbeddedMemberSelectionExpression = EmbeddedMemberSelectionExpression;
20700 exports.YieldExpression = YieldExpression;
20701 exports.YieldFromExpression = YieldFromExpression;
20702 exports.PrefixUnaryExpression = PrefixUnaryExpression;
20703 exports.PostfixUnaryExpression = PostfixUnaryExpression;
20704 exports.BinaryExpression = BinaryExpression;
20705 exports.InstanceofExpression = InstanceofExpression;
20706 exports.IsExpression = IsExpression;
20707 exports.ConditionalExpression = ConditionalExpression;
20708 exports.EvalExpression = EvalExpression;
20709 exports.EmptyExpression = EmptyExpression;
20710 exports.DefineExpression = DefineExpression;
20711 exports.HaltCompilerExpression = HaltCompilerExpression;
20712 exports.IssetExpression = IssetExpression;
20713 exports.FunctionCallExpression = FunctionCallExpression;
20714 exports.FunctionCallWithTypeArgumentsExpression = FunctionCallWithTypeArgumentsExpression;
20715 exports.ParenthesizedExpression = ParenthesizedExpression;
20716 exports.BracedExpression = BracedExpression;
20717 exports.EmbeddedBracedExpression = EmbeddedBracedExpression;
20718 exports.ListExpression = ListExpression;
20719 exports.CollectionLiteralExpression = CollectionLiteralExpression;
20720 exports.ObjectCreationExpression = ObjectCreationExpression;
20721 exports.ConstructorCall = ConstructorCall;
20722 exports.ArrayCreationExpression = ArrayCreationExpression;
20723 exports.ArrayIntrinsicExpression = ArrayIntrinsicExpression;
20724 exports.DarrayIntrinsicExpression = DarrayIntrinsicExpression;
20725 exports.DictionaryIntrinsicExpression = DictionaryIntrinsicExpression;
20726 exports.KeysetIntrinsicExpression = KeysetIntrinsicExpression;
20727 exports.VarrayIntrinsicExpression = VarrayIntrinsicExpression;
20728 exports.VectorIntrinsicExpression = VectorIntrinsicExpression;
20729 exports.ElementInitializer = ElementInitializer;
20730 exports.SubscriptExpression = SubscriptExpression;
20731 exports.EmbeddedSubscriptExpression = EmbeddedSubscriptExpression;
20732 exports.AwaitableCreationExpression = AwaitableCreationExpression;
20733 exports.XHPChildrenDeclaration = XHPChildrenDeclaration;
20734 exports.XHPChildrenParenthesizedList = XHPChildrenParenthesizedList;
20735 exports.XHPCategoryDeclaration = XHPCategoryDeclaration;
20736 exports.XHPEnumType = XHPEnumType;
20737 exports.XHPRequired = XHPRequired;
20738 exports.XHPClassAttributeDeclaration = XHPClassAttributeDeclaration;
20739 exports.XHPClassAttribute = XHPClassAttribute;
20740 exports.XHPSimpleClassAttribute = XHPSimpleClassAttribute;
20741 exports.XHPSimpleAttribute = XHPSimpleAttribute;
20742 exports.XHPSpreadAttribute = XHPSpreadAttribute;
20743 exports.XHPOpen = XHPOpen;
20744 exports.XHPExpression = XHPExpression;
20745 exports.XHPClose = XHPClose;
20746 exports.TypeConstant = TypeConstant;
20747 exports.VectorTypeSpecifier = VectorTypeSpecifier;
20748 exports.KeysetTypeSpecifier = KeysetTypeSpecifier;
20749 exports.TupleTypeExplicitSpecifier = TupleTypeExplicitSpecifier;
20750 exports.VarrayTypeSpecifier = VarrayTypeSpecifier;
20751 exports.VectorArrayTypeSpecifier = VectorArrayTypeSpecifier;
20752 exports.TypeParameter = TypeParameter;
20753 exports.TypeConstraint = TypeConstraint;
20754 exports.DarrayTypeSpecifier = DarrayTypeSpecifier;
20755 exports.MapArrayTypeSpecifier = MapArrayTypeSpecifier;
20756 exports.DictionaryTypeSpecifier = DictionaryTypeSpecifier;
20757 exports.ClosureTypeSpecifier = ClosureTypeSpecifier;
20758 exports.ClosureParameterTypeSpecifier = ClosureParameterTypeSpecifier;
20759 exports.ClassnameTypeSpecifier = ClassnameTypeSpecifier;
20760 exports.FieldSpecifier = FieldSpecifier;
20761 exports.FieldInitializer = FieldInitializer;
20762 exports.ShapeTypeSpecifier = ShapeTypeSpecifier;
20763 exports.ShapeExpression = ShapeExpression;
20764 exports.TupleExpression = TupleExpression;
20765 exports.GenericTypeSpecifier = GenericTypeSpecifier;
20766 exports.NullableTypeSpecifier = NullableTypeSpecifier;
20767 exports.SoftTypeSpecifier = SoftTypeSpecifier;
20768 exports.TypeArguments = TypeArguments;
20769 exports.TypeParameters = TypeParameters;
20770 exports.TupleTypeSpecifier = TupleTypeSpecifier;
20771 exports.ErrorSyntax = ErrorSyntax;
20772 exports.ListItem = ListItem;