module YARP::DSL - Documentation for Ruby 3.3

AliasGlobalVariableNode(new_name, old_name, keyword_loc, location = Location()) click to toggle source

Create a new AliasGlobalVariableNode node

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

AliasMethodNode(new_name, old_name, keyword_loc, location = Location()) click to toggle source

Create a new AliasMethodNode node

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

AlternationPatternNode(left, right, operator_loc, location = Location()) click to toggle source

Create a new AlternationPatternNode node

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

AndNode(left, right, operator_loc, location = Location()) click to toggle source

Create a new AndNode node

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

ArgumentsNode(arguments, location = Location()) click to toggle source

Create a new ArgumentsNode node

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

ArrayNode(elements, opening_loc, closing_loc, location = Location()) click to toggle source

Create a new ArrayNode node

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

ArrayPatternNode(constant, requireds, rest, posts, opening_loc, closing_loc, location = Location()) click to toggle source

Create a new ArrayPatternNode node

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

AssocNode(key, value, operator_loc, location = Location()) click to toggle source

Create a new AssocNode node

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

AssocSplatNode(value, operator_loc, location = Location()) click to toggle source

Create a new AssocSplatNode node

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

BackReferenceReadNode(location = Location()) click to toggle source

Create a new BackReferenceReadNode node

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

BeginNode(begin_keyword_loc, statements, rescue_clause, else_clause, ensure_clause, end_keyword_loc, location = Location()) click to toggle source

Create a new BeginNode node

# File lib/yarp/node.rb, line 14075
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

BlockArgumentNode(expression, operator_loc, location = Location()) click to toggle source

Create a new BlockArgumentNode node

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

BlockLocalVariableNode(name, location = Location()) click to toggle source

Create a new BlockLocalVariableNode node

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

BlockNode(locals, parameters, body, opening_loc, closing_loc, location = Location()) click to toggle source

Create a new BlockNode node

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

BlockParameterNode(name, name_loc, operator_loc, location = Location()) click to toggle source

Create a new BlockParameterNode node

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

BlockParametersNode(parameters, locals, opening_loc, closing_loc, location = Location()) click to toggle source

Create a new BlockParametersNode node

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

BreakNode(arguments, keyword_loc, location = Location()) click to toggle source

Create a new BreakNode node

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

CallAndWriteNode(receiver, call_operator_loc, message_loc, opening_loc, arguments, closing_loc, flags, read_name, write_name, operator_loc, value, location = Location()) click to toggle source

Create a new CallAndWriteNode node

# File lib/yarp/node.rb, line 14110
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

CallNode(receiver, call_operator_loc, message_loc, opening_loc, arguments, closing_loc, block, flags, name, location = Location()) click to toggle source

Create a new CallNode node

# File lib/yarp/node.rb, line 14115
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

CallOperatorWriteNode(receiver, call_operator_loc, message_loc, opening_loc, arguments, closing_loc, flags, read_name, write_name, operator, operator_loc, value, location = Location()) click to toggle source

Create a new CallOperatorWriteNode node

# File lib/yarp/node.rb, line 14120
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

CallOrWriteNode(receiver, call_operator_loc, message_loc, opening_loc, arguments, closing_loc, flags, read_name, write_name, operator_loc, value, location = Location()) click to toggle source

Create a new CallOrWriteNode node

# File lib/yarp/node.rb, line 14125
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

CapturePatternNode(value, target, operator_loc, location = Location()) click to toggle source

Create a new CapturePatternNode node

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

CaseNode(predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, location = Location()) click to toggle source

Create a new CaseNode node

# File lib/yarp/node.rb, line 14135
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

ClassNode(locals, class_keyword_loc, constant_path, inheritance_operator_loc, superclass, body, end_keyword_loc, name, location = Location()) click to toggle source

Create a new ClassNode node

# File lib/yarp/node.rb, line 14140
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

ClassVariableAndWriteNode(name, name_loc, operator_loc, value, location = Location()) click to toggle source

Create a new ClassVariableAndWriteNode node

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

