class RuboCop::Cop::VariableForce::Variable

and some states of the variable.
This holds a variable declaration node,
A Variable represents existence of a local variable.

def argument? 

def argument?
  ARGUMENT_DECLARATION_TYPES.include?(@declaration_node.type)
end

def assign(node) 

def assign(node)
  @assignments << Assignment.new(node, self)
end

def block_argument? 

def block_argument?
  argument? && @scope.node.block_type?
end

def capture_with_block! 

def capture_with_block!
  @captured_by_block = true
end

def explicit_block_local_variable? 

def explicit_block_local_variable?
  @declaration_node.shadowarg_type?
end

def initialize(name, declaration_node, scope) 

def initialize(name, declaration_node, scope)
  unless VARIABLE_DECLARATION_TYPES.include?(declaration_node.type)
    raise ArgumentError,
          "Node type must be any of #{VARIABLE_DECLARATION_TYPES}, " \
          "passed #{declaration_node.type}"
  end
  @name = name.to_sym
  @declaration_node = declaration_node
  @scope = scope
  @assignments = []
  @references = []
  @captured_by_block = false
end

def keyword_argument? 

def keyword_argument?
  [:kwarg, :kwoptarg].include?(@declaration_node.type)
end

def method_argument? 

def method_argument?
  argument? && [:def, :defs].include?(@scope.node.type)
end

def reference!(node) 

def reference!(node)
  reference = Reference.new(node, @scope)
  @references << reference
  consumed_branch_ids = Set.new
  @assignments.reverse_each do |assignment|
    next if consumed_branch_ids.include?(assignment.branch_id)
    unless assignment.run_exclusively_with?(reference)
      assignment.reference!
    end
    break unless assignment.inside_of_branch?
    break if assignment.branch_id == reference.branch_id
    next if assignment.reference_penetrable?
    consumed_branch_ids << assignment.branch_id
  end
end

def referenced? 

def referenced?
  !@references.empty?
end

def should_be_unused? 

def should_be_unused?
  name.to_s.start_with?('_')
end

def used?

So we consider it's used to suppress false positive offenses.
and it means we cannot track the usage of the variable.
when, where and how many times the block would be invoked
Once the variable is captured by a block, we have no idea

For more precise usage check, refer Assignment#used?.
in its entire variable lifetime.
This is a convenient way to check whether the variable is used 
def used?
  @captured_by_block || referenced?
end