module YARP::DSL

# File yarp/node.rb, line 11413
def AliasGlobalVariableNode(new_name, old_name, keyword_loc, location = Location())
  AliasGlobalVariableNode.new(new_name, old_name, keyword_loc, location)
end

# File yarp/node.rb, line 11418
def AliasMethodNode(new_name, old_name, keyword_loc, location = Location())
  AliasMethodNode.new(new_name, old_name, keyword_loc, location)
end

# File yarp/node.rb, line 11423
def AlternationPatternNode(left, right, operator_loc, location = Location())
  AlternationPatternNode.new(left, right, operator_loc, location)
end

# File yarp/node.rb, line 11428
def AndNode(left, right, operator_loc, location = Location())
  AndNode.new(left, right, operator_loc, location)
end

# File yarp/node.rb, line 11433
def ArgumentsNode(arguments, location = Location())
  ArgumentsNode.new(arguments, location)
end

# File yarp/node.rb, line 11438
def ArrayNode(elements, opening_loc, closing_loc, location = Location())
  ArrayNode.new(elements, opening_loc, closing_loc, location)
end

# File yarp/node.rb, line 11443
def ArrayPatternNode(constant, requireds, rest, posts, opening_loc, closing_loc, location = Location())
  ArrayPatternNode.new(constant, requireds, rest, posts, opening_loc, closing_loc, location)
end

# File yarp/node.rb, line 11448
def AssocNode(key, value, operator_loc, location = Location())
  AssocNode.new(key, value, operator_loc, location)
end

# File yarp/node.rb, line 11453
def AssocSplatNode(value, operator_loc, location = Location())
  AssocSplatNode.new(value, operator_loc, location)
end

# File yarp/node.rb, line 11458
def BackReferenceReadNode(location = Location())
  BackReferenceReadNode.new(location)
end

# File yarp/node.rb, line 11463
def BeginNode(begin_keyword_loc, statements, rescue_clause, else_clause, ensure_clause, end_keyword_loc, location = Location())
  BeginNode.new(begin_keyword_loc, statements, rescue_clause, else_clause, ensure_clause, end_keyword_loc, location)
end

# File yarp/node.rb, line 11468
def BlockArgumentNode(expression, operator_loc, location = Location())
  BlockArgumentNode.new(expression, operator_loc, location)
end

# File yarp/node.rb, line 11473
def BlockLocalVariableNode(name, location = Location())
  BlockLocalVariableNode.new(name, location)
end

# File yarp/node.rb, line 11478
def BlockNode(locals, parameters, body, opening_loc, closing_loc, location = Location())
  BlockNode.new(locals, parameters, body, opening_loc, closing_loc, location)
end

# File yarp/node.rb, line 11483
def BlockParameterNode(name, name_loc, operator_loc, location = Location())
  BlockParameterNode.new(name, name_loc, operator_loc, location)
end

# File yarp/node.rb, line 11488
def BlockParametersNode(parameters, locals, opening_loc, closing_loc, location = Location())
  BlockParametersNode.new(parameters, locals, opening_loc, closing_loc, location)
end

# File yarp/node.rb, line 11493
def BreakNode(arguments, keyword_loc, location = Location())
  BreakNode.new(arguments, keyword_loc, location)
end

# File yarp/node.rb, line 11498
def CallAndWriteNode(receiver, call_operator_loc, message_loc, opening_loc, arguments, closing_loc, flags, read_name, write_name, operator_loc, value, location = Location())
  CallAndWriteNode.new(receiver, call_operator_loc, message_loc, opening_loc, arguments, closing_loc, flags, read_name, write_name, operator_loc, value, location)
end

# File yarp/node.rb, line 11503
def CallNode(receiver, call_operator_loc, message_loc, opening_loc, arguments, closing_loc, block, flags, name, location = Location())
  CallNode.new(receiver, call_operator_loc, message_loc, opening_loc, arguments, closing_loc, block, flags, name, location)
end