ClassVariableOperatorWriteNode(name, name_loc, operator_loc, value, operator, location = Location()) click to toggle source

Create a new ClassVariableOperatorWriteNode node

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

ClassVariableOrWriteNode(name, name_loc, operator_loc, value, location = Location()) click to toggle source

Create a new ClassVariableOrWriteNode node

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

ClassVariableReadNode(name, location = Location()) click to toggle source

Create a new ClassVariableReadNode node

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

ClassVariableTargetNode(name, location = Location()) click to toggle source

Create a new ClassVariableTargetNode node

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

ClassVariableWriteNode(name, name_loc, value, operator_loc, location = Location()) click to toggle source

Create a new ClassVariableWriteNode node

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

ConstantAndWriteNode(name, name_loc, operator_loc, value, location = Location()) click to toggle source

Create a new ConstantAndWriteNode node

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

ConstantOperatorWriteNode(name, name_loc, operator_loc, value, operator, location = Location()) click to toggle source

Create a new ConstantOperatorWriteNode node

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

ConstantOrWriteNode(name, name_loc, operator_loc, value, location = Location()) click to toggle source

Create a new ConstantOrWriteNode node

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

ConstantPathAndWriteNode(target, operator_loc, value, location = Location()) click to toggle source

Create a new ConstantPathAndWriteNode node

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

ConstantPathNode(parent, child, delimiter_loc, location = Location()) click to toggle source

Create a new ConstantPathNode node

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

ConstantPathOperatorWriteNode(target, operator_loc, value, operator, location = Location()) click to toggle source

Create a new ConstantPathOperatorWriteNode node

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

ConstantPathOrWriteNode(target, operator_loc, value, location = Location()) click to toggle source

Create a new ConstantPathOrWriteNode node

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

ConstantPathTargetNode(parent, child, delimiter_loc, location = Location()) click to toggle source

Create a new ConstantPathTargetNode node

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

ConstantPathWriteNode(target, operator_loc, value, location = Location()) click to toggle source

Create a new ConstantPathWriteNode node

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

ConstantReadNode(name, location = Location()) click to toggle source

Create a new ConstantReadNode node

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

ConstantTargetNode(name, location = Location()) click to toggle source

Create a new ConstantTargetNode node

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

ConstantWriteNode(name, name_loc, value, operator_loc, location = Location()) click to toggle source

Create a new ConstantWriteNode node

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

DefNode(name, name_loc, receiver, parameters, body, locals, def_keyword_loc, operator_loc, lparen_loc, rparen_loc, equal_loc, end_keyword_loc, location = Location()) click to toggle source

Create a new DefNode node

# File lib/yarp/node.rb, line 14235
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

DefinedNode(lparen_loc, value, rparen_loc, keyword_loc, location = Location()) click to toggle source

Create a new DefinedNode node

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

ElseNode(else_keyword_loc, statements, end_keyword_loc, location = Location()) click to toggle source

Create a new ElseNode node

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

EmbeddedStatementsNode(opening_loc, statements, closing_loc, location = Location()) click to toggle source

Create a new EmbeddedStatementsNode node

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

EmbeddedVariableNode(operator_loc, variable, location = Location()) click to toggle source

Create a new EmbeddedVariableNode node

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

EnsureNode(ensure_keyword_loc, statements, end_keyword_loc, location = Location()) click to toggle source

Create a new EnsureNode node

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

FalseNode(location = Location()) click to toggle source

Create a new FalseNode node

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

FindPatternNode(constant, left, requireds, right, opening_loc, closing_loc, location = Location()) click to toggle source

Create a new FindPatternNode node

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

FlipFlopNode(left, right, operator_loc, flags, location = Location()) click to toggle source

Create a new FlipFlopNode node

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

FloatNode(location = Location()) click to toggle source

Create a new FloatNode node

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

ForNode(index, collection, statements, for_keyword_loc, in_keyword_loc, do_keyword_loc, end_keyword_loc, location = Location()) click to toggle source

Create a new ForNode node

# File lib/yarp/node.rb, line 14285
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

