Class: Prism::ConstantPathAndWriteNode
- Inherits:
-
PrismNode
- Object
- PrismNode
- Prism::ConstantPathAndWriteNode
- Defined in:
- lib/prism/node.rb,
ext/prism/api_node.c
Overview
Represents the use of the ‘&&=` operator for assignment to a constant path.
Parent::Child &&= value
^^^^^^^^^^^^^^^^^^^^^^^
Instance Attribute Summary collapse
-
#operator_loc ⇒ Object
readonly
attr_reader operator_loc: Location.
-
#target ⇒ Object
readonly
attr_reader target: ConstantPathNode.
-
#value ⇒ Object
readonly
attr_reader value: Node.
Class Method Summary collapse
-
.type ⇒ Object
Similar to #type, this method returns a symbol that you can use for splitting on the type of the node without having to do a long === chain.
Instance Method Summary collapse
-
#accept(visitor) ⇒ Object
def accept: (visitor: Visitor) -> void.
-
#child_nodes ⇒ Object
(also: #deconstruct)
def child_nodes: () -> Array[nil | Node].
-
#comment_targets ⇒ Object
def comment_targets: () -> Array[Node | Location].
-
#compact_child_nodes ⇒ Object
def compact_child_nodes: () -> Array.
-
#copy(**params) ⇒ Object
def copy: (**params) -> ConstantPathAndWriteNode.
- #deconstruct_keys(keys) ⇒ Object
-
#initialize(target, operator_loc, value, location) ⇒ ConstantPathAndWriteNode
constructor
def initialize: (target: ConstantPathNode, operator_loc: Location, value: Node, location: Location) -> void.
-
#inspect(inspector = NodeInspector.new) ⇒ Object
def inspect(inspector: NodeInspector) -> String.
-
#operator ⇒ Object
def operator: () -> String.
-
#type ⇒ Object
Sometimes you want to check an instance of a node against a list of classes to see what kind of behavior to perform.
Constructor Details
#initialize(target, operator_loc, value, location) ⇒ ConstantPathAndWriteNode
def initialize: (target: ConstantPathNode, operator_loc: Location, value: Node, location: Location) -> void
4314 4315 4316 4317 4318 4319 |
# File 'lib/prism/node.rb', line 4314 def initialize(target, operator_loc, value, location) @target = target @operator_loc = operator_loc @value = value @location = location end |
Instance Attribute Details
#operator_loc ⇒ Object (readonly)
attr_reader operator_loc: Location
4308 4309 4310 |
# File 'lib/prism/node.rb', line 4308 def operator_loc @operator_loc end |
#target ⇒ Object (readonly)
attr_reader target: ConstantPathNode
4305 4306 4307 |
# File 'lib/prism/node.rb', line 4305 def target @target end |
#value ⇒ Object (readonly)
attr_reader value: Node
4311 4312 4313 |
# File 'lib/prism/node.rb', line 4311 def value @value end |
Class Method Details
.type ⇒ Object
Similar to #type, this method returns a symbol that you can use for splitting on the type of the node without having to do a long === chain. Note that like #type, it will still be slower than using == for a single class, but should be faster in a case statement or an array comparison.
def self.type: () -> Symbol
4399 4400 4401 |
# File 'lib/prism/node.rb', line 4399 def self.type :constant_path_and_write_node end |
Instance Method Details
#accept(visitor) ⇒ Object
def accept: (visitor: Visitor) -> void
4322 4323 4324 |
# File 'lib/prism/node.rb', line 4322 def accept(visitor) visitor.visit_constant_path_and_write_node(self) end |
#child_nodes ⇒ Object Also known as: deconstruct
def child_nodes: () -> Array[nil | Node]
4327 4328 4329 |
# File 'lib/prism/node.rb', line 4327 def child_nodes [target, value] end |
#comment_targets ⇒ Object
def comment_targets: () -> Array[Node | Location]
4337 4338 4339 |
# File 'lib/prism/node.rb', line 4337 def comment_targets [target, operator_loc, value] end |
#compact_child_nodes ⇒ Object
def compact_child_nodes: () -> Array
4332 4333 4334 |
# File 'lib/prism/node.rb', line 4332 def compact_child_nodes [target, value] end |
#copy(**params) ⇒ Object
def copy: (**params) -> ConstantPathAndWriteNode
4342 4343 4344 4345 4346 4347 4348 4349 |
# File 'lib/prism/node.rb', line 4342 def copy(**params) ConstantPathAndWriteNode.new( params.fetch(:target) { target }, params.fetch(:operator_loc) { operator_loc }, params.fetch(:value) { value }, params.fetch(:location) { location }, ) end |
#deconstruct_keys(keys) ⇒ Object
4355 4356 4357 |
# File 'lib/prism/node.rb', line 4355 def deconstruct_keys(keys) { target: target, operator_loc: operator_loc, value: value, location: location } end |
#inspect(inspector = NodeInspector.new) ⇒ Object
def inspect(inspector: NodeInspector) -> String
4365 4366 4367 4368 4369 4370 4371 4372 4373 |
# File 'lib/prism/node.rb', line 4365 def inspect(inspector = NodeInspector.new) inspector << inspector.header(self) inspector << "├── target:\n" inspector << inspector.child_node(target, "│ ") inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n" inspector << "└── value:\n" inspector << inspector.child_node(value, " ") inspector.to_str end |
#operator ⇒ Object
def operator: () -> String
4360 4361 4362 |
# File 'lib/prism/node.rb', line 4360 def operator operator_loc.slice end |
#type ⇒ Object
Sometimes you want to check an instance of a node against a list of classes to see what kind of behavior to perform. Usually this is done by calling ‘[cls1, cls2].include?(node.class)` or putting the node into a case statement and doing `case node; when cls1; when cls2; end`. Both of these approaches are relatively slow because of the constant lookups, method calls, and/or array allocations.
Instead, you can call #type, which will return to you a symbol that you can use for comparison. This is faster than the other approaches because it uses a single integer comparison, but also because if you’re on CRuby you can take advantage of the fact that case statements with all symbol keys will use a jump table.
def type: () -> Symbol
4389 4390 4391 |
# File 'lib/prism/node.rb', line 4389 def type :constant_path_and_write_node end |