# File yarp/node.rb, line 11508
def CallOperatorWriteNode(receiver, call_operator_loc, message_loc, opening_loc, arguments, closing_loc, flags, read_name, write_name, operator, operator_loc, value, location = Location())
  CallOperatorWriteNode.new(receiver, call_operator_loc, message_loc, opening_loc, arguments, closing_loc, flags, read_name, write_name, operator, operator_loc, value, location)
end

# File yarp/node.rb, line 11513
def CallOrWriteNode(receiver, call_operator_loc, message_loc, opening_loc, arguments, closing_loc, flags, read_name, write_name, operator_loc, value, location = Location())
  CallOrWriteNode.new(receiver, call_operator_loc, message_loc, opening_loc, arguments, closing_loc, flags, read_name, write_name, operator_loc, value, location)
end

# File yarp/node.rb, line 11518
def CapturePatternNode(value, target, operator_loc, location = Location())
  CapturePatternNode.new(value, target, operator_loc, location)
end

# File yarp/node.rb, line 11523
def CaseNode(predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, location = Location())
  CaseNode.new(predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, location)
end

# File yarp/node.rb, line 11528
def ClassNode(locals, class_keyword_loc, constant_path, inheritance_operator_loc, superclass, body, end_keyword_loc, name, location = Location())
  ClassNode.new(locals, class_keyword_loc, constant_path, inheritance_operator_loc, superclass, body, end_keyword_loc, name, location)
end

# File yarp/node.rb, line 11533
def ClassVariableAndWriteNode(name, name_loc, operator_loc, value, location = Location())
  ClassVariableAndWriteNode.new(name, name_loc, operator_loc, value, location)
end

# File yarp/node.rb, line 11538
def ClassVariableOperatorWriteNode(name, name_loc, operator_loc, value, operator, location = Location())
  ClassVariableOperatorWriteNode.new(name, name_loc, operator_loc, value, operator, location)
end

# File yarp/node.rb, line 11543
def ClassVariableOrWriteNode(name, name_loc, operator_loc, value, location = Location())
  ClassVariableOrWriteNode.new(name, name_loc, operator_loc, value, location)
end

# File yarp/node.rb, line 11548
def ClassVariableReadNode(name, location = Location())
  ClassVariableReadNode.new(name, location)
end

# File yarp/node.rb, line 11553
def ClassVariableTargetNode(name, location = Location())
  ClassVariableTargetNode.new(name, location)
end

# File yarp/node.rb, line 11558
def ClassVariableWriteNode(name, name_loc, value, operator_loc, location = Location())
  ClassVariableWriteNode.new(name, name_loc, value, operator_loc, location)
end

# File yarp/node.rb, line 11563
def ConstantAndWriteNode(name, name_loc, operator_loc, value, location = Location())
  ConstantAndWriteNode.new(name, name_loc, operator_loc, value, location)
end

# File yarp/node.rb, line 11568
def ConstantOperatorWriteNode(name, name_loc, operator_loc, value, operator, location = Location())
  ConstantOperatorWriteNode.new(name, name_loc, operator_loc, value, operator, location)
end

# File yarp/node.rb, line 11573
def ConstantOrWriteNode(name, name_loc, operator_loc, value, location = Location())
  ConstantOrWriteNode.new(name, name_loc, operator_loc, value, location)
end

# File yarp/node.rb, line 11578
def ConstantPathAndWriteNode(target, operator_loc, value, location = Location())
  ConstantPathAndWriteNode.new(target, operator_loc, value, location)
end

# File yarp/node.rb, line 11583
def ConstantPathNode(parent, child, delimiter_loc, location = Location())
  ConstantPathNode.new(parent, child, delimiter_loc, location)
end

# File yarp/node.rb, line 11588
def ConstantPathOperatorWriteNode(target, operator_loc, value, operator, location = Location())
  ConstantPathOperatorWriteNode.new(target, operator_loc, value, operator, location)
end

# File yarp/node.rb, line 11593
def ConstantPathOrWriteNode(target, operator_loc, value, location = Location())
  ConstantPathOrWriteNode.new(target, operator_loc, value, location)
