module Prism::DSL - Documentation for Ruby 3.3

# module Prism::DSL

The `DSL` module provides a set of methods that can be used to create prism nodes in a more concise manner. For example, instead of writing:

    source = Prism::Source.new("[1]")

    Prism::ArrayNode.new(
      [
        Prism::IntegerNode.new(
          Prism::IntegerBaseFlags::DECIMAL,
          Prism::Location.new(source, 1, 1),
        )
      ],
      Prism::Location.new(source, 0, 1),
      Prism::Location.new(source, 2, 1)
    )

you could instead write:

    source = Prism::Source.new("[1]")

    ArrayNode(
      IntegerNode(Prism::IntegerBaseFlags::DECIMAL, Location(source, 1, 1))),
      Location(source, 0, 1),
      Location(source, 2, 1)
    )

This is mostly helpful in the context of writing tests, but can also be used to generate trees programmatically.

### Private Instance Methods

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

Create a new `AliasGlobalVariableNode` node

    # File lib/prism/dsl.rb, line 46
    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/prism/dsl.rb, line 51
    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/prism/dsl.rb, line 56
    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/prism/dsl.rb, line 61
    def AndNode(left, right, operator_loc, location = Location())
      AndNode.new(left, right, operator_loc, location)
    end

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

Create a new `ArgumentsNode` node

    # File lib/prism/dsl.rb, line 66
    def ArgumentsNode(flags, arguments, location = Location())
      ArgumentsNode.new(flags, arguments, location)
    end

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

