module Prism::DSL

def AliasGlobalVariableNode(new_name, old_name, keyword_loc, location = Location())

Create a new AliasGlobalVariableNode node 
def AliasGlobalVariableNode(new_name, old_name, keyword_loc, location = Location())
  AliasGlobalVariableNode.new(new_name, old_name, keyword_loc, location)
end

def AliasMethodNode(new_name, old_name, keyword_loc, location = Location())

Create a new AliasMethodNode node 
def AliasMethodNode(new_name, old_name, keyword_loc, location = Location())
  AliasMethodNode.new(new_name, old_name, keyword_loc, location)
end

def AlternationPatternNode(left, right, operator_loc, location = Location())

Create a new AlternationPatternNode node 
def AlternationPatternNode(left, right, operator_loc, location = Location())
  AlternationPatternNode.new(left, right, operator_loc, location)
end

def AndNode(left, right, operator_loc, location = Location())

Create a new AndNode node 
def AndNode(left, right, operator_loc, location = Location())
  AndNode.new(left, right, operator_loc, location)
end

def ArgumentsNode(flags, arguments, location = Location())

Create a new ArgumentsNode node 
def ArgumentsNode(flags, arguments, location = Location())
  ArgumentsNode.new(flags, arguments, location)
end

def ArrayNode(flags, elements, opening_loc, closing_loc, location = Location())

Create a new ArrayNode node 
def ArrayNode(flags, elements, opening_loc, closing_loc, location = Location())
  ArrayNode.new(flags, elements, opening_loc, closing_loc, location)
end

def ArrayPatternNode(constant, requireds, rest, posts, opening_loc, closing_loc, location = Location())

Create a new ArrayPatternNode node 
def ArrayPatternNode(constant, requireds, rest, posts, opening_loc, closing_loc, location = Location())
  ArrayPatternNode.new(constant, requireds, rest, posts, opening_loc, closing_loc, location)
end

def AssocNode(key, value, operator_loc, location = Location())

Create a new AssocNode node 
def AssocNode(key, value, operator_loc, location = Location())
  AssocNode.new(key, value, operator_loc, location)
end

def AssocSplatNode(value, operator_loc, location = Location())

Create a new AssocSplatNode node 
def AssocSplatNode(value, operator_loc, location = Location())
  AssocSplatNode.new(value, operator_loc, location)
end

def BackReferenceReadNode(name, location = Location())

Create a new BackReferenceReadNode node 
def BackReferenceReadNode(name, location = Location())
  BackReferenceReadNode.new(name, location)
end

def BeginNode(begin_keyword_loc, statements, rescue_clause, else_clause, ensure_clause, end_keyword_loc, location = Location())

Create a new BeginNode node 
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

def BlockArgumentNode(expression, operator_loc, location = Location())

Create a new BlockArgumentNode node 
def BlockArgumentNode(expression, operator_loc, location = Location())
  BlockArgumentNode.new(expression, operator_loc, location)
end

def BlockLocalVariableNode(flags, name, location = Location())

Create a new BlockLocalVariableNode node 
def BlockLocalVariableNode(flags, name, location = Location())
  BlockLocalVariableNode.new(flags, name, location)
end

def BlockNode(locals, parameters, body, opening_loc, closing_loc, location = Location())

Create a new BlockNode node 
def BlockNode(locals, parameters, body, opening_loc, closing_loc, location = Location())
  BlockNode.new(locals, parameters, body, opening_loc, closing_loc, location)
end

def BlockParameterNode(flags, name, name_loc, operator_loc, location = Location())

Create a new BlockParameterNode node 
def BlockParameterNode(flags, name, name_loc, operator_loc, location = Location())
  BlockParameterNode.new(flags, name, name_loc, operator_loc, location)
end

def BlockParametersNode(parameters, locals, opening_loc, closing_loc, location = Location())

Create a new BlockParametersNode node 
def BlockParametersNode(parameters, locals, opening_loc, closing_loc, location = Location())
  BlockParametersNode.new(parameters, locals, opening_loc, closing_loc, location)
end

def BreakNode(arguments, keyword_loc, location = Location())

Create a new BreakNode node 
def BreakNode(arguments, keyword_loc, location = Location())
  BreakNode.new(arguments, keyword_loc, location)
end

def CallAndWriteNode(flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator_loc, value, location = Location())

Create a new CallAndWriteNode node 
def CallAndWriteNode(flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator_loc, value, location = Location())
  CallAndWriteNode.new(flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator_loc, value, location)
end

def CallNode(flags, receiver, call_operator_loc, name, message_loc, opening_loc, arguments, closing_loc, block, location = Location())

Create a new CallNode node 
def CallNode(flags, receiver, call_operator_loc, name, message_loc, opening_loc, arguments, closing_loc, block, location = Location())
  CallNode.new(flags, receiver, call_operator_loc, name, message_loc, opening_loc, arguments, closing_loc, block, location)
