Class: Prism::LocalVariableWriteNode

Inherits:
PrismNode
  • Object
show all
Defined in:
lib/prism/node.rb,
ext/prism/api_node.c

Overview

Represents writing to a local variable.

foo = 1
^^^^^^^

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(source, node_id, location, flags, name, depth, name_loc, value, operator_loc) ⇒ LocalVariableWriteNode

Initialize a new LocalVariableWriteNode node.



13075
13076
13077
13078
13079
13080
13081
13082
13083
13084
13085
 
# File 'lib/prism/node.rb', line 13075

def initialize(source, node_id, location, flags, name, depth, name_loc, value, operator_loc)
  @source = source
  @node_id = node_id
  @location = location
  @flags = flags
  @name = name
  @depth = depth
  @name_loc = name_loc
  @value = value
  @operator_loc = operator_loc
end

Instance Attribute Details

#depth ⇒ Object (readonly)

The number of semantic scopes we have to traverse to find the declaration of this variable.

foo = 1         # depth 0

tap { foo = 1 } # depth 1

The specific rules for calculating the depth may differ from individual Ruby implementations, as they are not specified by the language. For more information, see the Prism documentation.



13141
13142
13143
 
# File 'lib/prism/node.rb', line 13141

def depth
  @depth
end

#name ⇒ Object (readonly)

The name of the local variable, which is an identifier.

foo = :bar # name `:foo`

abc = 123  # name `:abc`


13132
13133
13134
 
# File 'lib/prism/node.rb', line 13132

def name
  @name
end

#value ⇒ Object (readonly)

The value to write to the local variable. It can be any non-void expression.

foo = :bar
      ^^^^

abc = 1234
      ^^^^

Note that since the name of a local variable is known before the value is parsed, it is valid for a local variable to appear within the value of its own write.

foo = foo


13170
13171
13172
 
# File 'lib/prism/node.rb', line 13170

def value
  @value
end

Class Method Details

.type ⇒ Object

Return a symbol representation of this node type. See Node::type.



13204
13205
13206
 
# File 'lib/prism/node.rb', line 13204

def self.type
  :local_variable_write_node
end

Instance Method Details

#===(other) ⇒ Object

Implements case-equality for the node. This is effectively == but without comparing the value of locations. Locations are checked only for presence.



13210
13211
13212
13213
13214
13215
13216
13217
 
# File 'lib/prism/node.rb', line 13210

def ===(other)
  other.is_a?(LocalVariableWriteNode) &&
    (name === other.name) &&
    (depth === other.depth) &&
    (name_loc.nil? == other.name_loc.nil?) &&
    (value === other.value) &&
    (operator_loc.nil? == other.operator_loc.nil?)
end

#accept(visitor) ⇒ Object

def accept: (Visitor visitor) -> void



13088
13089
13090
 
# File 'lib/prism/node.rb', line 13088

def accept(visitor)
  visitor.visit_local_variable_write_node(self)
end

#child_nodes ⇒ Object Also known as: deconstruct

def child_nodes: () -> Array



13093
13094
13095
 
# File 'lib/prism/node.rb', line 13093

def child_nodes
  [value]
end

#comment_targets ⇒ Object

def comment_targets: () -> Array[Node | Location]



13110
13111
13112
 
# File 'lib/prism/node.rb', line 13110

def comment_targets
  [name_loc, value, operator_loc] #: Array[Prism::node | Location]
end

#compact_child_nodes ⇒ Object

def compact_child_nodes: () -> Array



13105
13106
13107
 
# File 'lib/prism/node.rb', line 13105

def compact_child_nodes
  [value]
end

#copy(node_id: self.node_id, location: self.location, flags: self.flags, name: self.name, depth: self.depth, name_loc: self.name_loc, value: self.value, operator_loc: self.operator_loc) ⇒ Object

def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?depth: Integer, ?name_loc: Location, ?value: Prism::node, ?operator_loc: Location) -> LocalVariableWriteNode



13115
13116
13117
 
# File 'lib/prism/node.rb', line 13115

def copy(node_id: self.node_id, location: self.location, flags: self.flags, name: self.name, depth: self.depth, name_loc: self.name_loc, value: self.value, operator_loc: self.operator_loc)
  LocalVariableWriteNode.new(source, node_id, location, flags, name, depth, name_loc, value, operator_loc)
end

#deconstruct_keys(keys) ⇒ Object

def deconstruct_keys: (Array keys) -> { node_id: Integer, location: Location, name: Symbol, depth: Integer, name_loc: Location, value: Prism::node, operator_loc: Location }



13123
13124
13125
 
# File 'lib/prism/node.rb', line 13123

def deconstruct_keys(keys)
  { node_id: node_id, location: location, name: name, depth: depth, name_loc: name_loc, value: value, operator_loc: operator_loc }
end

#each_child_node {|value| ... } ⇒ Object

def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator

Yields:



13098
13099
13100
13101
13102
 
# File 'lib/prism/node.rb', line 13098

def each_child_node
  return to_enum(:each_child_node) unless block_given?

  yield value
end

#inspect ⇒ Object

def inspect -> String



13194
13195
13196
 
# File 'lib/prism/node.rb', line 13194

def inspect
  InspectVisitor.compose(self)
end

#name_loc ⇒ Object

The location of the variable name.

foo = :bar
^^^


13147
13148
13149
13150
13151
 
# File 'lib/prism/node.rb', line 13147

def name_loc
  location = @name_loc
  return location if location.is_a?(Location)
  @name_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
end

#operator ⇒ Object

def operator: () -> String



13189
13190
13191
 
# File 'lib/prism/node.rb', line 13189

def operator
  operator_loc.slice
end

#operator_loc ⇒ Object

The location of the = operator.

x = :y
  ^


13176
13177
13178
13179
13180
 
# File 'lib/prism/node.rb', line 13176

def operator_loc
  location = @operator_loc
  return location if location.is_a?(Location)
  @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
end

#save_name_loc(repository) ⇒ Object

Save the name_loc location using the given saved source so that it can be retrieved later.



13155
13156
13157
 
# File 'lib/prism/node.rb', line 13155

def save_name_loc(repository)
  repository.enter(node_id, :name_loc)
end

#save_operator_loc(repository) ⇒ Object

Save the operator_loc location using the given saved source so that it can be retrieved later.



13184
13185
13186
 
# File 'lib/prism/node.rb', line 13184

def save_operator_loc(repository)
  repository.enter(node_id, :operator_loc)
end

#type ⇒ Object

Return a symbol representation of this node type. See Node#type.



13199
13200
13201
 
# File 'lib/prism/node.rb', line 13199

def type
  :local_variable_write_node
end