end

# File yarp/node.rb, line 11598
def ConstantPathTargetNode(parent, child, delimiter_loc, location = Location())
  ConstantPathTargetNode.new(parent, child, delimiter_loc, location)
end

# File yarp/node.rb, line 11603
def ConstantPathWriteNode(target, operator_loc, value, location = Location())
  ConstantPathWriteNode.new(target, operator_loc, value, location)
end

# File yarp/node.rb, line 11608
def ConstantReadNode(name, location = Location())
  ConstantReadNode.new(name, location)
end

# File yarp/node.rb, line 11613
def ConstantTargetNode(name, location = Location())
  ConstantTargetNode.new(name, location)
end

# File yarp/node.rb, line 11618
def ConstantWriteNode(name, name_loc, value, operator_loc, location = Location())
  ConstantWriteNode.new(name, name_loc, value, operator_loc, location)
end

# File yarp/node.rb, line 11623
def DefNode(name, name_loc, receiver, parameters, body, locals, def_keyword_loc, operator_loc, lparen_loc, rparen_loc, equal_loc, end_keyword_loc, location = Location())
  DefNode.new(name, name_loc, receiver, parameters, body, locals, def_keyword_loc, operator_loc, lparen_loc, rparen_loc, equal_loc, end_keyword_loc, location)
end

# File yarp/node.rb, line 11628
def DefinedNode(lparen_loc, value, rparen_loc, keyword_loc, location = Location())
  DefinedNode.new(lparen_loc, value, rparen_loc, keyword_loc, location)
end

# File yarp/node.rb, line 11633
def ElseNode(else_keyword_loc, statements, end_keyword_loc, location = Location())
  ElseNode.new(else_keyword_loc, statements, end_keyword_loc, location)
end

# File yarp/node.rb, line 11638
def EmbeddedStatementsNode(opening_loc, statements, closing_loc, location = Location())
  EmbeddedStatementsNode.new(opening_loc, statements, closing_loc, location)
end

# File yarp/node.rb, line 11643
def EmbeddedVariableNode(operator_loc, variable, location = Location())
  EmbeddedVariableNode.new(operator_loc, variable, location)
end

# File yarp/node.rb, line 11648
def EnsureNode(ensure_keyword_loc, statements, end_keyword_loc, location = Location())
  EnsureNode.new(ensure_keyword_loc, statements, end_keyword_loc, location)
end

# File yarp/node.rb, line 11653
def FalseNode(location = Location())
  FalseNode.new(location)
end

# File yarp/node.rb, line 11658
def FindPatternNode(constant, left, requireds, right, opening_loc, closing_loc, location = Location())
  FindPatternNode.new(constant, left, requireds, right, opening_loc, closing_loc, location)
end

# File yarp/node.rb, line 11663
def FlipFlopNode(left, right, operator_loc, flags, location = Location())
  FlipFlopNode.new(left, right, operator_loc, flags, location)
end

# File yarp/node.rb, line 11668
def FloatNode(location = Location())
  FloatNode.new(location)
end

# File yarp/node.rb, line 11673
def ForNode(index, collection, statements, for_keyword_loc, in_keyword_loc, do_keyword_loc, end_keyword_loc, location = Location())
  ForNode.new(index, collection, statements, for_keyword_loc, in_keyword_loc, do_keyword_loc, end_keyword_loc, location)
end

# File yarp/node.rb, line 11678
def ForwardingArgumentsNode(location = Location())
  ForwardingArgumentsNode.new(location)
end

# File yarp/node.rb, line 11683
def ForwardingParameterNode(location = Location())
  ForwardingParameterNode.new(location)
end

# File yarp/node.rb, line 11688
def ForwardingSuperNode(block, location = Location())
  ForwardingSuperNode.new(block, location)
end

# File yarp/node.rb, line 11693
def GlobalVariableAndWriteNode(name, name_loc, operator_loc, value, location = Location())
  GlobalVariableAndWriteNode.new(name, name_loc, operator_loc, value, location)
end