end

def CallOperatorWriteNode(flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator, operator_loc, value, location = Location())

Create a new CallOperatorWriteNode node 
def CallOperatorWriteNode(flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator, operator_loc, value, location = Location())
  CallOperatorWriteNode.new(flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator, operator_loc, value, location)
end

def CallOrWriteNode(flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator_loc, value, location = Location())

Create a new CallOrWriteNode node 
def CallOrWriteNode(flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator_loc, value, location = Location())
  CallOrWriteNode.new(flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator_loc, value, location)
end

def CallTargetNode(flags, receiver, call_operator_loc, name, message_loc, location = Location())

Create a new CallTargetNode node 
def CallTargetNode(flags, receiver, call_operator_loc, name, message_loc, location = Location())
  CallTargetNode.new(flags, receiver, call_operator_loc, name, message_loc, location)
end

def CapturePatternNode(value, target, operator_loc, location = Location())

Create a new CapturePatternNode node 
def CapturePatternNode(value, target, operator_loc, location = Location())
  CapturePatternNode.new(value, target, operator_loc, location)
end

def CaseMatchNode(predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, location = Location())

Create a new CaseMatchNode node 
def CaseMatchNode(predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, location = Location())
  CaseMatchNode.new(predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, location)
end

def CaseNode(predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, location = Location())

Create a new CaseNode node 
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

def ClassNode(locals, class_keyword_loc, constant_path, inheritance_operator_loc, superclass, body, end_keyword_loc, name, location = Location())

Create a new ClassNode node 
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

def ClassVariableAndWriteNode(name, name_loc, operator_loc, value, location = Location())

Create a new ClassVariableAndWriteNode node 
def ClassVariableAndWriteNode(name, name_loc, operator_loc, value, location = Location())
  ClassVariableAndWriteNode.new(name, name_loc, operator_loc, value, location)
end

def ClassVariableOperatorWriteNode(name, name_loc, operator_loc, value, operator, location = Location())

Create a new ClassVariableOperatorWriteNode node 
def ClassVariableOperatorWriteNode(name, name_loc, operator_loc, value, operator, location = Location())
  ClassVariableOperatorWriteNode.new(name, name_loc, operator_loc, value, operator, location)
end

def ClassVariableOrWriteNode(name, name_loc, operator_loc, value, location = Location())

Create a new ClassVariableOrWriteNode node 
def ClassVariableOrWriteNode(name, name_loc, operator_loc, value, location = Location())
  ClassVariableOrWriteNode.new(name, name_loc, operator_loc, value, location)
end

def ClassVariableReadNode(name, location = Location())

Create a new ClassVariableReadNode node 
def ClassVariableReadNode(name, location = Location())
  ClassVariableReadNode.new(name, location)
end

def ClassVariableTargetNode(name, location = Location())

Create a new ClassVariableTargetNode node 
def ClassVariableTargetNode(name, location = Location())
  ClassVariableTargetNode.new(name, location)
end

def ClassVariableWriteNode(name, name_loc, value, operator_loc, location = Location())

Create a new ClassVariableWriteNode node 
def ClassVariableWriteNode(name, name_loc, value, operator_loc, location = Location())
  ClassVariableWriteNode.new(name, name_loc, value, operator_loc, location)
end

def ConstantAndWriteNode(name, name_loc, operator_loc, value, location = Location())

Create a new ConstantAndWriteNode node 
def ConstantAndWriteNode(name, name_loc, operator_loc, value, location = Location())
  ConstantAndWriteNode.new(name, name_loc, operator_loc, value, location)
end

def ConstantOperatorWriteNode(name, name_loc, operator_loc, value, operator, location = Location())

Create a new ConstantOperatorWriteNode node 
def ConstantOperatorWriteNode(name, name_loc, operator_loc, value, operator, location = Location())
  ConstantOperatorWriteNode.new(name, name_loc, operator_loc, value, operator, location)
end

def ConstantOrWriteNode(name, name_loc, operator_loc, value, location = Location())

Create a new ConstantOrWriteNode node 
def ConstantOrWriteNode(name, name_loc, operator_loc, value, location = Location())
  ConstantOrWriteNode.new(name, name_loc, operator_loc, value, location)
end

def ConstantPathAndWriteNode(target, operator_loc, value, location = Location())

Create a new ConstantPathAndWriteNode node 
def ConstantPathAndWriteNode(target, operator_loc, value, location = Location())
  ConstantPathAndWriteNode.new(target, operator_loc, value, location)
end

def ConstantPathNode(parent, child, delimiter_loc, location = Location())

Create a new ConstantPathNode node 
def ConstantPathNode(parent, child, delimiter_loc, location = Location())
  ConstantPathNode.new(parent, child, delimiter_loc, location)