ForwardingArgumentsNode(location = Location()) click to toggle source

Create a new ForwardingArgumentsNode node

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

ForwardingParameterNode(location = Location()) click to toggle source

Create a new ForwardingParameterNode node

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

ForwardingSuperNode(block, location = Location()) click to toggle source

Create a new ForwardingSuperNode node

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

GlobalVariableAndWriteNode(name, name_loc, operator_loc, value, location = Location()) click to toggle source

Create a new GlobalVariableAndWriteNode node

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

GlobalVariableOperatorWriteNode(name, name_loc, operator_loc, value, operator, location = Location()) click to toggle source

Create a new GlobalVariableOperatorWriteNode node

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

GlobalVariableOrWriteNode(name, name_loc, operator_loc, value, location = Location()) click to toggle source

Create a new GlobalVariableOrWriteNode node

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

GlobalVariableReadNode(name, location = Location()) click to toggle source

Create a new GlobalVariableReadNode node

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

GlobalVariableTargetNode(name, location = Location()) click to toggle source

Create a new GlobalVariableTargetNode node

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

GlobalVariableWriteNode(name, name_loc, value, operator_loc, location = Location()) click to toggle source

Create a new GlobalVariableWriteNode node

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

HashNode(opening_loc, elements, closing_loc, location = Location()) click to toggle source

Create a new HashNode node

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

HashPatternNode(constant, assocs, kwrest, opening_loc, closing_loc, location = Location()) click to toggle source

Create a new HashPatternNode node

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

IfNode(if_keyword_loc, predicate, statements, consequent, end_keyword_loc, location = Location()) click to toggle source

Create a new IfNode node

# File lib/yarp/node.rb, line 14345
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

ImaginaryNode(numeric, location = Location()) click to toggle source

Create a new ImaginaryNode node

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

ImplicitNode(value, location = Location()) click to toggle source

Create a new ImplicitNode node

# File lib/yarp/node.rb, line 14355
def ImplicitNode(value, location = Location())
  ImplicitNode.new(value, location)
end

InNode(pattern, statements, in_loc, then_loc, location = Location()) click to toggle source

Create a new InNode node

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

InstanceVariableAndWriteNode(name, name_loc, operator_loc, value, location = Location()) click to toggle source

Create a new InstanceVariableAndWriteNode node

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

InstanceVariableOperatorWriteNode(name, name_loc, operator_loc, value, operator, location = Location()) click to toggle source

Create a new InstanceVariableOperatorWriteNode node

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

InstanceVariableOrWriteNode(name, name_loc, operator_loc, value, location = Location()) click to toggle source

Create a new InstanceVariableOrWriteNode node

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

InstanceVariableReadNode(name, location = Location()) click to toggle source

Create a new InstanceVariableReadNode node

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

InstanceVariableTargetNode(name, location = Location()) click to toggle source

Create a new InstanceVariableTargetNode node

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

InstanceVariableWriteNode(name, name_loc, value, operator_loc, location = Location()) click to toggle source

Create a new InstanceVariableWriteNode node

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

IntegerNode(flags, location = Location()) click to toggle source

Create a new IntegerNode node

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

InterpolatedMatchLastLineNode(opening_loc, parts, closing_loc, flags, location = Location()) click to toggle source

Create a new InterpolatedMatchLastLineNode node

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

InterpolatedRegularExpressionNode(opening_loc, parts, closing_loc, flags, location = Location()) click to toggle source

Create a new InterpolatedRegularExpressionNode node

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

InterpolatedStringNode(opening_loc, parts, closing_loc, location = Location()) click to toggle source

Create a new InterpolatedStringNode node

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

InterpolatedSymbolNode(opening_loc, parts, closing_loc, location = Location()) click to toggle source

Create a new InterpolatedSymbolNode node

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

InterpolatedXStringNode(opening_loc, parts, closing_loc, location = Location()) click to toggle source

Create a new InterpolatedXStringNode node

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

KeywordHashNode(elements, location = Location()) click to toggle source

Create a new KeywordHashNode node

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

