класс Prism::CallOperatorWriteNode

Родитель:: Prism::Node

Представляет использование оператора присваивания в вызове.

foo.bar += baz
^^^^^^^^^^^^^^

Атрибуты

call_operator_loc[R]

attr_reader call_operator_loc: Location?

message_loc[R]

attr_reader message_loc: Location?

operator[R]

attr_reader operator: Symbol

operator_loc[R]

attr_reader operator_loc: Location

read_name[R]

attr_reader read_name: Symbol

receiver[R]

attr_reader receiver: Node?

value[R]

attr_reader value: Node

write_name[R]

attr_reader write_name: Symbol

Общедоступные методы класса

new(flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator, operator_loc, value, location) Показать исходный код

# File lib/prism/node.rb, line 2371
def initialize(flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator, operator_loc, value, location)
  @flags = flags
  @receiver = receiver
  @call_operator_loc = call_operator_loc
  @message_loc = message_loc
  @read_name = read_name
  @write_name = write_name
  @operator = operator
  @operator_loc = operator_loc
  @value = value
  @location = location
end

def initialize: (flags: Integer, receiver: Node?, call_operator_loc: Location?, message_loc: Location?, read_name: Symbol, write_name: Symbol, operator: Symbol, operator_loc: Location, value: Node, location: Location) -> void

type() Показать исходный код

# File lib/prism/node.rb, line 2502
def self.type
  :call_operator_write_node
end

Аналогично type, этот метод возвращает символ, который можно использовать для разделения по типу узла, не прибегая к длинной цепочке ===. Обратите внимание, что, как и type, он всё ещё будет медленнее, чем использование == для одного класса, но должен быть быстрее в операторе case или сравнении массивов.

def self.type: () -> Symbol

Общедоступные методы экземпляров

accept(visitor) Показать исходный код

# File lib/prism/node.rb, line 2385
def accept(visitor)
  visitor.visit_call_operator_write_node(self)
end

def accept: (visitor: Visitor) -> void

attribute_write?() Показать исходный код

# File lib/prism/node.rb, line 2442
def attribute_write?
  flags.anybits?(CallNodeFlags::ATTRIBUTE_WRITE)
end

def attribute_write?: () -> bool

call_operator() Показать исходный код

# File lib/prism/node.rb, line 2447
def call_operator
  call_operator_loc&.slice
end

def call_operator: () -> String?

child_nodes() Показать исходный код

# File lib/prism/node.rb, line 2390
def child_nodes
  [receiver, value]
end

def child_nodes: () -> Array[nil | Node]

Также алиасируется как: deconstruct

comment_targets() Показать исходный код

# File lib/prism/node.rb, line 2403
def comment_targets
  [*receiver, *call_operator_loc, *message_loc, operator_loc, value]
end

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

compact_child_nodes() Показать исходный код

# File lib/prism/node.rb, line 2395
def compact_child_nodes
  compact = []
  compact << receiver if receiver
  compact << value
  compact
end

def compact_child_nodes: () -> Array

copy(**params) Показать исходный код

# File lib/prism/node.rb, line 2408
def copy(**params)
  CallOperatorWriteNode.new(
    params.fetch(:flags) { flags },
    params.fetch(:receiver) { receiver },
    params.fetch(:call_operator_loc) { call_operator_loc },
    params.fetch(:message_loc) { message_loc },
    params.fetch(:read_name) { read_name },
    params.fetch(:write_name) { write_name },
    params.fetch(:operator) { operator },
    params.fetch(:operator_loc) { operator_loc },
    params.fetch(:value) { value },
    params.fetch(:location) { location },
  )
end

def copy: (**params) -> CallOperatorWriteNode

deconstruct()

def deconstruct: () -> Array[nil | Node]

Псевдоним для: child_nodes

deconstruct_keys(keys) Показать исходный код

# File lib/prism/node.rb, line 2427
def deconstruct_keys(keys)
  { flags: flags, receiver: receiver, call_operator_loc: call_operator_loc, message_loc: message_loc, read_name: read_name, write_name: write_name, operator: operator, operator_loc: operator_loc, value: value, location: location }
end

inspect(inspector = NodeInspector.new) Показать исходный код

# File lib/prism/node.rb, line 2457
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 << "├── message_loc: #{inspector.location(message_loc)}\n"
  inspector << "├── read_name: #{read_name.inspect}\n"
  inspector << "├── write_name: #{write_name.inspect}\n"
  inspector << "├── operator: #{operator.inspect}\n"
  inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
  inspector << "└── value:\n"
  inspector << inspector.child_node(value, "    ")
  inspector.to_str
end

def inspect(inspector: NodeInspector) -> String

message() Показать исходный код

# File lib/prism/node.rb, line 2452
def message
  message_loc&.slice
end

def message: () -> String?

safe_navigation?() Показать исходный код

# File lib/prism/node.rb, line 2432
def safe_navigation?
  flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
end

def safe_navigation?: () -> bool

type() Показать исходный код

# File lib/prism/node.rb, line 2492
def type
  :call_operator_write_node
end

Иногда вам нужно проверить экземпляр узла на соответствие списку классов, чтобы определить, какое поведение выполнить. Обычно это делается с помощью вызова `[cls1, cls2].include?(node.class)` или размещения узла в операторе case и выполнения `case node; when cls1; when cls2; end`. Оба этих подхода относительно медленные из-за постоянных поисков, вызовов методов и/или выделения памяти массивов.

Вместо этого вы можете вызвать type, который вернёт символ, который вы можете использовать для сравнения. Это быстрее, чем другие подходы, потому что использует одно сравнение целых чисел, а также потому, что если вы работаете с CRuby, вы можете воспользоваться тем, что операторы case со всеми символами-ключами используют таблицу переходов.

def type: () -> Symbol

variable_call?() Показать исходный код

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