end

def ConstantPathOperatorWriteNode(target, operator_loc, value, operator, location = Location())

Create a new ConstantPathOperatorWriteNode node 
def ConstantPathOperatorWriteNode(target, operator_loc, value, operator, location = Location())
  ConstantPathOperatorWriteNode.new(target, operator_loc, value, operator, location)
end

def ConstantPathOrWriteNode(target, operator_loc, value, location = Location())

Create a new ConstantPathOrWriteNode node 
def ConstantPathOrWriteNode(target, operator_loc, value, location = Location())
  ConstantPathOrWriteNode.new(target, operator_loc, value, location)
end

def ConstantPathTargetNode(parent, child, delimiter_loc, location = Location())

Create a new ConstantPathTargetNode node 
def ConstantPathTargetNode(parent, child, delimiter_loc, location = Location())
  ConstantPathTargetNode.new(parent, child, delimiter_loc, location)
end

def ConstantPathWriteNode(target, operator_loc, value, location = Location())

Create a new ConstantPathWriteNode node 
def ConstantPathWriteNode(target, operator_loc, value, location = Location())
  ConstantPathWriteNode.new(target, operator_loc, value, location)
end

def ConstantReadNode(name, location = Location())

Create a new ConstantReadNode node 
def ConstantReadNode(name, location = Location())
  ConstantReadNode.new(name, location)
end

def ConstantTargetNode(name, location = Location())

Create a new ConstantTargetNode node 
def ConstantTargetNode(name, location = Location())
  ConstantTargetNode.new(name, location)
end

def ConstantWriteNode(name, name_loc, value, operator_loc, location = Location())

Create a new ConstantWriteNode node 
def ConstantWriteNode(name, name_loc, value, operator_loc, location = Location())
  ConstantWriteNode.new(name, name_loc, value, operator_loc, location)
end

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())

Create a new DefNode node 
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

def DefinedNode(lparen_loc, value, rparen_loc, keyword_loc, location = Location())

Create a new DefinedNode node 
def DefinedNode(lparen_loc, value, rparen_loc, keyword_loc, location = Location())
  DefinedNode.new(lparen_loc, value, rparen_loc, keyword_loc, location)
end

def ElseNode(else_keyword_loc, statements, end_keyword_loc, location = Location())

Create a new ElseNode node 
def ElseNode(else_keyword_loc, statements, end_keyword_loc, location = Location())
  ElseNode.new(else_keyword_loc, statements, end_keyword_loc, location)
end

def EmbeddedStatementsNode(opening_loc, statements, closing_loc, location = Location())

Create a new EmbeddedStatementsNode node 
def EmbeddedStatementsNode(opening_loc, statements, closing_loc, location = Location())
  EmbeddedStatementsNode.new(opening_loc, statements, closing_loc, location)
end

def EmbeddedVariableNode(operator_loc, variable, location = Location())

Create a new EmbeddedVariableNode node 
def EmbeddedVariableNode(operator_loc, variable, location = Location())
  EmbeddedVariableNode.new(operator_loc, variable, location)
end

def EnsureNode(ensure_keyword_loc, statements, end_keyword_loc, location = Location())

Create a new EnsureNode node 
def EnsureNode(ensure_keyword_loc, statements, end_keyword_loc, location = Location())
  EnsureNode.new(ensure_keyword_loc, statements, end_keyword_loc, location)
end

def FalseNode(location = Location())

Create a new FalseNode node 
def FalseNode(location = Location())
  FalseNode.new(location)
end

def FindPatternNode(constant, left, requireds, right, opening_loc, closing_loc, location = Location())

Create a new FindPatternNode node 
def FindPatternNode(constant, left, requireds, right, opening_loc, closing_loc, location = Location())
  FindPatternNode.new(constant, left, requireds, right, opening_loc, closing_loc, location)
end

def FlipFlopNode(flags, left, right, operator_loc, location = Location())

Create a new FlipFlopNode node 
def FlipFlopNode(flags, left, right, operator_loc, location = Location())
  FlipFlopNode.new(flags, left, right, operator_loc, location)
end

def FloatNode(location = Location())

Create a new FloatNode node 
def FloatNode(location = Location())
  FloatNode.new(location)
end

def ForNode(index, collection, statements, for_keyword_loc, in_keyword_loc, do_keyword_loc, end_keyword_loc, location = Location())

Create a new ForNode node 
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

def ForwardingArgumentsNode(location = Location())

Create a new ForwardingArgumentsNode node 
def ForwardingArgumentsNode(location = Location())
  ForwardingArgumentsNode.new(location)
end

def ForwardingParameterNode(location = Location())

Create a new ForwardingParameterNode node 
def ForwardingParameterNode(location = Location())
  ForwardingParameterNode.new(location)
end

