Class: Prism::CallNode
- Inherits:
-
PrismNode
- Object
- PrismNode
- Prism::CallNode
- Defined in:
- lib/prism/node.rb,
lib/prism/node_ext.rb,
ext/prism/api_node.c more...
Overview
Represents a method call, in all of the various forms that can take.
foo
^^^
foo()
^^^^^
+foo
^^^^
foo + bar
^^^^^^^^^
foo.bar
^^^^^^^
foo&.bar
^^^^^^^^
Instance Attribute Summary collapse
-
#arguments ⇒ Object
readonly
Represents the arguments to the method call.
-
#block ⇒ Object
readonly
Represents the block that is being passed to the method.
-
#name ⇒ Object
readonly
Represents the name of the method being called.
-
#receiver ⇒ Object
readonly
The object that the method is being called on.
Class Method Summary collapse
-
.type ⇒ Object
Return a symbol representation of this node type.
Instance Method Summary collapse
-
#===(other) ⇒ Object
Implements case-equality for the node.
-
#accept(visitor) ⇒ Object
def accept: (Visitor visitor) -> void.
-
#attribute_write? ⇒ Boolean
def attribute_write?: () -> bool.
-
#call_operator ⇒ Object
def call_operator: () -> String?.
-
#call_operator_loc ⇒ Object
Represents the location of the call operator.
-
#child_nodes ⇒ Object
(also: #deconstruct)
def child_nodes: () -> Array[nil | Node].
-
#closing ⇒ Object
def closing: () -> String?.
-
#closing_loc ⇒ Object
Represents the location of the right parenthesis.
-
#comment_targets ⇒ Object
def comment_targets: () -> Array[Node | Location].
-
#compact_child_nodes ⇒ Object
def compact_child_nodes: () -> Array.
-
#copy(node_id: self.node_id, location: self.location, flags: self.flags, receiver: self.receiver, call_operator_loc: self.call_operator_loc, name: self.name, message_loc: self.message_loc, opening_loc: self.opening_loc, arguments: self.arguments, closing_loc: self.closing_loc, block: self.block) ⇒ Object
def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?name: Symbol, ?message_loc: Location?, ?opening_loc: Location?, ?arguments: ArgumentsNode?, ?closing_loc: Location?, ?block: BlockNode | BlockArgumentNode | nil) -> CallNode.
-
#deconstruct_keys(keys) ⇒ Object
def deconstruct_keys: (Array keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, name: Symbol, message_loc: Location?, opening_loc: Location?, arguments: ArgumentsNode?, closing_loc: Location?, block: BlockNode | BlockArgumentNode | nil }.
-
#full_message_loc ⇒ Object
When a call node has the attribute_write flag set, it means that the call is using the attribute write syntax.
-
#ignore_visibility? ⇒ Boolean
def ignore_visibility?: () -> bool.
-
#initialize(source, node_id, location, flags, receiver, call_operator_loc, name, message_loc, opening_loc, arguments, closing_loc, block) ⇒ CallNode
constructor
Initialize a new CallNode node.
-
#inspect ⇒ Object
def inspect -> String.
-
#message ⇒ Object
def message: () -> String?.
-
#message_loc ⇒ Object
Represents the location of the message.
-
#opening ⇒ Object
def opening: () -> String?.
-
#opening_loc ⇒ Object
Represents the location of the left parenthesis.
-
#safe_navigation? ⇒ Boolean
def safe_navigation?: () -> bool.
-
#save_call_operator_loc(repository) ⇒ Object
Save the call_operator_loc location using the given saved source so that it can be retrieved later.
-
#save_closing_loc(repository) ⇒ Object
Save the closing_loc location using the given saved source so that it can be retrieved later.
-
#save_message_loc(repository) ⇒ Object
Save the message_loc location using the given saved source so that it can be retrieved later.
-
#save_opening_loc(repository) ⇒ Object
Save the opening_loc location using the given saved source so that it can be retrieved later.
-
#type ⇒ Object
Return a symbol representation of this node type.
-
#variable_call? ⇒ Boolean
def variable_call?: () -> bool.
Constructor Details
permalink #initialize(source, node_id, location, flags, receiver, call_operator_loc, name, message_loc, opening_loc, arguments, closing_loc, block) ⇒ CallNode
Initialize a new CallNode node.
2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 |
# File 'lib/prism/node.rb', line 2596 def initialize(source, node_id, location, flags, receiver, call_operator_loc, name, , opening_loc, arguments, closing_loc, block) @source = source @node_id = node_id @location = location @flags = flags @receiver = receiver @call_operator_loc = call_operator_loc @name = name @message_loc = @opening_loc = opening_loc @arguments = arguments @closing_loc = closing_loc @block = block end |
Instance Attribute Details
permalink #arguments ⇒ Object (readonly)
Represents the arguments to the method call. These can be any [non-void expressions](github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
foo(bar)
^^^
2758 2759 2760 |
# File 'lib/prism/node.rb', line 2758 def arguments @arguments end |
permalink #block ⇒ Object (readonly)
Represents the block that is being passed to the method.
foo { |a| a }
^^^^^^^^^
2786 2787 2788 |
# File 'lib/prism/node.rb', line 2786 def block @block end |
permalink #name ⇒ Object (readonly)
Represents the name of the method being called.
foo.bar # name `:foo`
^^^
2709 2710 2711 |
# File 'lib/prism/node.rb', line 2709 def name @name end |
permalink #receiver ⇒ Object (readonly)
The object that the method is being called on. This can be either ‘nil` or any [non-void expression](github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
foo.bar
^^^
+foo
^^^
foo + bar
^^^
2678 2679 2680 |
# File 'lib/prism/node.rb', line 2678 def receiver @receiver end |
Class Method Details
permalink .type ⇒ Object
Return a symbol representation of this node type. See ‘Node::type`.
2819 2820 2821 |
# File 'lib/prism/node.rb', line 2819 def self.type :call_node end |
Instance Method Details
permalink #===(other) ⇒ Object
Implements case-equality for the node. This is effectively == but without comparing the value of locations. Locations are checked only for presence.
2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 |
# File 'lib/prism/node.rb', line 2825 def ===(other) other.is_a?(CallNode) && (flags === other.flags) && (receiver === other.receiver) && (call_operator_loc.nil? == other.call_operator_loc.nil?) && (name === other.name) && (.nil? == other..nil?) && (opening_loc.nil? == other.opening_loc.nil?) && (arguments === other.arguments) && (closing_loc.nil? == other.closing_loc.nil?) && (block === other.block) end |
permalink #accept(visitor) ⇒ Object
def accept: (Visitor visitor) -> void
2612 2613 2614 |
# File 'lib/prism/node.rb', line 2612 def accept(visitor) visitor.visit_call_node(self) end |
permalink #attribute_write? ⇒ Boolean
def attribute_write?: () -> bool
2659 2660 2661 |
# File 'lib/prism/node.rb', line 2659 def attribute_write? flags.anybits?(CallNodeFlags::ATTRIBUTE_WRITE) end |
permalink #call_operator ⇒ Object
def call_operator: () -> String?
2789 2790 2791 |
# File 'lib/prism/node.rb', line 2789 def call_operator call_operator_loc&.slice end |
permalink #call_operator_loc ⇒ Object
Represents the location of the call operator.
foo.bar
^
foo&.bar
^^
2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 |
# File 'lib/prism/node.rb', line 2687 def call_operator_loc location = @call_operator_loc case location when nil nil when Location location else @call_operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF) end end |
permalink #child_nodes ⇒ Object Also known as: deconstruct
def child_nodes: () -> Array[nil | Node]
2617 2618 2619 |
# File 'lib/prism/node.rb', line 2617 def child_nodes [receiver, arguments, block] end |
permalink #closing ⇒ Object
def closing: () -> String?
2804 2805 2806 |
# File 'lib/prism/node.rb', line 2804 def closing closing_loc&.slice end |
permalink #closing_loc ⇒ Object
Represents the location of the right parenthesis.
foo(bar)
^
2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 |
# File 'lib/prism/node.rb', line 2764 def closing_loc location = @closing_loc case location when nil nil when Location location else @closing_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF) end end |
permalink #comment_targets ⇒ Object
def comment_targets: () -> Array[Node | Location]
2631 2632 2633 |
# File 'lib/prism/node.rb', line 2631 def comment_targets [*receiver, *call_operator_loc, *, *opening_loc, *arguments, *closing_loc, *block] #: Array[Prism::node | Location] end |
permalink #compact_child_nodes ⇒ Object
def compact_child_nodes: () -> Array
2622 2623 2624 2625 2626 2627 2628 |
# File 'lib/prism/node.rb', line 2622 def compact_child_nodes compact = [] #: Array[Prism::node] compact << receiver if receiver compact << arguments if arguments compact << block if block compact end |
permalink #copy(node_id: self.node_id, location: self.location, flags: self.flags, receiver: self.receiver, call_operator_loc: self.call_operator_loc, name: self.name, message_loc: self.message_loc, opening_loc: self.opening_loc, arguments: self.arguments, closing_loc: self.closing_loc, block: self.block) ⇒ Object
def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?name: Symbol, ?message_loc: Location?, ?opening_loc: Location?, ?arguments: ArgumentsNode?, ?closing_loc: Location?, ?block: BlockNode | BlockArgumentNode | nil) -> CallNode
2636 2637 2638 |
# File 'lib/prism/node.rb', line 2636 def copy(node_id: self.node_id, location: self.location, flags: self.flags, receiver: self.receiver, call_operator_loc: self.call_operator_loc, name: self.name, message_loc: self., opening_loc: self.opening_loc, arguments: self.arguments, closing_loc: self.closing_loc, block: self.block) CallNode.new(source, node_id, location, flags, receiver, call_operator_loc, name, , opening_loc, arguments, closing_loc, block) end |
permalink #deconstruct_keys(keys) ⇒ Object
def deconstruct_keys: (Array keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, name: Symbol, message_loc: Location?, opening_loc: Location?, arguments: ArgumentsNode?, closing_loc: Location?, block: BlockNode | BlockArgumentNode | nil }
2644 2645 2646 |
# File 'lib/prism/node.rb', line 2644 def deconstruct_keys(keys) { node_id: node_id, location: location, receiver: receiver, call_operator_loc: call_operator_loc, name: name, message_loc: , opening_loc: opening_loc, arguments: arguments, closing_loc: closing_loc, block: block } end |
permalink #full_message_loc ⇒ Object
When a call node has the attribute_write flag set, it means that the call is using the attribute write syntax. This is either a method call to []= or a method call to a method that ends with =. Either way, the = sign is present in the source.
Prism returns the message_loc without the = sign attached, because there can be any amount of space between the message and the = sign. However, sometimes you want the location of the full message including the inner space and the = sign. This method provides that.
331 332 333 |
# File 'lib/prism/node_ext.rb', line 331 def attribute_write? ? &.adjoin("=") : end |
permalink #ignore_visibility? ⇒ Boolean
def ignore_visibility?: () -> bool
2664 2665 2666 |
# File 'lib/prism/node.rb', line 2664 def ignore_visibility? flags.anybits?(CallNodeFlags::IGNORE_VISIBILITY) end |
permalink #inspect ⇒ Object
def inspect -> String
2809 2810 2811 |
# File 'lib/prism/node.rb', line 2809 def inspect InspectVisitor.compose(self) end |
permalink #message ⇒ Object
def message: () -> String?
2794 2795 2796 |
# File 'lib/prism/node.rb', line 2794 def &.slice end |
permalink #message_loc ⇒ Object
Represents the location of the message.
foo.bar
^^^
2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 |
# File 'lib/prism/node.rb', line 2715 def location = @message_loc case location when nil nil when Location location else @message_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF) end end |
permalink #opening ⇒ Object
def opening: () -> String?
2799 2800 2801 |
# File 'lib/prism/node.rb', line 2799 def opening opening_loc&.slice end |
permalink #opening_loc ⇒ Object
Represents the location of the left parenthesis.
foo(bar)
^
2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 |
# File 'lib/prism/node.rb', line 2736 def opening_loc location = @opening_loc case location when nil nil when Location location else @opening_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF) end end |
permalink #safe_navigation? ⇒ Boolean
def safe_navigation?: () -> bool
2649 2650 2651 |
# File 'lib/prism/node.rb', line 2649 def flags.anybits?(CallNodeFlags::SAFE_NAVIGATION) end |
permalink #save_call_operator_loc(repository) ⇒ Object
Save the call_operator_loc location using the given saved source so that it can be retrieved later.
2701 2702 2703 |
# File 'lib/prism/node.rb', line 2701 def save_call_operator_loc(repository) repository.enter(node_id, :call_operator_loc) unless @call_operator_loc.nil? end |
permalink #save_closing_loc(repository) ⇒ Object
Save the closing_loc location using the given saved source so that it can be retrieved later.
2778 2779 2780 |
# File 'lib/prism/node.rb', line 2778 def save_closing_loc(repository) repository.enter(node_id, :closing_loc) unless @closing_loc.nil? end |
permalink #save_message_loc(repository) ⇒ Object
Save the message_loc location using the given saved source so that it can be retrieved later.
2729 2730 2731 |
# File 'lib/prism/node.rb', line 2729 def (repository) repository.enter(node_id, :message_loc) unless @message_loc.nil? end |
permalink #save_opening_loc(repository) ⇒ Object
Save the opening_loc location using the given saved source so that it can be retrieved later.
2750 2751 2752 |
# File 'lib/prism/node.rb', line 2750 def save_opening_loc(repository) repository.enter(node_id, :opening_loc) unless @opening_loc.nil? end |
permalink #type ⇒ Object
Return a symbol representation of this node type. See ‘Node#type`.
2814 2815 2816 |
# File 'lib/prism/node.rb', line 2814 def type :call_node end |
permalink #variable_call? ⇒ Boolean
def variable_call?: () -> bool
2654 2655 2656 |
# File 'lib/prism/node.rb', line 2654 def variable_call? flags.anybits?(CallNodeFlags::VARIABLE_CALL) end |