# File yarp/node.rb, line 11698
def GlobalVariableOperatorWriteNode(name, name_loc, operator_loc, value, operator, location = Location())
  GlobalVariableOperatorWriteNode.new(name, name_loc, operator_loc, value, operator, location)
end

# File yarp/node.rb, line 11703
def GlobalVariableOrWriteNode(name, name_loc, operator_loc, value, location = Location())
  GlobalVariableOrWriteNode.new(name, name_loc, operator_loc, value, location)
end

# File yarp/node.rb, line 11708
def GlobalVariableReadNode(name, location = Location())
  GlobalVariableReadNode.new(name, location)
end

# File yarp/node.rb, line 11713
def GlobalVariableTargetNode(name, location = Location())
  GlobalVariableTargetNode.new(name, location)
end

# File yarp/node.rb, line 11718
def GlobalVariableWriteNode(name, name_loc, value, operator_loc, location = Location())
  GlobalVariableWriteNode.new(name, name_loc, value, operator_loc, location)
end

# File yarp/node.rb, line 11723
def HashNode(opening_loc, elements, closing_loc, location = Location())
  HashNode.new(opening_loc, elements, closing_loc, location)
end

# File yarp/node.rb, line 11728
def HashPatternNode(constant, assocs, kwrest, opening_loc, closing_loc, location = Location())
  HashPatternNode.new(constant, assocs, kwrest, opening_loc, closing_loc, location)
end

# File yarp/node.rb, line 11733
def IfNode(if_keyword_loc, predicate, statements, consequent, end_keyword_loc, location = Location())
  IfNode.new(if_keyword_loc, predicate, statements, consequent, end_keyword_loc, location)
end

# File yarp/node.rb, line 11738
def ImaginaryNode(numeric, location = Location())
  ImaginaryNode.new(numeric, location)
end

# File yarp/node.rb, line 11743
def InNode(pattern, statements, in_loc, then_loc, location = Location())
  InNode.new(pattern, statements, in_loc, then_loc, location)
end

# File yarp/node.rb, line 11748
def InstanceVariableAndWriteNode(name, name_loc, operator_loc, value, location = Location())
  InstanceVariableAndWriteNode.new(name, name_loc, operator_loc, value, location)
end

# File yarp/node.rb, line 11753
def InstanceVariableOperatorWriteNode(name, name_loc, operator_loc, value, operator, location = Location())
  InstanceVariableOperatorWriteNode.new(name, name_loc, operator_loc, value, operator, location)
end

# File yarp/node.rb, line 11758
def InstanceVariableOrWriteNode(name, name_loc, operator_loc, value, location = Location())
  InstanceVariableOrWriteNode.new(name, name_loc, operator_loc, value, location)
end

# File yarp/node.rb, line 11763
def InstanceVariableReadNode(name, location = Location())
  InstanceVariableReadNode.new(name, location)
end

# File yarp/node.rb, line 11768
def InstanceVariableTargetNode(name, location = Location())
  InstanceVariableTargetNode.new(name, location)
end

# File yarp/node.rb, line 11773
def InstanceVariableWriteNode(name, name_loc, value, operator_loc, location = Location())
  InstanceVariableWriteNode.new(name, name_loc, value, operator_loc, location)
end

# File yarp/node.rb, line 11778
def IntegerNode(flags, location = Location())
  IntegerNode.new(flags, location)
end

# File yarp/node.rb, line 11783
def InterpolatedMatchLastLineNode(opening_loc, parts, closing_loc, flags, location = Location())
  InterpolatedMatchLastLineNode.new(opening_loc, parts, closing_loc, flags, location)
end

# File yarp/node.rb, line 11788
def InterpolatedRegularExpressionNode(opening_loc, parts, closing_loc, flags, location = Location())
  InterpolatedRegularExpressionNode.new(opening_loc, parts, closing_loc, flags, location)
end

# File yarp/node.rb, line 11793
def InterpolatedStringNode(opening_loc, parts, closing_loc, location = Location())
  InterpolatedStringNode.new(opening_loc, parts, closing_loc, location)