def ForwardingSuperNode(block, location = Location())

Create a new ForwardingSuperNode node 
def ForwardingSuperNode(block, location = Location())
  ForwardingSuperNode.new(block, location)
end

def GlobalVariableAndWriteNode(name, name_loc, operator_loc, value, location = Location())

Create a new GlobalVariableAndWriteNode node 
def GlobalVariableAndWriteNode(name, name_loc, operator_loc, value, location = Location())
  GlobalVariableAndWriteNode.new(name, name_loc, operator_loc, value, location)
end

def GlobalVariableOperatorWriteNode(name, name_loc, operator_loc, value, operator, location = Location())

Create a new GlobalVariableOperatorWriteNode node 
def GlobalVariableOperatorWriteNode(name, name_loc, operator_loc, value, operator, location = Location())
  GlobalVariableOperatorWriteNode.new(name, name_loc, operator_loc, value, operator, location)
end

def GlobalVariableOrWriteNode(name, name_loc, operator_loc, value, location = Location())

Create a new GlobalVariableOrWriteNode node 
def GlobalVariableOrWriteNode(name, name_loc, operator_loc, value, location = Location())
  GlobalVariableOrWriteNode.new(name, name_loc, operator_loc, value, location)
end

def GlobalVariableReadNode(name, location = Location())

Create a new GlobalVariableReadNode node 
def GlobalVariableReadNode(name, location = Location())
  GlobalVariableReadNode.new(name, location)
end

def GlobalVariableTargetNode(name, location = Location())

Create a new GlobalVariableTargetNode node 
def GlobalVariableTargetNode(name, location = Location())
  GlobalVariableTargetNode.new(name, location)
end

def GlobalVariableWriteNode(name, name_loc, value, operator_loc, location = Location())

Create a new GlobalVariableWriteNode node 
def GlobalVariableWriteNode(name, name_loc, value, operator_loc, location = Location())
  GlobalVariableWriteNode.new(name, name_loc, value, operator_loc, location)
end

def HashNode(opening_loc, elements, closing_loc, location = Location())

Create a new HashNode node 
def HashNode(opening_loc, elements, closing_loc, location = Location())
  HashNode.new(opening_loc, elements, closing_loc, location)
end

def HashPatternNode(constant, elements, rest, opening_loc, closing_loc, location = Location())

Create a new HashPatternNode node 
def HashPatternNode(constant, elements, rest, opening_loc, closing_loc, location = Location())
  HashPatternNode.new(constant, elements, rest, opening_loc, closing_loc, location)
end

def IfNode(if_keyword_loc, predicate, then_keyword_loc, statements, consequent, end_keyword_loc, location = Location())

Create a new IfNode node 
def IfNode(if_keyword_loc, predicate, then_keyword_loc, statements, consequent, end_keyword_loc, location = Location())
  IfNode.new(if_keyword_loc, predicate, then_keyword_loc, statements, consequent, end_keyword_loc, location)
end

def ImaginaryNode(numeric, location = Location())

Create a new ImaginaryNode node 
def ImaginaryNode(numeric, location = Location())
  ImaginaryNode.new(numeric, location)
end

def ImplicitNode(value, location = Location())

Create a new ImplicitNode node 
def ImplicitNode(value, location = Location())
  ImplicitNode.new(value, location)
end

def ImplicitRestNode(location = Location())

Create a new ImplicitRestNode node 
def ImplicitRestNode(location = Location())
  ImplicitRestNode.new(location)
end

def InNode(pattern, statements, in_loc, then_loc, location = Location())

Create a new InNode node 
def InNode(pattern, statements, in_loc, then_loc, location = Location())
  InNode.new(pattern, statements, in_loc, then_loc, location)
end

def IndexAndWriteNode(flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator_loc, value, location = Location())

Create a new IndexAndWriteNode node 
def IndexAndWriteNode(flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator_loc, value, location = Location())
  IndexAndWriteNode.new(flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator_loc, value, location)
end

def IndexOperatorWriteNode(flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator, operator_loc, value, location = Location())

Create a new IndexOperatorWriteNode node 
def IndexOperatorWriteNode(flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator, operator_loc, value, location = Location())
  IndexOperatorWriteNode.new(flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator, operator_loc, value, location)
end

def IndexOrWriteNode(flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator_loc, value, location = Location())

Create a new IndexOrWriteNode node 
def IndexOrWriteNode(flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator_loc, value, location = Location())
  IndexOrWriteNode.new(flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator_loc, value, location)
end

def IndexTargetNode(flags, receiver, opening_loc, arguments, closing_loc, block, location = Location())

Create a new IndexTargetNode node 
def IndexTargetNode(flags, receiver, opening_loc, arguments, closing_loc, block, location = Location())
  IndexTargetNode.new(flags, receiver, opening_loc, arguments, closing_loc, block, location)
