class RuboCop::Cop::Lint::UselessSetterCall::MethodVariableTracker

This class tracks variable assignments in a method body and if a variable contains object passed as argument at the end of the method.

Public Class Methods

new(body_node) click to toggle source
# File lib/rubocop/cop/lint/useless_setter_call.rb, line 69
def initialize(body_node)
  @body_node = body_node
  @local = nil
end

Public Instance Methods

constructor?(node) click to toggle source
# File lib/rubocop/cop/lint/useless_setter_call.rb, line 155
def constructor?(node)
  return true if node.literal?
  return false unless node.send_type?
  _receiver, method = *node
  method == :new
end
contain_local_object?(variable_name) click to toggle source
# File lib/rubocop/cop/lint/useless_setter_call.rb, line 74
def contain_local_object?(variable_name)
  return @local[variable_name] if @local

  @local = {}

  scan(@body_node) { |node| process_assignment_node(node) }

  @local[variable_name]
end
process_assignment(asgn_node, rhs_node) click to toggle source
# File lib/rubocop/cop/lint/useless_setter_call.rb, line 144
def process_assignment(asgn_node, rhs_node)
  lhs_variable_name, = *asgn_node

  @local[lhs_variable_name] = if rhs_node.variable?
                                rhs_variable_name, = *rhs_node
                                @local[rhs_variable_name]
                              else
                                constructor?(rhs_node)
                              end
end
process_assignment_node(node) click to toggle source
# File lib/rubocop/cop/lint/useless_setter_call.rb, line 94
def process_assignment_node(node)
  case node.type
  when :masgn
    process_multiple_assignment(node)
  when :or_asgn, :and_asgn
    process_logical_operator_assignment(node)
  when :op_asgn
    process_binary_operator_assignment(node)
  when *ASSIGNMENT_TYPES
    _, rhs_node = *node
    process_assignment(node, rhs_node) if rhs_node
  end
end
process_binary_operator_assignment(op_asgn_node) click to toggle source
# File lib/rubocop/cop/lint/useless_setter_call.rb, line 135
def process_binary_operator_assignment(op_asgn_node)
  lhs_node, = *op_asgn_node
  return unless ASSIGNMENT_TYPES.include?(lhs_node.type)
  lhs_variable_name, = *lhs_node
  @local[lhs_variable_name] = true

  throw :skip_children
end
process_logical_operator_assignment(asgn_node) click to toggle source
# File lib/rubocop/cop/lint/useless_setter_call.rb, line 127
def process_logical_operator_assignment(asgn_node)
  lhs_node, rhs_node = *asgn_node
  return unless ASSIGNMENT_TYPES.include?(lhs_node.type)
  process_assignment(lhs_node, rhs_node)

  throw :skip_children
end
process_multiple_assignment(masgn_node) click to toggle source
# File lib/rubocop/cop/lint/useless_setter_call.rb, line 108
def process_multiple_assignment(masgn_node)
  mlhs_node, mrhs_node = *masgn_node

  mlhs_node.children.each_with_index do |lhs_node, index|
    next unless ASSIGNMENT_TYPES.include?(lhs_node.type)

    lhs_variable_name, = *lhs_node
    rhs_node = mrhs_node.children[index]

    if mrhs_node.array_type? && rhs_node
      process_assignment(lhs_variable_name, rhs_node)
    else
      @local[lhs_variable_name] = true
    end
  end

  throw :skip_children
end
scan(node) { |node| ... } click to toggle source
# File lib/rubocop/cop/lint/useless_setter_call.rb, line 84
def scan(node, &block)
  catch(:skip_children) do
    yield node

    node.each_child_node do |child_node|
      scan(child_node, &block)
    end
  end
end