end

# File yarp/node.rb, line 11798
def InterpolatedSymbolNode(opening_loc, parts, closing_loc, location = Location())
  InterpolatedSymbolNode.new(opening_loc, parts, closing_loc, location)
end

# File yarp/node.rb, line 11803
def InterpolatedXStringNode(opening_loc, parts, closing_loc, location = Location())
  InterpolatedXStringNode.new(opening_loc, parts, closing_loc, location)
end

# File yarp/node.rb, line 11808
def KeywordHashNode(elements, location = Location())
  KeywordHashNode.new(elements, location)
end

# File yarp/node.rb, line 11813
def KeywordParameterNode(name, name_loc, value, location = Location())
  KeywordParameterNode.new(name, name_loc, value, location)
end

# File yarp/node.rb, line 11818
def KeywordRestParameterNode(name, name_loc, operator_loc, location = Location())
  KeywordRestParameterNode.new(name, name_loc, operator_loc, location)
end

# File yarp/node.rb, line 11823
def LambdaNode(locals, operator_loc, opening_loc, closing_loc, parameters, body, location = Location())
  LambdaNode.new(locals, operator_loc, opening_loc, closing_loc, parameters, body, location)
end

# File yarp/node.rb, line 11828
def LocalVariableAndWriteNode(name_loc, operator_loc, value, name, depth, location = Location())
  LocalVariableAndWriteNode.new(name_loc, operator_loc, value, name, depth, location)
end

# File yarp/node.rb, line 11833
def LocalVariableOperatorWriteNode(name_loc, operator_loc, value, name, operator, depth, location = Location())
  LocalVariableOperatorWriteNode.new(name_loc, operator_loc, value, name, operator, depth, location)
end

# File yarp/node.rb, line 11838
def LocalVariableOrWriteNode(name_loc, operator_loc, value, name, depth, location = Location())
  LocalVariableOrWriteNode.new(name_loc, operator_loc, value, name, depth, location)
end

# File yarp/node.rb, line 11843
def LocalVariableReadNode(name, depth, location = Location())
  LocalVariableReadNode.new(name, depth, location)
end

# File yarp/node.rb, line 11848
def LocalVariableTargetNode(name, depth, location = Location())
  LocalVariableTargetNode.new(name, depth, location)
end

# File yarp/node.rb, line 11853
def LocalVariableWriteNode(name, depth, name_loc, value, operator_loc, location = Location())
  LocalVariableWriteNode.new(name, depth, name_loc, value, operator_loc, location)
end

# File yarp/node.rb, line 11408
def Location(source = nil, start_offset = 0, length = 0)
  Location.new(source, start_offset, length)
end

# File yarp/node.rb, line 11858
def MatchLastLineNode(opening_loc, content_loc, closing_loc, unescaped, flags, location = Location())
  MatchLastLineNode.new(opening_loc, content_loc, closing_loc, unescaped, flags, location)
end

# File yarp/node.rb, line 11863
def MatchPredicateNode(value, pattern, operator_loc, location = Location())
  MatchPredicateNode.new(value, pattern, operator_loc, location)
end

# File yarp/node.rb, line 11868
def MatchRequiredNode(value, pattern, operator_loc, location = Location())
  MatchRequiredNode.new(value, pattern, operator_loc, location)
end

# File yarp/node.rb, line 11873
def MissingNode(location = Location())
  MissingNode.new(location)
end

# File yarp/node.rb, line 11878
def ModuleNode(locals, module_keyword_loc, constant_path, body, end_keyword_loc, name, location = Location())
  ModuleNode.new(locals, module_keyword_loc, constant_path, body, end_keyword_loc, name, location)
end

# File yarp/node.rb, line 11883
def MultiTargetNode(targets, lparen_loc, rparen_loc, location = Location())
  MultiTargetNode.new(targets, lparen_loc, rparen_loc, location)
end