end

def InstanceVariableAndWriteNode(name, name_loc, operator_loc, value, location = Location())

Create a new InstanceVariableAndWriteNode node 
def InstanceVariableAndWriteNode(name, name_loc, operator_loc, value, location = Location())
  InstanceVariableAndWriteNode.new(name, name_loc, operator_loc, value, location)
end

def InstanceVariableOperatorWriteNode(name, name_loc, operator_loc, value, operator, location = Location())

Create a new InstanceVariableOperatorWriteNode node 
def InstanceVariableOperatorWriteNode(name, name_loc, operator_loc, value, operator, location = Location())
  InstanceVariableOperatorWriteNode.new(name, name_loc, operator_loc, value, operator, location)
end

def InstanceVariableOrWriteNode(name, name_loc, operator_loc, value, location = Location())

Create a new InstanceVariableOrWriteNode node 
def InstanceVariableOrWriteNode(name, name_loc, operator_loc, value, location = Location())
  InstanceVariableOrWriteNode.new(name, name_loc, operator_loc, value, location)
end

def InstanceVariableReadNode(name, location = Location())

Create a new InstanceVariableReadNode node 
def InstanceVariableReadNode(name, location = Location())
  InstanceVariableReadNode.new(name, location)
end

def InstanceVariableTargetNode(name, location = Location())

Create a new InstanceVariableTargetNode node 
def InstanceVariableTargetNode(name, location = Location())
  InstanceVariableTargetNode.new(name, location)
end

def InstanceVariableWriteNode(name, name_loc, value, operator_loc, location = Location())

Create a new InstanceVariableWriteNode node 
def InstanceVariableWriteNode(name, name_loc, value, operator_loc, location = Location())
  InstanceVariableWriteNode.new(name, name_loc, value, operator_loc, location)
end

def IntegerNode(flags, location = Location())

Create a new IntegerNode node 
def IntegerNode(flags, location = Location())
  IntegerNode.new(flags, location)
end

def InterpolatedMatchLastLineNode(flags, opening_loc, parts, closing_loc, location = Location())

Create a new InterpolatedMatchLastLineNode node 
def InterpolatedMatchLastLineNode(flags, opening_loc, parts, closing_loc, location = Location())
  InterpolatedMatchLastLineNode.new(flags, opening_loc, parts, closing_loc, location)
end

def InterpolatedRegularExpressionNode(flags, opening_loc, parts, closing_loc, location = Location())

Create a new InterpolatedRegularExpressionNode node 
def InterpolatedRegularExpressionNode(flags, opening_loc, parts, closing_loc, location = Location())
  InterpolatedRegularExpressionNode.new(flags, opening_loc, parts, closing_loc, location)
end

def InterpolatedStringNode(opening_loc, parts, closing_loc, location = Location())

Create a new InterpolatedStringNode node 
def InterpolatedStringNode(opening_loc, parts, closing_loc, location = Location())
  InterpolatedStringNode.new(opening_loc, parts, closing_loc, location)
end

def InterpolatedSymbolNode(opening_loc, parts, closing_loc, location = Location())

Create a new InterpolatedSymbolNode node 
def InterpolatedSymbolNode(opening_loc, parts, closing_loc, location = Location())
  InterpolatedSymbolNode.new(opening_loc, parts, closing_loc, location)
end

def InterpolatedXStringNode(opening_loc, parts, closing_loc, location = Location())

Create a new InterpolatedXStringNode node 
def InterpolatedXStringNode(opening_loc, parts, closing_loc, location = Location())
  InterpolatedXStringNode.new(opening_loc, parts, closing_loc, location)
end

def KeywordHashNode(flags, elements, location = Location())

Create a new KeywordHashNode node 
def KeywordHashNode(flags, elements, location = Location())
  KeywordHashNode.new(flags, elements, location)
end

def KeywordRestParameterNode(flags, name, name_loc, operator_loc, location = Location())

Create a new KeywordRestParameterNode node 
def KeywordRestParameterNode(flags, name, name_loc, operator_loc, location = Location())
  KeywordRestParameterNode.new(flags, name, name_loc, operator_loc, location)
end

def LambdaNode(locals, operator_loc, opening_loc, closing_loc, parameters, body, location = Location())

Create a new LambdaNode node 
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

def LocalVariableAndWriteNode(name_loc, operator_loc, value, name, depth, location = Location())

Create a new LocalVariableAndWriteNode node 
def LocalVariableAndWriteNode(name_loc, operator_loc, value, name, depth, location = Location())
  LocalVariableAndWriteNode.new(name_loc, operator_loc, value, name, depth, location)
end

def LocalVariableOperatorWriteNode(name_loc, operator_loc, value, name, operator, depth, location = Location())