Create a new `ArrayNode` node

    # File lib/prism/dsl.rb, line 71
    def ArrayNode(flags, elements, opening_loc, closing_loc, location = Location())
      ArrayNode.new(flags, 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/prism/dsl.rb, line 76
    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/prism/dsl.rb, line 81
    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/prism/dsl.rb, line 86
    def AssocSplatNode(value, operator_loc, location = Location())
      AssocSplatNode.new(value, operator_loc, location)
    end

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

Create a new `BackReferenceReadNode` node

    # File lib/prism/dsl.rb, line 91
    def BackReferenceReadNode(name, location = Location())
      BackReferenceReadNode.new(name, 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/prism/dsl.rb, line 96
    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/prism/dsl.rb, line 101
    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/prism/dsl.rb, line 106
    def BlockLocalVariableNode(name, location = Location())
      BlockLocalVariableNode.new(name, location)
    end

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

Create a new `BlockNode` node

    # File lib/prism/dsl.rb, line 111
    def BlockNode(locals, locals_body_index, parameters, body, opening_loc, closing_loc, location = Location())
      BlockNode.new(locals, locals_body_index, 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/prism/dsl.rb, line 116
    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/prism/dsl.rb, line 121
    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/prism/dsl.rb, line 126
    def BreakNode(arguments, keyword_loc, location = Location())
      BreakNode.new(arguments, keyword_loc, location)
    end

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

Create a new `CallAndWriteNode` node

    # File lib/prism/dsl.rb, line 131
    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

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

Create a new `CallNode` node

    # File lib/prism/dsl.rb, line 136
    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

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

Create a new `CallOperatorWriteNode` node

    # File lib/prism/dsl.rb, line 141
    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

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

Create a new `CallOrWriteNode` node

    # File lib/prism/dsl.rb, line 146
    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

CallTargetNode(flags, receiver, call_operator_loc, name, message_loc, location = Location()) click to toggle source

Create a new `CallTargetNode` node

    # File lib/prism/dsl.rb, line 151
    def CallTargetNode(flags, receiver, call_operator_loc, name, message_loc, location = Location())
      CallTargetNode.new(flags, receiver, call_operator_loc, name, message_loc, location)
    end

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

Create a new `CapturePatternNode` node

    # File lib/prism/dsl.rb, line 156
    def CapturePatternNode(value, target, operator_loc, location = Location())
      CapturePatternNode.new(value, target, operator_loc, location)
    end

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

Create a new `CaseMatchNode` node

    # File lib/prism/dsl.rb, line 161
    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

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

Create a new `CaseNode` node

    # File lib/prism/dsl.rb, line 166
    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/prism/dsl.rb, line 171
    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/prism/dsl.rb, line 176
    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/prism/dsl.rb, line 181
    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/prism/dsl.rb, line 186
    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/prism/dsl.rb, line 191
    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/prism/dsl.rb, line 196
    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/prism/dsl.rb, line 201
    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/prism/dsl.rb, line 206
    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/prism/dsl.rb, line 211
    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/prism/dsl.rb, line 216
    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/prism/dsl.rb, line 221
    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/prism/dsl.rb, line 226
    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/prism/dsl.rb, line 231
    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/prism/dsl.rb, line 236
    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/prism/dsl.rb, line 241
    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/prism/dsl.rb, line 246
    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/prism/dsl.rb, line 251
    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/prism/dsl.rb, line 256
    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/prism/dsl.rb, line 261
    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, locals_body_index, 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/prism/dsl.rb, line 266
    def DefNode(name, name_loc, receiver, parameters, body, locals, locals_body_index, 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, locals_body_index, 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/prism/dsl.rb, line 271
    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/prism/dsl.rb, line 276
    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/prism/dsl.rb, line 281
    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/prism/dsl.rb, line 286
    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/prism/dsl.rb, line 291
    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/prism/dsl.rb, line 296
    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/prism/dsl.rb, line 301
    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(flags, left, right, operator_loc, location = Location()) click to toggle source

Create a new `FlipFlopNode` node

    # File lib/prism/dsl.rb, line 306
    def FlipFlopNode(flags, left, right, operator_loc, location = Location())
      FlipFlopNode.new(flags, left, right, operator_loc, location)
    end

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

Create a new `FloatNode` node

    # File lib/prism/dsl.rb, line 311
    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/prism/dsl.rb, line 316
    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/prism/dsl.rb, line 321
    def ForwardingArgumentsNode(location = Location())
      ForwardingArgumentsNode.new(location)
    end

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

Create a new `ForwardingParameterNode` node

    # File lib/prism/dsl.rb, line 326
    def ForwardingParameterNode(location = Location())
      ForwardingParameterNode.new(location)
    end

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

Create a new `ForwardingSuperNode` node

    # File lib/prism/dsl.rb, line 331
    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/prism/dsl.rb, line 336
    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/prism/dsl.rb, line 341
    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/prism/dsl.rb, line 346
    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/prism/dsl.rb, line 351
    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/prism/dsl.rb, line 356
    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/prism/dsl.rb, line 361
    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/prism/dsl.rb, line 366
    def HashNode(opening_loc, elements, closing_loc, location = Location())
      HashNode.new(opening_loc, elements, closing_loc, location)
    end

HashPatternNode(constant, elements, rest, opening_loc, closing_loc, location = Location()) click to toggle source

Create a new `HashPatternNode` node

    # File lib/prism/dsl.rb, line 371
    def HashPatternNode(constant, elements, rest, opening_loc, closing_loc, location = Location())
      HashPatternNode.new(constant, elements, rest, opening_loc, closing_loc, location)
    end

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

Create a new `IfNode` node

    # File lib/prism/dsl.rb, line 376
    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

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

Create a new `ImaginaryNode` node

    # File lib/prism/dsl.rb, line 381
    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/prism/dsl.rb, line 386
    def ImplicitNode(value, location = Location())
      ImplicitNode.new(value, location)
    end

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

Create a new `ImplicitRestNode` node

    # File lib/prism/dsl.rb, line 391
    def ImplicitRestNode(location = Location())
      ImplicitRestNode.new(location)
    end

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

Create a new `InNode` node

    # File lib/prism/dsl.rb, line 396
    def InNode(pattern, statements, in_loc, then_loc, location = Location())
      InNode.new(pattern, statements, in_loc, then_loc, location)
    end

IndexAndWriteNode(flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator_loc, value, location = Location()) click to toggle source

Create a new `IndexAndWriteNode` node

    # File lib/prism/dsl.rb, line 401
    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

IndexOperatorWriteNode(flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator, operator_loc, value, location = Location()) click to toggle source

Create a new `IndexOperatorWriteNode` node

    # File lib/prism/dsl.rb, line 406
    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

IndexOrWriteNode(flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator_loc, value, location = Location()) click to toggle source

Create a new `IndexOrWriteNode` node

    # File lib/prism/dsl.rb, line 411
    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

IndexTargetNode(flags, receiver, opening_loc, arguments, closing_loc, block, location = Location()) click to toggle source

Create a new `IndexTargetNode` node

    # File lib/prism/dsl.rb, line 416
    def IndexTargetNode(flags, receiver, opening_loc, arguments, closing_loc, block, location = Location())
      IndexTargetNode.new(flags, receiver, opening_loc, arguments, closing_loc, block, location)
    end

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

Create a new `InstanceVariableAndWriteNode` node

    # File lib/prism/dsl.rb, line 421
    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/prism/dsl.rb, line 426
    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/prism/dsl.rb, line 431
    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/prism/dsl.rb, line 436
    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/prism/dsl.rb, line 441
    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/prism/dsl.rb, line 446
    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/prism/dsl.rb, line 451
    def IntegerNode(flags, location = Location())
      IntegerNode.new(flags, location)
    end

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

Create a new `InterpolatedMatchLastLineNode` node

    # File lib/prism/dsl.rb, line 456
    def InterpolatedMatchLastLineNode(flags, opening_loc, parts, closing_loc, location = Location())
      InterpolatedMatchLastLineNode.new(flags, opening_loc, parts, closing_loc, location)
    end

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

Create a new `InterpolatedRegularExpressionNode` node

    # File lib/prism/dsl.rb, line 461
    def InterpolatedRegularExpressionNode(flags, opening_loc, parts, closing_loc, location = Location())
      InterpolatedRegularExpressionNode.new(flags, opening_loc, parts, closing_loc, location)
    end

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

Create a new `InterpolatedStringNode` node

    # File lib/prism/dsl.rb, line 466
    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/prism/dsl.rb, line 471
    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/prism/dsl.rb, line 476
    def InterpolatedXStringNode(opening_loc, parts, closing_loc, location = Location())
      InterpolatedXStringNode.new(opening_loc, parts, closing_loc, location)
    end

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

Create a new `KeywordHashNode` node

    # File lib/prism/dsl.rb, line 481
    def KeywordHashNode(flags, elements, location = Location())
      KeywordHashNode.new(flags, elements, location)
    end

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

Create a new `KeywordRestParameterNode` node

    # File lib/prism/dsl.rb, line 486
    def KeywordRestParameterNode(name, name_loc, operator_loc, location = Location())
      KeywordRestParameterNode.new(name, name_loc, operator_loc, location)
    end

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

Create a new `LambdaNode` node

    # File lib/prism/dsl.rb, line 491
    def LambdaNode(locals, locals_body_index, operator_loc, opening_loc, closing_loc, parameters, body, location = Location())
      LambdaNode.new(locals, locals_body_index, 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/prism/dsl.rb, line 496
    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/prism/dsl.rb, line 501
    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/prism/dsl.rb, line 506
    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/prism/dsl.rb, line 511
    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/prism/dsl.rb, line 516
    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/prism/dsl.rb, line 521
    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/prism/dsl.rb, line 41
    def Location(source = nil, start_offset = 0, length = 0)
      Location.new(source, start_offset, length)
    end

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

Create a new `MatchLastLineNode` node

    # File lib/prism/dsl.rb, line 526
    def MatchLastLineNode(flags, opening_loc, content_loc, closing_loc, unescaped, location = Location())
      MatchLastLineNode.new(flags, opening_loc, content_loc, closing_loc, unescaped, location)
    end

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

Create a new `MatchPredicateNode` node

    # File lib/prism/dsl.rb, line 531
    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/prism/dsl.rb, line 536
    def MatchRequiredNode(value, pattern, operator_loc, location = Location())
      MatchRequiredNode.new(value, pattern, operator_loc, location)
    end

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

Create a new `MatchWriteNode` node

    # File lib/prism/dsl.rb, line 541
    def MatchWriteNode(call, targets, location = Location())
      MatchWriteNode.new(call, targets, location)
    end

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

Create a new `MissingNode` node

    # File lib/prism/dsl.rb, line 546
    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/prism/dsl.rb, line 551
    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(lefts, rest, rights, lparen_loc, rparen_loc, location = Location()) click to toggle source

Create a new `MultiTargetNode` node

    # File lib/prism/dsl.rb, line 556
    def MultiTargetNode(lefts, rest, rights, lparen_loc, rparen_loc, location = Location())
      MultiTargetNode.new(lefts, rest, rights, lparen_loc, rparen_loc, location)
    end

MultiWriteNode(lefts, rest, rights, lparen_loc, rparen_loc, operator_loc, value, location = Location()) click to toggle source

Create a new `MultiWriteNode` node

    # File lib/prism/dsl.rb, line 561
    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

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

Create a new `NextNode` node

    # File lib/prism/dsl.rb, line 566
    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/prism/dsl.rb, line 571
    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/prism/dsl.rb, line 576
    def NoKeywordsParameterNode(operator_loc, keyword_loc, location = Location())
      NoKeywordsParameterNode.new(operator_loc, keyword_loc, location)
    end

NumberedParametersNode(maximum, location = Location()) click to toggle source

Create a new `NumberedParametersNode` node

    # File lib/prism/dsl.rb, line 581
    def NumberedParametersNode(maximum, location = Location())
      NumberedParametersNode.new(maximum, location)
    end

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

Create a new `NumberedReferenceReadNode` node

    # File lib/prism/dsl.rb, line 586
    def NumberedReferenceReadNode(number, location = Location())
      NumberedReferenceReadNode.new(number, location)
    end

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

Create a new `OptionalKeywordParameterNode` node

    # File lib/prism/dsl.rb, line 591
    def OptionalKeywordParameterNode(name, name_loc, value, location = Location())
      OptionalKeywordParameterNode.new(name, name_loc, value, location)
    end

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

Create a new `OptionalParameterNode` node

    # File lib/prism/dsl.rb, line 596
    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/prism/dsl.rb, line 601
    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/prism/dsl.rb, line 606
    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/prism/dsl.rb, line 611
    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/prism/dsl.rb, line 616
    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/prism/dsl.rb, line 621
    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/prism/dsl.rb, line 626
    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/prism/dsl.rb, line 631
    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/prism/dsl.rb, line 636
    def ProgramNode(locals, statements, location = Location())
      ProgramNode.new(locals, statements, location)
    end

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

Create a new `RangeNode` node

    # File lib/prism/dsl.rb, line 641
    def RangeNode(flags, left, right, operator_loc, location = Location())
      RangeNode.new(flags, left, right, operator_loc, location)
    end

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

Create a new `RationalNode` node

    # File lib/prism/dsl.rb, line 646
    def RationalNode(numeric, location = Location())
      RationalNode.new(numeric, location)
    end

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

Create a new `RedoNode` node

    # File lib/prism/dsl.rb, line 651
    def RedoNode(location = Location())
      RedoNode.new(location)
    end

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

Create a new `RegularExpressionNode` node

    # File lib/prism/dsl.rb, line 656
    def RegularExpressionNode(flags, opening_loc, content_loc, closing_loc, unescaped, location = Location())
      RegularExpressionNode.new(flags, opening_loc, content_loc, closing_loc, unescaped, location)
    end

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

Create a new `RequiredKeywordParameterNode` node

    # File lib/prism/dsl.rb, line 661
    def RequiredKeywordParameterNode(name, name_loc, location = Location())
      RequiredKeywordParameterNode.new(name, name_loc, location)
    end

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

Create a new `RequiredParameterNode` node

    # File lib/prism/dsl.rb, line 666
    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/prism/dsl.rb, line 671
    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/prism/dsl.rb, line 676
    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/prism/dsl.rb, line 681
    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/prism/dsl.rb, line 686
    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/prism/dsl.rb, line 691
    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/prism/dsl.rb, line 696
    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/prism/dsl.rb, line 701
    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/prism/dsl.rb, line 706
    def SourceEncodingNode(location = Location())
      SourceEncodingNode.new(location)
    end

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

Create a new `SourceFileNode` node

    # File lib/prism/dsl.rb, line 711
    def SourceFileNode(filepath, location = Location())
      SourceFileNode.new(filepath, location)
    end

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

Create a new `SourceLineNode` node

    # File lib/prism/dsl.rb, line 716
    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/prism/dsl.rb, line 721
    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/prism/dsl.rb, line 726
    def StatementsNode(body, location = Location())
      StatementsNode.new(body, location)
    end

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

Create a new `StringNode` node

    # File lib/prism/dsl.rb, line 731
    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/prism/dsl.rb, line 736
    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(flags, opening_loc, value_loc, closing_loc, unescaped, location = Location()) click to toggle source

Create a new `SymbolNode` node

    # File lib/prism/dsl.rb, line 741
    def SymbolNode(flags, opening_loc, value_loc, closing_loc, unescaped, location = Location())
      SymbolNode.new(flags, opening_loc, value_loc, closing_loc, unescaped, location)
    end

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

Create a new `TrueNode` node

    # File lib/prism/dsl.rb, line 746
    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/prism/dsl.rb, line 751
    def UndefNode(names, keyword_loc, location = Location())
      UndefNode.new(names, keyword_loc, location)
    end

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

Create a new `UnlessNode` node

    # File lib/prism/dsl.rb, line 756
    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

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

Create a new `UntilNode` node

    # File lib/prism/dsl.rb, line 761
    def UntilNode(flags, keyword_loc, closing_loc, predicate, statements, location = Location())
      UntilNode.new(flags, keyword_loc, closing_loc, predicate, statements, location)
    end

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

Create a new `WhenNode` node

    # File lib/prism/dsl.rb, line 766
    def WhenNode(keyword_loc, conditions, statements, location = Location())
      WhenNode.new(keyword_loc, conditions, statements, location)
    end

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

Create a new `WhileNode` node

    # File lib/prism/dsl.rb, line 771
    def WhileNode(flags, keyword_loc, closing_loc, predicate, statements, location = Location())
      WhileNode.new(flags, keyword_loc, closing_loc, predicate, statements, location)
    end

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

Create a new `XStringNode` node

    # File lib/prism/dsl.rb, line 776
    def XStringNode(flags, opening_loc, content_loc, closing_loc, unescaped, location = Location())
      XStringNode.new(flags, 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/prism/dsl.rb, line 781
    def YieldNode(keyword_loc, lparen_loc, arguments, rparen_loc, location = Location())
      YieldNode.new(keyword_loc, lparen_loc, arguments, rparen_loc, location)
    end