# File yarp/node.rb, line 11888
def MultiWriteNode(targets, lparen_loc, rparen_loc, operator_loc, value, location = Location())
  MultiWriteNode.new(targets, lparen_loc, rparen_loc, operator_loc, value, location)
end

# File yarp/node.rb, line 11893
def NextNode(arguments, keyword_loc, location = Location())
  NextNode.new(arguments, keyword_loc, location)
end

# File yarp/node.rb, line 11898
def NilNode(location = Location())
  NilNode.new(location)
end

# File yarp/node.rb, line 11903
def NoKeywordsParameterNode(operator_loc, keyword_loc, location = Location())
  NoKeywordsParameterNode.new(operator_loc, keyword_loc, location)
end

# File yarp/node.rb, line 11908
def NumberedReferenceReadNode(number, location = Location())
  NumberedReferenceReadNode.new(number, location)
end

# File yarp/node.rb, line 11913
def OptionalParameterNode(name, name_loc, operator_loc, value, location = Location())
  OptionalParameterNode.new(name, name_loc, operator_loc, value, location)
end

# File yarp/node.rb, line 11918
def OrNode(left, right, operator_loc, location = Location())
  OrNode.new(left, right, operator_loc, location)
end

# File yarp/node.rb, line 11923
def ParametersNode(requireds, optionals, rest, posts, keywords, keyword_rest, block, location = Location())
  ParametersNode.new(requireds, optionals, rest, posts, keywords, keyword_rest, block, location)
end

# File yarp/node.rb, line 11928
def ParenthesesNode(body, opening_loc, closing_loc, location = Location())
  ParenthesesNode.new(body, opening_loc, closing_loc, location)
end

# File yarp/node.rb, line 11933
def PinnedExpressionNode(expression, operator_loc, lparen_loc, rparen_loc, location = Location())
  PinnedExpressionNode.new(expression, operator_loc, lparen_loc, rparen_loc, location)
end

# File yarp/node.rb, line 11938
def PinnedVariableNode(variable, operator_loc, location = Location())
  PinnedVariableNode.new(variable, operator_loc, location)
end

# File yarp/node.rb, line 11943
def PostExecutionNode(statements, keyword_loc, opening_loc, closing_loc, location = Location())
  PostExecutionNode.new(statements, keyword_loc, opening_loc, closing_loc, location)
end

# File yarp/node.rb, line 11948
def PreExecutionNode(statements, keyword_loc, opening_loc, closing_loc, location = Location())
  PreExecutionNode.new(statements, keyword_loc, opening_loc, closing_loc, location)
end

# File yarp/node.rb, line 11953
def ProgramNode(locals, statements, location = Location())
  ProgramNode.new(locals, statements, location)
end

# File yarp/node.rb, line 11958
def RangeNode(left, right, operator_loc, flags, location = Location())
  RangeNode.new(left, right, operator_loc, flags, location)
end

# File yarp/node.rb, line 11963
def RationalNode(numeric, location = Location())
  RationalNode.new(numeric, location)
end

# File yarp/node.rb, line 11968
def RedoNode(location = Location())
  RedoNode.new(location)
end

# File yarp/node.rb, line 11973
def RegularExpressionNode(opening_loc, content_loc, closing_loc, unescaped, flags, location = Location())
  RegularExpressionNode.new(opening_loc, content_loc, closing_loc, unescaped, flags, location)
end

# File yarp/node.rb, line 11978
def RequiredDestructuredParameterNode(parameters, opening_loc, closing_loc, location = Location())
  RequiredDestructuredParameterNode.new(parameters, opening_loc, closing_loc, location)
end

# File yarp/node.rb, line 11983
def RequiredParameterNode(name, location = Location())
  RequiredParameterNode.new(name, location)
end

# File yarp/node.rb, line 11988
def RescueModifierNode(expression, keyword_loc, rescue_expression, location = Location())
  RescueModifierNode.new(expression, keyword_loc, rescue_expression, location)
end

# File yarp/node.rb, line 11993
def RescueNode(keyword_loc, exceptions, operator_loc, reference, statements, consequent, location = Location())
  RescueNode.new(keyword_loc, exceptions, operator_loc, reference, statements, consequent, location)