Create a new LocalVariableOperatorWriteNode node 
def LocalVariableOperatorWriteNode(name_loc, operator_loc, value, name, operator, depth, location = Location())
  LocalVariableOperatorWriteNode.new(name_loc, operator_loc, value, name, operator, depth, location)
end

def LocalVariableOrWriteNode(name_loc, operator_loc, value, name, depth, location = Location())

Create a new LocalVariableOrWriteNode node 
def LocalVariableOrWriteNode(name_loc, operator_loc, value, name, depth, location = Location())
  LocalVariableOrWriteNode.new(name_loc, operator_loc, value, name, depth, location)
end

def LocalVariableReadNode(name, depth, location = Location())

Create a new LocalVariableReadNode node 
def LocalVariableReadNode(name, depth, location = Location())
  LocalVariableReadNode.new(name, depth, location)
end

def LocalVariableTargetNode(name, depth, location = Location())

Create a new LocalVariableTargetNode node 
def LocalVariableTargetNode(name, depth, location = Location())
  LocalVariableTargetNode.new(name, depth, location)
end

def LocalVariableWriteNode(name, depth, name_loc, value, operator_loc, location = Location())

Create a new LocalVariableWriteNode node 
def LocalVariableWriteNode(name, depth, name_loc, value, operator_loc, location = Location())
  LocalVariableWriteNode.new(name, depth, name_loc, value, operator_loc, location)
end

def Location(source = nil, start_offset = 0, length = 0)

Create a new Location object 
def Location(source = nil, start_offset = 0, length = 0)
  Location.new(source, start_offset, length)
end

def MatchLastLineNode(flags, opening_loc, content_loc, closing_loc, unescaped, location = Location())

Create a new MatchLastLineNode node 
def MatchLastLineNode(flags, opening_loc, content_loc, closing_loc, unescaped, location = Location())
  MatchLastLineNode.new(flags, opening_loc, content_loc, closing_loc, unescaped, location)
end

def MatchPredicateNode(value, pattern, operator_loc, location = Location())

Create a new MatchPredicateNode node 
def MatchPredicateNode(value, pattern, operator_loc, location = Location())
  MatchPredicateNode.new(value, pattern, operator_loc, location)
end

def MatchRequiredNode(value, pattern, operator_loc, location = Location())

Create a new MatchRequiredNode node 
def MatchRequiredNode(value, pattern, operator_loc, location = Location())
  MatchRequiredNode.new(value, pattern, operator_loc, location)
end

def MatchWriteNode(call, targets, location = Location())

Create a new MatchWriteNode node 
def MatchWriteNode(call, targets, location = Location())
  MatchWriteNode.new(call, targets, location)
end

def MissingNode(location = Location())

Create a new MissingNode node 
def MissingNode(location = Location())
  MissingNode.new(location)
end

def ModuleNode(locals, module_keyword_loc, constant_path, body, end_keyword_loc, name, location = Location())

Create a new ModuleNode node 
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

def MultiTargetNode(lefts, rest, rights, lparen_loc, rparen_loc, location = Location())

Create a new MultiTargetNode node 
def MultiTargetNode(lefts, rest, rights, lparen_loc, rparen_loc, location = Location())
  MultiTargetNode.new(lefts, rest, rights, lparen_loc, rparen_loc, location)
end

def MultiWriteNode(lefts, rest, rights, lparen_loc, rparen_loc, operator_loc, value, location = Location())

Create a new MultiWriteNode node 
def MultiWriteNode(lefts, rest, rights, lparen_loc, rparen_loc, operator_loc, value, location = Location())
  MultiWriteNode.new(lefts, rest, rights, lparen_loc, rparen_loc, operator_loc, value, location)
end

def NextNode(arguments, keyword_loc, location = Location())

Create a new NextNode node 
def NextNode(arguments, keyword_loc, location = Location())
  NextNode.new(arguments, keyword_loc, location)
end

def NilNode(location = Location())

Create a new NilNode node 
def NilNode(location = Location())
  NilNode.new(location)
end

def NoKeywordsParameterNode(operator_loc, keyword_loc, location = Location())

Create a new NoKeywordsParameterNode node 
def NoKeywordsParameterNode(operator_loc, keyword_loc, location = Location())
  NoKeywordsParameterNode.new(operator_loc, keyword_loc, location)
end

def NumberedParametersNode(maximum, location = Location())

Create a new NumberedParametersNode node 
def NumberedParametersNode(maximum, location = Location())
  NumberedParametersNode.new(maximum, location)
end

def NumberedReferenceReadNode(number, location = Location())

Create a new NumberedReferenceReadNode node 
def NumberedReferenceReadNode(number, location = Location())
  NumberedReferenceReadNode.new(number, location)
end

def OptionalKeywordParameterNode(flags, name, name_loc, value, location = Location())