KeywordParameterNode(name, name_loc, value, location = Location()) click to toggle source

Create a new KeywordParameterNode node

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

KeywordRestParameterNode(name, name_loc, operator_loc, location = Location()) click to toggle source

Create a new KeywordRestParameterNode node

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

LambdaNode(locals, operator_loc, opening_loc, closing_loc, parameters, body, location = Location()) click to toggle source

Create a new LambdaNode node

# File lib/yarp/node.rb, line 14440
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

LocalVariableAndWriteNode(name_loc, operator_loc, value, name, depth, location = Location()) click to toggle source

Create a new LocalVariableAndWriteNode node

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

LocalVariableOperatorWriteNode(name_loc, operator_loc, value, name, operator, depth, location = Location()) click to toggle source

Create a new LocalVariableOperatorWriteNode node

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

LocalVariableOrWriteNode(name_loc, operator_loc, value, name, depth, location = Location()) click to toggle source

Create a new LocalVariableOrWriteNode node

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

LocalVariableReadNode(name, depth, location = Location()) click to toggle source

Create a new LocalVariableReadNode node

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

LocalVariableTargetNode(name, depth, location = Location()) click to toggle source

Create a new LocalVariableTargetNode node

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

LocalVariableWriteNode(name, depth, name_loc, value, operator_loc, location = Location()) click to toggle source

Create a new LocalVariableWriteNode node

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

Location(source = nil, start_offset = 0, length = 0) click to toggle source

Create a new Location object

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

MatchLastLineNode(opening_loc, content_loc, closing_loc, unescaped, flags, location = Location()) click to toggle source

Create a new MatchLastLineNode node

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

MatchPredicateNode(value, pattern, operator_loc, location = Location()) click to toggle source

Create a new MatchPredicateNode node

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

MatchRequiredNode(value, pattern, operator_loc, location = Location()) click to toggle source

Create a new MatchRequiredNode node

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

MatchWriteNode(call, locals, location = Location()) click to toggle source

Create a new MatchWriteNode node

# File lib/yarp/node.rb, line 14490
def MatchWriteNode(call, locals, location = Location())
  MatchWriteNode.new(call, locals, location)
end

MissingNode(location = Location()) click to toggle source

Create a new MissingNode node

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

ModuleNode(locals, module_keyword_loc, constant_path, body, end_keyword_loc, name, location = Location()) click to toggle source

Create a new ModuleNode node

# File lib/yarp/node.rb, line 14500
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

MultiTargetNode(targets, lparen_loc, rparen_loc, location = Location()) click to toggle source

Create a new MultiTargetNode node

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

MultiWriteNode(targets, lparen_loc, rparen_loc, operator_loc, value, location = Location()) click to toggle source

Create a new MultiWriteNode node

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

NextNode(arguments, keyword_loc, location = Location()) click to toggle source

Create a new NextNode node

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

NilNode(location = Location()) click to toggle source

Create a new NilNode node

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

NoKeywordsParameterNode(operator_loc, keyword_loc, location = Location()) click to toggle source

Create a new NoKeywordsParameterNode node

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

NumberedReferenceReadNode(number, location = Location()) click to toggle source

Create a new NumberedReferenceReadNode node

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

OptionalParameterNode(name, name_loc, operator_loc, value, location = Location()) click to toggle source

Create a new OptionalParameterNode node

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

OrNode(left, right, operator_loc, location = Location()) click to toggle source

Create a new OrNode node

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

ParametersNode(requireds, optionals, rest, posts, keywords, keyword_rest, block, location = Location()) click to toggle source

Create a new ParametersNode node

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

ParenthesesNode(body, opening_loc, closing_loc, location = Location()) click to toggle source

Create a new ParenthesesNode node

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

PinnedExpressionNode(expression, operator_loc, lparen_loc, rparen_loc, location = Location()) click to toggle source

Create a new PinnedExpressionNode node

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

PinnedVariableNode(variable, operator_loc, location = Location()) click to toggle source

Create a new PinnedVariableNode node

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

