класс Prism::CallNode
Представляет вызов метода в различных формах.
foo ^^^ foo() ^^^^^ +foo ^^^^ foo + bar ^^^^^^^^^ foo.bar ^^^^^^^ foo&.bar ^^^^^^^^
Атрибуты
attr_reader arguments: ArgumentsNode?
attr_reader block: Node?
attr_reader call_operator_loc: Location?
attr_reader closing_loc: Location?
attr_reader message_loc: Location?
attr_reader name: Symbol
attr_reader opening_loc: Location?
attr_reader receiver: Node?
Публичные методы класса
# File lib/prism/node.rb, line 2182 def initialize(flags, receiver, call_operator_loc, name, message_loc, opening_loc, arguments, closing_loc, block, location) @flags = flags @receiver = receiver @call_operator_loc = call_operator_loc @name = name @message_loc = message_loc @opening_loc = opening_loc @arguments = arguments @closing_loc = closing_loc @block = block @location = location end
def initialize: (flags: Integer, receiver: Node?, call_operator_loc: Location?, name: Symbol, message_loc: Location?, opening_loc: Location?, arguments: ArgumentsNode?, closing_loc: Location?, block: Node?, location: Location) -> void
# File lib/prism/node.rb, line 2333 def self.type :call_node end
Аналогично type, этот метод возвращает символ, который можно использовать для разделения по типу узла, не выполняя длинную цепочку ===. Обратите внимание, что, как и type, он по-прежнему будет медленнее, чем использование == для одного класса, но должен быть быстрее в операторе case или сравнении массивов.
def self.type: () -> Symbol
Общедоступные методы экземпляра
# File lib/prism/node.rb, line 2196 def accept(visitor) visitor.visit_call_node(self) end
def accept: (visitor: Visitor) -> void
# File lib/prism/node.rb, line 2254 def attribute_write? flags.anybits?(CallNodeFlags::ATTRIBUTE_WRITE) end
def attribute_write?: () -> bool
# File lib/prism/node.rb, line 2259 def call_operator call_operator_loc&.slice end
def call_operator: () -> String?
# File lib/prism/node.rb, line 2201 def child_nodes [receiver, arguments, block] end
def child_nodes: () -> Array[nil | Node]
# File lib/prism/node.rb, line 2274 def closing closing_loc&.slice end
def closing: () -> String?
# File lib/prism/node.rb, line 2215 def comment_targets [*receiver, *call_operator_loc, *message_loc, *opening_loc, *arguments, *closing_loc, *block] end
def comment_targets: () -> Array[Node | Location]
# File lib/prism/node.rb, line 2206 def compact_child_nodes compact = [] compact << receiver if receiver compact << arguments if arguments compact << block if block compact end
def compact_child_nodes: () -> Array
# File lib/prism/node.rb, line 2220
def copy(**params)
CallNode.new(
params.fetch(:flags) { flags },
params.fetch(:receiver) { receiver },
params.fetch(:call_operator_loc) { call_operator_loc },
params.fetch(:name) { name },
params.fetch(:message_loc) { message_loc },
params.fetch(:opening_loc) { opening_loc },
params.fetch(:arguments) { arguments },
params.fetch(:closing_loc) { closing_loc },
params.fetch(:block) { block },
params.fetch(:location) { location },
)
end def copy: (**params) -> CallNode
# File lib/prism/node.rb, line 2239
def deconstruct_keys(keys)
{ flags: flags, receiver: receiver, call_operator_loc: call_operator_loc, name: name, message_loc: message_loc, opening_loc: opening_loc, arguments: arguments, closing_loc: closing_loc, block: block, location: location }
end def deconstruct_keys: (keys: Array) -> Hash[Symbol, nil | Node | Array | String | Token | Array | Location]
# File lib/prism/node.rb, line 2279
def inspect(inspector = NodeInspector.new)
inspector << inspector.header(self)
flags = [("safe_navigation" if safe_navigation?), ("variable_call" if variable_call?), ("attribute_write" if attribute_write?)].compact
inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
if (receiver = self.receiver).nil?
inspector << "├── receiver: ∅\n"
else
inspector << "├── receiver:\n"
inspector << receiver.inspect(inspector.child_inspector("│ ")).delete_prefix(inspector.prefix)
end
inspector << "├── call_operator_loc: #{inspector.location(call_operator_loc)}\n"
inspector << "├── name: #{name.inspect}\n"
inspector << "├── message_loc: #{inspector.location(message_loc)}\n"
inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
if (arguments = self.arguments).nil?
inspector << "├── arguments: ∅\n"
else
inspector << "├── arguments:\n"
inspector << arguments.inspect(inspector.child_inspector("│ ")).delete_prefix(inspector.prefix)
end
inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
if (block = self.block).nil?
inspector << "└── block: ∅\n"
else
inspector << "└── block:\n"
inspector << block.inspect(inspector.child_inspector(" ")).delete_prefix(inspector.prefix)
end
inspector.to_str
end def inspect(inspector: NodeInspector) -> String
# File lib/prism/node.rb, line 2264 def message message_loc&.slice end
def message: () -> String?
# File lib/prism/node.rb, line 2269 def opening opening_loc&.slice end
def opening: () -> String?
def safe_navigation?: () -> bool
# File lib/prism/node.rb, line 2323 def type :call_node end
Иногда вам нужно проверить экземпляр узла на соответствие списку классов, чтобы определить, какое поведение использовать. Обычно это делается с помощью `[cls1, cls2].include?(node.class)` или размещения узла в операторе case и выполнении `case node; when cls1; when cls2; end`. Оба этих подхода относительно медленные из-за постоянных проверок, вызовов методов и/или выделения массивов.
Вместо этого вы можете вызвать type, который вернёт вам символ, который можно использовать для сравнения. Это быстрее, чем другие подходы, потому что использует одно целое сравнение, а также потому, что если вы используете CRuby, то можете воспользоваться тем, что операторы case со всеми символьными ключами будут использовать таблицу переходов.
def type: () -> Symbol
# File lib/prism/node.rb, line 2249 def variable_call? flags.anybits?(CallNodeFlags::VARIABLE_CALL) end
def variable_call?: () -> bool
Ruby Core © 1993–2022 Yukihiro Matsumoto
Licensed under the Ruby License.
Ruby Standard Library © contributors
Licensed under their own licenses.