Create a new OptionalKeywordParameterNode node 
def OptionalKeywordParameterNode(flags, name, name_loc, value, location = Location())
  OptionalKeywordParameterNode.new(flags, name, name_loc, value, location)
end

def OptionalParameterNode(flags, name, name_loc, operator_loc, value, location = Location())

Create a new OptionalParameterNode node 
def OptionalParameterNode(flags, name, name_loc, operator_loc, value, location = Location())
  OptionalParameterNode.new(flags, name, name_loc, operator_loc, value, location)
end

def OrNode(left, right, operator_loc, location = Location())

Create a new OrNode node 
def OrNode(left, right, operator_loc, location = Location())
  OrNode.new(left, right, operator_loc, location)
end

def ParametersNode(requireds, optionals, rest, posts, keywords, keyword_rest, block, location = Location())

Create a new ParametersNode node 
def ParametersNode(requireds, optionals, rest, posts, keywords, keyword_rest, block, location = Location())
  ParametersNode.new(requireds, optionals, rest, posts, keywords, keyword_rest, block, location)
end

def ParenthesesNode(body, opening_loc, closing_loc, location = Location())

Create a new ParenthesesNode node 
def ParenthesesNode(body, opening_loc, closing_loc, location = Location())
  ParenthesesNode.new(body, opening_loc, closing_loc, location)
end

def PinnedExpressionNode(expression, operator_loc, lparen_loc, rparen_loc, location = Location())

Create a new PinnedExpressionNode node 
def PinnedExpressionNode(expression, operator_loc, lparen_loc, rparen_loc, location = Location())
  PinnedExpressionNode.new(expression, operator_loc, lparen_loc, rparen_loc, location)
end

def PinnedVariableNode(variable, operator_loc, location = Location())

Create a new PinnedVariableNode node 
def PinnedVariableNode(variable, operator_loc, location = Location())
  PinnedVariableNode.new(variable, operator_loc, location)
end

def PostExecutionNode(statements, keyword_loc, opening_loc, closing_loc, location = Location())

Create a new PostExecutionNode node 
def PostExecutionNode(statements, keyword_loc, opening_loc, closing_loc, location = Location())
  PostExecutionNode.new(statements, keyword_loc, opening_loc, closing_loc, location)
end

def PreExecutionNode(statements, keyword_loc, opening_loc, closing_loc, location = Location())

Create a new PreExecutionNode node 
def PreExecutionNode(statements, keyword_loc, opening_loc, closing_loc, location = Location())
  PreExecutionNode.new(statements, keyword_loc, opening_loc, closing_loc, location)
end

def ProgramNode(locals, statements, location = Location())

Create a new ProgramNode node 
def ProgramNode(locals, statements, location = Location())
  ProgramNode.new(locals, statements, location)
end

def RangeNode(flags, left, right, operator_loc, location = Location())

Create a new RangeNode node 
def RangeNode(flags, left, right, operator_loc, location = Location())
  RangeNode.new(flags, left, right, operator_loc, location)
end

def RationalNode(numeric, location = Location())

Create a new RationalNode node 
def RationalNode(numeric, location = Location())
  RationalNode.new(numeric, location)
end

def RedoNode(location = Location())

Create a new RedoNode node 
def RedoNode(location = Location())
  RedoNode.new(location)
end

def RegularExpressionNode(flags, opening_loc, content_loc, closing_loc, unescaped, location = Location())

Create a new RegularExpressionNode node 
def RegularExpressionNode(flags, opening_loc, content_loc, closing_loc, unescaped, location = Location())
  RegularExpressionNode.new(flags, opening_loc, content_loc, closing_loc, unescaped, location)
end

def RequiredKeywordParameterNode(flags, name, name_loc, location = Location())

Create a new RequiredKeywordParameterNode node 
def RequiredKeywordParameterNode(flags, name, name_loc, location = Location())
  RequiredKeywordParameterNode.new(flags, name, name_loc, location)
end

def RequiredParameterNode(flags, name, location = Location())

Create a new RequiredParameterNode node 
def RequiredParameterNode(flags, name, location = Location())
  RequiredParameterNode.new(flags, name, location)
end

def RescueModifierNode(expression, keyword_loc, rescue_expression, location = Location())

Create a new RescueModifierNode node 
def RescueModifierNode(expression, keyword_loc, rescue_expression, location = Location())
  RescueModifierNode.new(expression, keyword_loc, rescue_expression, location)
end

def RescueNode(keyword_loc, exceptions, operator_loc, reference, statements, consequent, location = Location())

Create a new RescueNode node 
def RescueNode(keyword_loc, exceptions, operator_loc, reference, statements, consequent, location = Location())
  RescueNode.new(keyword_loc, exceptions, operator_loc, reference, statements, consequent, location)
end

def RestParameterNode(flags, name, name_loc, operator_loc, location = Location())

