class RuboCop::Cop::Lint::UnneededSplatExpansion

end
baz
else
bar
when 1, 2, 3
case foo
end
bar
rescue StandardError, ApplicationError
foo
begin
a = [‘a’]
a = *1..10
a, *b = *c
a, b = *c
a = *c
c = [1, 2, 3]
# good
@example
end
baz
else
bar
when *[1, 2, 3]
case foo
end
bar
rescue *[StandardError, ApplicationError]
foo
begin
a = *1
a = *‘a’
a = *[1, 2, 3]
# bad
@example
This cop checks for unneeded usages of splat expansion

def array_new_inside_array_literal?(array_new_node) 

def array_new_inside_array_literal?(array_new_node)
  return false unless array_new?(array_new_node)
  grandparent = array_new_node.parent.parent
  grandparent.array_type? && grandparent.children.size > 1
end

def array_splat?(node) 

def array_splat?(node)
  node.children.first.array_type?
end

def autocorrect(node) 

def autocorrect(node)
  range, content = replacement_range_and_content(node)
  lambda do |corrector|
    corrector.replace(range, content)
  end
end

def method_argument?(node) 

def method_argument?(node)
  node.parent.send_type?
end

def on_splat(node) 

def on_splat(node)
  unneeded_splat_expansion(node) do
    if array_splat?(node) &&
       (method_argument?(node) || part_of_an_array?(node))
      add_offense(node, message: ARRAY_PARAM_MSG)
    else
      add_offense(node)
    end
  end
end

def part_of_an_array?(node) 

def part_of_an_array?(node)
  # The parent of a splat expansion is an array that does not have
  # `begin` or `end`
  parent = node.parent
  parent.array_type? && parent.loc.begin && parent.loc.end
end

def remove_brackets(array) 

def remove_brackets(array)
  array_start = array.loc.begin.source
  elements = *array
  elements = elements.map(&:source)
  if array_start.start_with?(PERCENT_W)
    "'#{elements.join("', '")}'"
  elsif array_start.start_with?(PERCENT_CAPITAL_W)
    %("#{elements.join('", "')}")
  elsif array_start.start_with?(PERCENT_I)
    ":#{elements.join(', :')}"
  elsif array_start.start_with?(PERCENT_CAPITAL_I)
    %(:"#{elements.join('", :"')}")
  else
    elements.join(', ')
  end
end

def replacement_range_and_content(node) 

def replacement_range_and_content(node)
  variable, = *node
  loc = node.loc
  if array_new?(variable)
    [node.parent.loc.expression, variable.source]
  elsif !variable.array_type?
    [loc.expression, "[#{variable.source}]"]
  elsif unneeded_brackets?(node)
    [loc.expression, remove_brackets(variable)]
  else
    [loc.operator, '']
  end
end

def unneeded_brackets?(node) 

def unneeded_brackets?(node)
  parent = node.parent
  grandparent = node.parent.parent
  parent.when_type? || parent.send_type? || part_of_an_array?(node) ||
    (grandparent && grandparent.resbody_type?)
end

def unneeded_splat_expansion(node) 

def unneeded_splat_expansion(node)
  literal_expansion(node) do |expanded_item|
    if expanded_item.send_type?
      return if array_new_inside_array_literal?(expanded_item)
      grandparent = node.parent.parent
      return if grandparent &&
                !ASSIGNMENT_TYPES.include?(grandparent.type)
    end
    yield
  end
end