end

# File yarp/node.rb, line 11998
def RestParameterNode(name, name_loc, operator_loc, location = Location())
  RestParameterNode.new(name, name_loc, operator_loc, location)
end

# File yarp/node.rb, line 12003
def RetryNode(location = Location())
  RetryNode.new(location)
end

# File yarp/node.rb, line 12008
def ReturnNode(keyword_loc, arguments, location = Location())
  ReturnNode.new(keyword_loc, arguments, location)
end

# File yarp/node.rb, line 12013
def SelfNode(location = Location())
  SelfNode.new(location)
end

# File yarp/node.rb, line 12018
def SingletonClassNode(locals, class_keyword_loc, operator_loc, expression, body, end_keyword_loc, location = Location())
  SingletonClassNode.new(locals, class_keyword_loc, operator_loc, expression, body, end_keyword_loc, location)
end

# File yarp/node.rb, line 12023
def SourceEncodingNode(location = Location())
  SourceEncodingNode.new(location)
end

# File yarp/node.rb, line 12028
def SourceFileNode(filepath, location = Location())
  SourceFileNode.new(filepath, location)
end

# File yarp/node.rb, line 12033
def SourceLineNode(location = Location())
  SourceLineNode.new(location)
end

# File yarp/node.rb, line 12038
def SplatNode(operator_loc, expression, location = Location())
  SplatNode.new(operator_loc, expression, location)
end

# File yarp/node.rb, line 12043
def StatementsNode(body, location = Location())
  StatementsNode.new(body, location)
end

# File yarp/node.rb, line 12048
def StringConcatNode(left, right, location = Location())
  StringConcatNode.new(left, right, location)
end

# File yarp/node.rb, line 12053
def StringNode(opening_loc, content_loc, closing_loc, unescaped, location = Location())
  StringNode.new(opening_loc, content_loc, closing_loc, unescaped, location)
end

# File yarp/node.rb, line 12058
def SuperNode(keyword_loc, lparen_loc, arguments, rparen_loc, block, location = Location())
  SuperNode.new(keyword_loc, lparen_loc, arguments, rparen_loc, block, location)
end

# File yarp/node.rb, line 12063
def SymbolNode(opening_loc, value_loc, closing_loc, unescaped, location = Location())
  SymbolNode.new(opening_loc, value_loc, closing_loc, unescaped, location)
end

# File yarp/node.rb, line 12068
def TrueNode(location = Location())
  TrueNode.new(location)
end

# File yarp/node.rb, line 12073
def UndefNode(names, keyword_loc, location = Location())
  UndefNode.new(names, keyword_loc, location)
end

# File yarp/node.rb, line 12078
def UnlessNode(keyword_loc, predicate, statements, consequent, end_keyword_loc, location = Location())
  UnlessNode.new(keyword_loc, predicate, statements, consequent, end_keyword_loc, location)
end

# File yarp/node.rb, line 12083
def UntilNode(keyword_loc, closing_loc, predicate, statements, flags, location = Location())
  UntilNode.new(keyword_loc, closing_loc, predicate, statements, flags, location)
end

# File yarp/node.rb, line 12088
def WhenNode(keyword_loc, conditions, statements, location = Location())
  WhenNode.new(keyword_loc, conditions, statements, location)
end

# File yarp/node.rb, line 12093
def WhileNode(keyword_loc, closing_loc, predicate, statements, flags, location = Location())
  WhileNode.new(keyword_loc, closing_loc, predicate, statements, flags, location)
end

# File yarp/node.rb, line 12098
def XStringNode(opening_loc, content_loc, closing_loc, unescaped, location = Location())
  XStringNode.new(opening_loc, content_loc, closing_loc, unescaped, location)
end

# File yarp/node.rb, line 12103
def YieldNode(keyword_loc, lparen_loc, arguments, rparen_loc, location = Location())
  YieldNode.new(keyword_loc, lparen_loc, arguments, rparen_loc, location)
end