Create a new RestParameterNode node 
def RestParameterNode(flags, name, name_loc, operator_loc, location = Location())
  RestParameterNode.new(flags, name, name_loc, operator_loc, location)
end

def RetryNode(location = Location())

Create a new RetryNode node 
def RetryNode(location = Location())
  RetryNode.new(location)
end

def ReturnNode(keyword_loc, arguments, location = Location())

Create a new ReturnNode node 
def ReturnNode(keyword_loc, arguments, location = Location())
  ReturnNode.new(keyword_loc, arguments, location)
end

def SelfNode(location = Location())

Create a new SelfNode node 
def SelfNode(location = Location())
  SelfNode.new(location)
end

def SingletonClassNode(locals, class_keyword_loc, operator_loc, expression, body, end_keyword_loc, location = Location())

Create a new SingletonClassNode node 
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

def SourceEncodingNode(location = Location())

Create a new SourceEncodingNode node 
def SourceEncodingNode(location = Location())
  SourceEncodingNode.new(location)
end

def SourceFileNode(filepath, location = Location())

Create a new SourceFileNode node 
def SourceFileNode(filepath, location = Location())
  SourceFileNode.new(filepath, location)
end

def SourceLineNode(location = Location())

Create a new SourceLineNode node 
def SourceLineNode(location = Location())
  SourceLineNode.new(location)
end

def SplatNode(operator_loc, expression, location = Location())

Create a new SplatNode node 
def SplatNode(operator_loc, expression, location = Location())
  SplatNode.new(operator_loc, expression, location)
end

def StatementsNode(body, location = Location())

Create a new StatementsNode node 
def StatementsNode(body, location = Location())
  StatementsNode.new(body, location)
end

def StringNode(flags, opening_loc, content_loc, closing_loc, unescaped, location = Location())

Create a new StringNode node 
def StringNode(flags, opening_loc, content_loc, closing_loc, unescaped, location = Location())
  StringNode.new(flags, opening_loc, content_loc, closing_loc, unescaped, location)
end

def SuperNode(keyword_loc, lparen_loc, arguments, rparen_loc, block, location = Location())

Create a new SuperNode node 
def SuperNode(keyword_loc, lparen_loc, arguments, rparen_loc, block, location = Location())
  SuperNode.new(keyword_loc, lparen_loc, arguments, rparen_loc, block, location)
end

def SymbolNode(flags, opening_loc, value_loc, closing_loc, unescaped, location = Location())

Create a new SymbolNode node 
def SymbolNode(flags, opening_loc, value_loc, closing_loc, unescaped, location = Location())
  SymbolNode.new(flags, opening_loc, value_loc, closing_loc, unescaped, location)
end

def TrueNode(location = Location())

Create a new TrueNode node 
def TrueNode(location = Location())
  TrueNode.new(location)
end

def UndefNode(names, keyword_loc, location = Location())

Create a new UndefNode node 
def UndefNode(names, keyword_loc, location = Location())
  UndefNode.new(names, keyword_loc, location)
end

def UnlessNode(keyword_loc, predicate, then_keyword_loc, statements, consequent, end_keyword_loc, location = Location())

Create a new UnlessNode node 
def UnlessNode(keyword_loc, predicate, then_keyword_loc, statements, consequent, end_keyword_loc, location = Location())
  UnlessNode.new(keyword_loc, predicate, then_keyword_loc, statements, consequent, end_keyword_loc, location)
end

def UntilNode(flags, keyword_loc, closing_loc, predicate, statements, location = Location())

Create a new UntilNode node 
def UntilNode(flags, keyword_loc, closing_loc, predicate, statements, location = Location())
  UntilNode.new(flags, keyword_loc, closing_loc, predicate, statements, location)
end

def WhenNode(keyword_loc, conditions, statements, location = Location())

Create a new WhenNode node 
def WhenNode(keyword_loc, conditions, statements, location = Location())
  WhenNode.new(keyword_loc, conditions, statements, location)
end

def WhileNode(flags, keyword_loc, closing_loc, predicate, statements, location = Location())

Create a new WhileNode node 
def WhileNode(flags, keyword_loc, closing_loc, predicate, statements, location = Location())
  WhileNode.new(flags, keyword_loc, closing_loc, predicate, statements, location)
end

def XStringNode(flags, opening_loc, content_loc, closing_loc, unescaped, location = Location())

Create a new XStringNode node 
def XStringNode(flags, opening_loc, content_loc, closing_loc, unescaped, location = Location())
  XStringNode.new(flags, opening_loc, content_loc, closing_loc, unescaped, location)
end

def YieldNode(keyword_loc, lparen_loc, arguments, rparen_loc, location = Location())

Create a new YieldNode node 
def YieldNode(keyword_loc, lparen_loc, arguments, rparen_loc, location = Location())
  YieldNode.new(keyword_loc, lparen_loc, arguments, rparen_loc, location)
end