PostExecutionNode(statements, keyword_loc, opening_loc, closing_loc, location = Location()) click to toggle source

Create a new PostExecutionNode node

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

PreExecutionNode(statements, keyword_loc, opening_loc, closing_loc, location = Location()) click to toggle source

Create a new PreExecutionNode node

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

ProgramNode(locals, statements, location = Location()) click to toggle source

Create a new ProgramNode node

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

RangeNode(left, right, operator_loc, flags, location = Location()) click to toggle source

Create a new RangeNode node

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

RationalNode(numeric, location = Location()) click to toggle source

Create a new RationalNode node

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

RedoNode(location = Location()) click to toggle source

Create a new RedoNode node

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

RegularExpressionNode(opening_loc, content_loc, closing_loc, unescaped, flags, location = Location()) click to toggle source

Create a new RegularExpressionNode node

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

RequiredDestructuredParameterNode(parameters, opening_loc, closing_loc, location = Location()) click to toggle source

Create a new RequiredDestructuredParameterNode node

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

RequiredParameterNode(name, location = Location()) click to toggle source

Create a new RequiredParameterNode node

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

RescueModifierNode(expression, keyword_loc, rescue_expression, location = Location()) click to toggle source

Create a new RescueModifierNode node

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

RescueNode(keyword_loc, exceptions, operator_loc, reference, statements, consequent, location = Location()) click to toggle source

Create a new RescueNode node

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

RestParameterNode(name, name_loc, operator_loc, location = Location()) click to toggle source

Create a new RestParameterNode node

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

RetryNode(location = Location()) click to toggle source

Create a new RetryNode node

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

ReturnNode(keyword_loc, arguments, location = Location()) click to toggle source

Create a new ReturnNode node

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

SelfNode(location = Location()) click to toggle source

Create a new SelfNode node

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

SingletonClassNode(locals, class_keyword_loc, operator_loc, expression, body, end_keyword_loc, location = Location()) click to toggle source

Create a new SingletonClassNode node

# File lib/yarp/node.rb, line 14640
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

SourceEncodingNode(location = Location()) click to toggle source

Create a new SourceEncodingNode node

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

SourceFileNode(filepath, location = Location()) click to toggle source

Create a new SourceFileNode node

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

SourceLineNode(location = Location()) click to toggle source

Create a new SourceLineNode node

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

SplatNode(operator_loc, expression, location = Location()) click to toggle source

Create a new SplatNode node

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

StatementsNode(body, location = Location()) click to toggle source

Create a new StatementsNode node

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

StringConcatNode(left, right, location = Location()) click to toggle source

Create a new StringConcatNode node

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

StringNode(flags, opening_loc, content_loc, closing_loc, unescaped, location = Location()) click to toggle source

Create a new StringNode node

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

SuperNode(keyword_loc, lparen_loc, arguments, rparen_loc, block, location = Location()) click to toggle source

Create a new SuperNode node

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

SymbolNode(opening_loc, value_loc, closing_loc, unescaped, location = Location()) click to toggle source

Create a new SymbolNode node

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

TrueNode(location = Location()) click to toggle source

Create a new TrueNode node

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

UndefNode(names, keyword_loc, location = Location()) click to toggle source

Create a new UndefNode node

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

UnlessNode(keyword_loc, predicate, statements, consequent, end_keyword_loc, location = Location()) click to toggle source

Create a new UnlessNode node

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

UntilNode(keyword_loc, closing_loc, predicate, statements, flags, location = Location()) click to toggle source

Create a new UntilNode node

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

WhenNode(keyword_loc, conditions, statements, location = Location()) click to toggle source

Create a new WhenNode node

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

WhileNode(keyword_loc, closing_loc, predicate, statements, flags, location = Location()) click to toggle source

Create a new WhileNode node

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

XStringNode(opening_loc, content_loc, closing_loc, unescaped, location = Location()) click to toggle source

Create a new XStringNode node

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

YieldNode(keyword_loc, lparen_loc, arguments, rparen_loc, location = Location()) click to toggle source

Create a new YieldNode node

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