rubocop 0.12.0 → 0.13.0

data/lib/rubocop/cop/style/symbol_array.rb

@@ -22,7 +22,7 @@ module Rubocop
 
             symbol_array = array_elems.all? { |e| e.type == :sym }
 
-            add_offence(:convention, node.loc.expression, MSG) if symbol_array
+            convention(node, :expression) if symbol_array
           end
         end
       end

data/lib/rubocop/cop/style/symbol_name.rb

@@ -5,13 +5,19 @@ module Rubocop
     module Style
       # This cop checks whether symbol names are snake_case.
       # There's also an option to accept CamelCase symbol names as well.
+      # There's also an option to accept symbol names with dots as well.
       class SymbolName < Cop
         MSG = 'Use snake_case for symbols.'
         SNAKE_CASE = /^[\da-z_]+[!?=]?$/
+        SNAKE_CASE_WITH_DOTS = /^[\da-z_\.]+[!?=]?$/
         CAMEL_CASE = /^[A-Z][A-Za-z\d]*$/
 
         def allow_camel_case?
-          self.class.config['AllowCamelCase']
+          cop_config['AllowCamelCase']
+        end
+
+        def allow_dots?
+          cop_config['AllowDots']
         end
 
         def on_send(node)
@@ -30,7 +36,8 @@ module Rubocop
           return unless sym_name =~ /^[a-zA-Z]/
           return if sym_name =~ SNAKE_CASE
           return if allow_camel_case? && sym_name =~ CAMEL_CASE
-          add_offence(:convention, node.loc.expression, MSG)
+          return if allow_dots? && sym_name =~ SNAKE_CASE_WITH_DOTS
+          convention(node, :expression)
         end
       end
     end

data/lib/rubocop/cop/style/tab.rb

@@ -12,11 +12,11 @@ module Rubocop
             match = line.match(/^( *)\t/)
             if match
               spaces = match.captures[0]
-              add_offence(:convention,
-                          source_range(processed_source.buffer,
-                                       processed_source[0...index],
-                                       spaces.length, 8),
-                          MSG)
+              convention(nil,
+                         source_range(processed_source.buffer,
+                                      processed_source[0...index],
+                                      spaces.length, 8),
+                         MSG)
             end
           end
         end

data/lib/rubocop/cop/style/ternary_operator.rb

@@ -14,9 +14,7 @@ module Rubocop
           # discard non-ternary ops
           return unless loc.respond_to?(:question)
 
-          if loc.line != loc.colon.line
-            add_offence(:convention, loc.expression, MSG)
-          end
+          convention(node, :expression) if loc.line != loc.colon.line
         end
       end
 
@@ -33,9 +31,7 @@ module Rubocop
 
           node.children.each do |child|
             on_node(:if, child) do |c|
-              if c.loc.respond_to?(:question)
-                add_offence(:convention, c.loc.expression, MSG)
-              end
+              convention(c, :expression) if c.loc.respond_to?(:question)
             end
           end
         end

data/lib/rubocop/cop/style/trailing_blank_lines.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop looks for trailing blank lines in the source code.
+      class TrailingBlankLines < Cop
+        MSG = '%d trailing blank lines detected.'
+
+        def investigate(processed_source)
+          blank_lines = 0
+
+          processed_source.lines.reverse_each do |line|
+            if line.blank?
+              blank_lines += 1
+            else
+              break
+            end
+          end
+
+          if blank_lines > 0
+            convention(nil,
+                       source_range(processed_source.buffer,
+                                    processed_source[0...-blank_lines],
+                                    0, 1),
+                       format(MSG, blank_lines))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/trailing_whitespace.rb

@@ -10,12 +10,11 @@ module Rubocop
         def investigate(processed_source)
           processed_source.lines.each_with_index do |line, index|
             if line =~ /.*[ \t]+$/
-              add_offence(:convention,
-                          source_range(processed_source.buffer,
-                                       processed_source[0...index],
-                                       line.rstrip.length,
-                                       line.length - line.rstrip.length),
-                          MSG)
+              convention(nil,
+                         source_range(processed_source.buffer,
+                                      processed_source[0...index],
+                                      line.rstrip.length,
+                                      line.length - line.rstrip.length))
             end
           end
         end

data/lib/rubocop/cop/style/trivial_accessors.rb

@@ -29,22 +29,22 @@ module Rubocop
                    'writer'
                  end
           if kind
-            add_offence(:convention, node.loc.keyword,
-                        sprintf(MSG, kind, kind))
+            convention(node, :keyword,
+                       sprintf(MSG, kind, kind))
           end
 
         end
 
         def exact_name_match?
-          TrivialAccessors.config['ExactNameMatch']
+          cop_config['ExactNameMatch']
         end
 
         def allow_predicates?
-          TrivialAccessors.config['AllowPredicates']
+          cop_config['AllowPredicates']
         end
 
         def whitelist
-          whitelist = TrivialAccessors.config['Whitelist']
+          whitelist = cop_config['Whitelist']
           Array(whitelist).map(&:to_sym) + [:initialize]
         end
 

data/lib/rubocop/cop/style/unless_else.rb

@@ -15,7 +15,7 @@ module Rubocop
           return unless loc.respond_to?(:keyword) && loc.respond_to?(:else)
 
           if loc.keyword.is?('unless') && loc.else
-            add_offence(:convention, loc.expression, MSG)
+            convention(node, :expression)
           end
         end
       end

data/lib/rubocop/cop/style/variable_interpolation.rb

@@ -12,9 +12,7 @@ module Rubocop
             var = (v.type == :nth_ref ? '$' : '') + v.to_a[0].to_s
 
             if node.loc.expression.source.include?("##{var}")
-              add_offence(:convention,
-                          v.loc.expression,
-                          sprintf(MSG, var, var))
+              convention(v, :expression, sprintf(MSG, var, var))
             end
           end
         end

data/lib/rubocop/cop/style/when_then.rb

@@ -8,10 +8,7 @@ module Rubocop
         MSG = 'Never use "when x;". Use "when x then" instead.'
 
         def on_when(node)
-          if node.loc.begin && node.loc.begin.is?(';')
-            add_offence(:convention, node.loc.begin, MSG)
-            do_autocorrect(node)
-          end
+          convention(node, :begin) if node.loc.begin && node.loc.begin.is?(';')
         end
 
         def autocorrect_action(node)

data/lib/rubocop/cop/style/while_until_do.rb

@@ -18,10 +18,8 @@ module Rubocop
 
           if length > 1
             if node.loc.begin && node.loc.begin.is?('do')
-              add_offence(:convention,
-                          node.loc.begin,
-                          error_message(node.type))
-              do_autocorrect(node)
+              convention(node, :begin,
+                         error_message(node.type))
             end
           end
         end
@@ -34,7 +32,11 @@ module Rubocop
 
         def autocorrect_action(node)
           @corrections << lambda do |corrector|
-            corrector.remove(node.loc.begin)
+            condition_node, = *node
+            end_of_condition_range = condition_node.loc.expression.end
+            do_range = node.loc.begin
+            whitespaces_and_do_range = end_of_condition_range.join(do_range)
+            corrector.remove(whitespaces_and_do_range)
           end
         end
       end

data/lib/rubocop/cop/style/word_array.rb

@@ -19,7 +19,7 @@ module Rubocop
           string_array = array_elems.all? { |e| e.type == :str }
 
           if string_array && !complex_content?(array_elems)
-            add_offence(:convention, node.loc.expression, MSG)
+            convention(node, :expression)
           end
         end
 

data/lib/rubocop/cop/team.rb

@@ -0,0 +1,100 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    # FIXME
+    class Team
+      attr_reader :errors
+
+      def initialize(cop_classes, config, options = nil)
+        @cop_classes = cop_classes
+        @config = config
+        @options = options || { autocorrect: false, debug: false }
+        @errors = []
+      end
+
+      def autocorrect?
+        @options[:autocorrect]
+      end
+
+      def debug?
+        @options[:debug]
+      end
+
+      def inspect_file(file)
+        begin
+          processed_source = SourceParser.parse_file(file)
+        rescue Encoding::UndefinedConversionError, ArgumentError => e
+          handle_error(e,
+                       "An error occurred while parsing #{file}.".color(:red))
+          return []
+        end
+
+        offences = processed_source.diagnostics.map do |diagnostic|
+          Offence.from_diagnostic(diagnostic)
+        end
+
+        # If we got any syntax errors, return only the syntax offences.
+        # Parser may return nil for AST even though there are no syntax errors.
+        # e.g. sources which contain only comments
+        if offences.any? { |o| [:error, :fatal].include?(o.severity) }
+          return offences
+        end
+
+        commissioner = Commissioner.new(cops)
+        offences += commissioner.investigate(processed_source)
+        process_commissioner_errors(file, commissioner.errors)
+        autocorrect(processed_source.buffer, cops)
+        offences.sort
+      end
+
+      def cops
+        @cops ||= begin
+          @cop_classes.reduce([]) do |instances, cop_class|
+            next instances unless @config.cop_enabled?(cop_class)
+            instances << cop_class.new(@config, @options)
+          end
+        end
+      end
+
+      private
+
+      def autocorrect(buffer, cops)
+        return unless autocorrect?
+
+        corrections = cops.reduce([]) do |array, cop|
+          array.concat(cop.corrections)
+          array
+        end
+
+        corrector = Corrector.new(buffer, corrections)
+        new_source = corrector.rewrite
+
+        unless new_source == buffer.source
+          filename = buffer.name
+          File.open(filename, 'w') { |f| f.write(new_source) }
+        end
+      end
+
+      def process_commissioner_errors(file, file_errors)
+        file_errors.each do |cop, errors|
+          errors.each do |e|
+            handle_error(e,
+                         "An error occurred while #{cop.name}".color(:red) +
+                         " cop was inspecting #{file}.".color(:red))
+          end
+        end
+      end
+
+      def handle_error(e, message)
+        @errors << message
+        warn message
+        if debug?
+          puts e.message, e.backtrace
+        else
+          warn 'To see the complete backtrace run rubocop -d.'
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/variable_inspector.rb

@@ -6,296 +6,320 @@ module Rubocop
     # This is intended to be used as mix-in, and the user class may override
     # some of hook methods.
     module VariableInspector
-      VARIABLE_ASSIGNMENT_TYPES = [:lvasgn, :match_with_lvasgn].freeze
-      ARGUMENT_DECLARATION_TYPES = [
-        :arg, :optarg, :restarg, :blockarg,
-        :kwarg, :kwoptarg, :kwrestarg,
-        :shadowarg
+      VARIABLE_ASSIGNMENT_TYPE = :lvasgn
+      REGEXP_NAMED_CAPTURE_TYPE = :match_with_lvasgn
+      VARIABLE_ASSIGNMENT_TYPES =
+        [VARIABLE_ASSIGNMENT_TYPE, REGEXP_NAMED_CAPTURE_TYPE].freeze
+
+      METHOD_ARGUMENT_DECLARATION_TYPES = [
+        :arg, :optarg, :restarg,
+        :kwarg, :kwoptarg, :kwrestarg
       ].freeze
-      VARIABLE_DECLARATION_TYPES =
-        (VARIABLE_ASSIGNMENT_TYPES + ARGUMENT_DECLARATION_TYPES).freeze
-      VARIABLE_USE_TYPES = [:lvar].freeze
-      SCOPE_TYPES = [:module, :class, :sclass, :def, :defs, :block].freeze
-
-      # A VariableEntry represents existance of a local variable.
-      # This holds a variable declaration node,
-      # and some states of the variable.
-      class VariableEntry
-        attr_reader :node
-        attr_accessor :used
-        alias_method :used?, :used
-
-        def initialize(node, name = nil)
-          unless VARIABLE_DECLARATION_TYPES.include?(node.type)
-            fail ArgumentError,
-                 "Node type must be any of #{VARIABLE_DECLARATION_TYPES}, " +
-                 "passed #{node.type}"
-          end
-          @node = node
-          @name = name.to_sym if name
-          @used = false
-        end
+      BLOCK_ARGUMENT_DECLARATION_TYPE = :blockarg
+      ARGUMENT_DECLARATION_TYPES = (
+        METHOD_ARGUMENT_DECLARATION_TYPES + [BLOCK_ARGUMENT_DECLARATION_TYPE]
+      ).freeze
+      BLOCK_LOCAL_VARIABLE_DECLARATION_TYPE = :shadowarg
+      DECLARATION_TYPES = (
+        ARGUMENT_DECLARATION_TYPES + [BLOCK_LOCAL_VARIABLE_DECLARATION_TYPE]
+      ).freeze
 
-        def name
-          @name || @node.children.first
-        end
+      LOGICAL_OPERATOR_ASSIGNMENT_TYPES = [:or_asgn, :and_asgn].freeze
+      OPERATOR_ASSIGNMENT_TYPES =
+        (LOGICAL_OPERATOR_ASSIGNMENT_TYPES + [:op_asgn]).freeze
+
+      MULTIPLE_ASSIGNMENT_TYPE = :masgn
+
+      VARIABLE_REFERENCE_TYPE = :lvar
+
+      POST_CONDITION_LOOP_TYPES = [:while_post, :until_post].freeze
+      LOOP_TYPES = (POST_CONDITION_LOOP_TYPES + [:while, :until, :for]).freeze
+
+      RESCUE_TYPE = :rescue
+
+      ZERO_ARITY_SUPER_TYPE = :zsuper
+
+      TWISTED_SCOPE_TYPES = [:block, :class, :sclass, :defs].freeze
+      SCOPE_TYPES = (TWISTED_SCOPE_TYPES + [:module, :def]).freeze
+
+      def variable_table
+        @variable_table ||= VariableTable.new(self)
       end
 
-      # A Scope represents a context of local variable visibility.
-      # This is a place where local variables belong to.
-      # A scope instance holds a scope node and variable entries.
-      class Scope
-        attr_reader :node, :variable_entries
-
-        def initialize(node)
-          # Accept begin node for top level scope.
-          unless SCOPE_TYPES.include?(node.type) || node.type == :begin
-            fail ArgumentError,
-                 "Node type must be any of #{SCOPE_TYPES}, " +
-                 "passed #{node.type}"
-          end
-          @node = node
-          @variable_entries = {}
+      # Starting point.
+      def inspect_variables(root_node)
+        return unless root_node
+
+        # Wrap with begin node if it's standalone node.
+        unless root_node.type == :begin
+          root_node = Parser::AST::Node.new(:begin, [root_node])
         end
+
+        inspect_variables_in_scope(root_node)
       end
 
-      # A VariableTable manages the lifetime of all scopes and local variables
-      # in a program.
-      # This holds scopes as stack structure, and provides a way to add local
-      # variables to current scope and find local variables by considering
-      # variable visibility of the current scope.
-      class VariableTable
-        def initialize(hook_receiver = nil)
-          @hook_receiver = hook_receiver
-        end
+      # This is called for each scope recursively.
+      def inspect_variables_in_scope(scope_node)
+        variable_table.push_scope(scope_node)
+        process_children(scope_node)
+        variable_table.pop_scope
+      end
 
-        def invoke_hook(hook_name, *args)
-          @hook_receiver.send(hook_name, *args) if @hook_receiver
+      def process_children(origin_node)
+        origin_node.children.each do |child|
+          next unless child.is_a?(Parser::AST::Node)
+          next if scanned_node?(child)
+          process_node(child)
         end
+      end
 
-        def scope_stack
-          @scope_stack ||= []
+      def process_node(node)
+        catch(:skip_children) do
+          dispatch_node(node)
+          process_children(node)
         end
+      end
 
-        def push_scope(scope_node)
-          scope = Scope.new(scope_node)
-          invoke_hook(:before_entering_scope, scope)
-          scope_stack.push(scope)
-          invoke_hook(:after_entering_scope, scope)
-          scope
-        end
+      def skip_children!
+        throw :skip_children
+      end
 
-        def pop_scope
-          scope = current_scope
-          invoke_hook(:before_leaving_scope, scope)
-          scope_stack.pop
-          invoke_hook(:after_leaving_scope, scope)
-          scope
+      def dispatch_node(node)
+        case node.type
+        when *DECLARATION_TYPES
+          process_variable_declaration(node)
+        when VARIABLE_ASSIGNMENT_TYPE
+          process_variable_assignment(node)
+        when REGEXP_NAMED_CAPTURE_TYPE
+          process_regexp_named_captures(node)
+        when *OPERATOR_ASSIGNMENT_TYPES
+          process_variable_operator_assignment(node)
+        when MULTIPLE_ASSIGNMENT_TYPE
+          process_variable_multiple_assignment(node)
+        when VARIABLE_REFERENCE_TYPE
+          process_variable_referencing(node)
+        when *LOOP_TYPES
+          process_loop(node)
+        when RESCUE_TYPE
+          process_rescue(node)
+        when ZERO_ARITY_SUPER_TYPE
+          process_zero_arity_super(node)
+        when *SCOPE_TYPES
+          process_scope(node)
         end
+      end
 
-        def current_scope
-          scope_stack.last
-        end
+      def process_variable_declaration(node)
+        # restarg would have no name:
+        #
+        #   def initialize(*)
+        #   end
+        return if node.type == :restarg && node.children.empty?
 
-        def current_scope_level
-          scope_stack.count
-        end
+        variable_name = node.children.first
+        variable_table.declare_variable(variable_name, node)
+      end
 
-        def add_variable_entry(variable_declaration_node, name = nil)
-          entry = VariableEntry.new(variable_declaration_node, name)
-          invoke_hook(:before_declaring_variable, entry)
-          current_scope.variable_entries[entry.name] = entry
-          invoke_hook(:after_declaring_variable, entry)
-          entry
-        end
+      def process_variable_assignment(node)
+        name = node.children.first
 
-        def find_variable_entry(variable_name)
-          scope_stack.reverse_each do |scope|
-            entry = scope.variable_entries[variable_name]
-            return entry if entry
-            # Only block scope allows referencing outer scope variables.
-            return nil unless scope.node.type == :block
-          end
-          nil
+        unless variable_table.variable_exist?(name)
+          variable_table.declare_variable(name, node)
         end
+
+        # Need to scan rhs before assignment so that we can mark previous
+        # assignments as referenced if rhs has referencing to the variable
+        # itself like:
+        #
+        #   foo = 1
+        #   foo = foo + 1
+        process_children(node)
+
+        variable_table.assign_to_variable(name, node)
+
+        skip_children!
       end
 
-      # This provides a way to scan all nodes only in current scope.
-      class NodeScanner
-        TWISTED_SCOPE_NODE_TYPES = [:block, :sclass, :defs].freeze
-        POST_CONDITION_LOOP_NODE_TYPES = [:while_post, :until_post].freeze
+      def process_regexp_named_captures(node)
+        regexp_node, rhs_node = *node
+
+        regexp_string = regexp_node.children[0].children[0]
+        regexp = Regexp.new(regexp_string)
+        variable_names = regexp.named_captures.keys
 
-        def self.scan_nodes_in_scope(origin_node, &block)
-          instance = new(block)
-          instance.scan_nodes_in_scope(origin_node)
+        variable_names.each do |name|
+          unless variable_table.variable_exist?(name)
+            variable_table.declare_variable(name, node)
+          end
         end
 
-        def initialize(callback)
-          @callback = callback
+        process_node(rhs_node)
+        process_node(regexp_node)
+
+        variable_names.each do |name|
+          variable_table.assign_to_variable(name, node)
         end
 
-        def scan_nodes_in_scope(origin_node, yield_origin_node = false)
-          @callback.call(origin_node) if yield_origin_node
+        skip_children!
+      end
 
-          origin_node.children.each_with_index do |child, index|
-            next unless child.is_a?(Parser::AST::Node)
-            node = child
+      def process_variable_operator_assignment(node)
+        if LOGICAL_OPERATOR_ASSIGNMENT_TYPES.include?(node.type)
+          asgn_node, rhs_node = *node
+        else
+          asgn_node, _operator, rhs_node = *node
+        end
 
-            if index == 0 &&
-               TWISTED_SCOPE_NODE_TYPES.include?(origin_node.type)
-              next
-            end
+        return unless asgn_node.type == :lvasgn
 
-            @callback.call(node)
+        name = asgn_node.children.first
 
-            scan_children(node)
-          end
+        unless variable_table.variable_exist?(name)
+          variable_table.declare_variable(name, asgn_node)
         end
 
-        def scan_children(node)
-          case node.type
-          when *POST_CONDITION_LOOP_NODE_TYPES
-            # Loop body nodes need to be scanned first.
-            #
-            # Ruby:
-            #   begin
-            #     foo = 1
-            #   end while foo > 10
-            #   puts foo
-            #
-            # AST:
-            #   (begin
-            #     (while-post
-            #       (send
-            #         (lvar :foo) :>
-            #         (int 10))
-            #       (kwbegin
-            #         (lvasgn :foo
-            #           (int 1))))
-            #     (send nil :puts
-            #       (lvar :foo)))
-            scan_nodes_in_scope(node.children[1], true)
-            scan_nodes_in_scope(node.children[0], true)
-          when *TWISTED_SCOPE_NODE_TYPES
-            # The variable foo belongs to the top level scope,
-            # but in AST, it's under the block node.
-            #
-            # Ruby:
-            #   some_method(foo = 1) do
-            #   end
-            #   puts foo
-            #
-            # AST:
-            #   (begin
-            #     (block
-            #       (send nil :some_method
-            #         (lvasgn :foo
-            #           (int 1)))
-            #       (args) nil)
-            #     (send nil :puts
-            #       (lvar :foo)))
-            #
-            # So the the method argument nodes need to be processed
-            # in current scope.
-            #
-            # Same thing.
-            #
-            # Ruby:
-            #   instance = Object.new
-            #   class << instance
-            #     foo = 1
-            #   end
-            #
-            # AST:
-            #   (begin
-            #     (lvasgn :instance
-            #       (send
-            #         (const nil :Object) :new))
-            #     (sclass
-            #       (lvar :instance)
-            #       (begin
-            #         (lvasgn :foo
-            #           (int 1))
-            scan_nodes_in_scope(node.children.first, true)
-          when *SCOPE_TYPES
-            # Do not go into inner scope.
-          else
-            scan_nodes_in_scope(node)
-          end
-        end
+        # The following statements:
+        #
+        #   foo = 1
+        #   foo += foo = 2
+        #   # => 3
+        #
+        # are equivalent to:
+        #
+        #   foo = 1
+        #   foo = foo + (foo = 2)
+        #   # => 3
+        #
+        # So, at operator assignment node, we need to reference the variable
+        # before processing rhs nodes.
+
+        variable_table.reference_variable(name, node)
+        process_node(rhs_node)
+        variable_table.assign_to_variable(name, asgn_node)
+
+        skip_children!
       end
 
-      def variable_table
-        @variable_table ||= VariableTable.new(self)
+      def process_variable_multiple_assignment(node)
+        lhs_node, rhs_node = *node
+        process_node(rhs_node)
+        process_node(lhs_node)
+        skip_children!
       end
 
-      # Starting point.
-      def inspect_variables(root_node)
-        return unless root_node
+      def process_variable_referencing(node)
+        name = node.children.first
+        variable_table.reference_variable(name, node)
+      end
 
-        # Wrap with begin node if it's standalone node.
-        unless root_node.type == :begin
-          root_node = Parser::AST::Node.new(:begin, [root_node])
+      def process_loop(node)
+        if POST_CONDITION_LOOP_TYPES.include?(node.type)
+          # See the comment at the end of file for this behavior.
+          condition_node, body_node = *node
+          process_node(body_node)
+          process_node(condition_node)
+        else
+          process_children(node)
         end
 
-        inspect_variables_in_scope(root_node)
+        mark_assignments_as_referenced_in_loop(node)
+
+        skip_children!
       end
 
-      # This is called for each scope recursively.
-      def inspect_variables_in_scope(scope_node)
-        variable_table.push_scope(scope_node)
+      def process_rescue(node)
+        resbody_nodes = node.children.select do |child|
+          next false unless child.is_a?(Parser::AST::Node)
+          child.type == :resbody
+        end
 
-        NodeScanner.scan_nodes_in_scope(scope_node) do |node|
-          # puts "scope:#{variable_table.current_scope_level} node:#{node}"
-          process_node(node)
+        contain_retry = resbody_nodes.any? do |resbody_node|
+          scan(resbody_node) do |node_in_resbody|
+            break true if node_in_resbody.type == :retry
+          end
         end
 
-        variable_table.pop_scope
+        # Treat begin..rescue..end with retry as a loop.
+        process_loop(node) if contain_retry
       end
 
-      def process_node(node)
-        case node.type
-        when *ARGUMENT_DECLARATION_TYPES
-          variable_table.add_variable_entry(node)
-        when :lvasgn
-          variable_name = node.children.first
-          process_variable_assignment(node, variable_name)
-        when :match_with_lvasgn
-          process_named_captures(node)
-        when *VARIABLE_USE_TYPES
-          variable_name = node.children.first
-          variable_entry = variable_table.find_variable_entry(variable_name)
-          unless variable_entry
-            fail "Using undeclared local variable \"#{variable_name}\" " +
-                 "at #{node.loc.expression}, #{node.inspect}"
+      def process_zero_arity_super(node)
+        variable_table.accessible_variables.each do |variable|
+          next unless variable.method_argument?
+          variable.reference!(node)
+        end
+      end
+
+      def process_scope(node)
+        if TWISTED_SCOPE_TYPES.include?(node.type)
+          # See the comment at the end of file for this behavior.
+          twisted_nodes = [node.children[0]]
+          twisted_nodes << node.children[1] if node.type == :class
+          twisted_nodes.compact!
+
+          twisted_nodes.each do |twisted_node|
+            process_node(twisted_node)
+            scanned_nodes << twisted_node
           end
-          variable_entry.used = true
-        when *SCOPE_TYPES
-          inspect_variables_in_scope(node)
         end
+
+        inspect_variables_in_scope(node)
+        skip_children!
       end
 
-      def process_variable_assignment(node, name)
-        entry = variable_table.find_variable_entry(name)
-        if entry
-          entry.used = true
-        else
-          variable_table.add_variable_entry(node, name)
+      # Mark all assignments which are referenced in the same loop
+      # as referenced by ignoring AST order since they would be referenced
+      # in next iteration.
+      def mark_assignments_as_referenced_in_loop(node)
+        referenced_variable_names_in_loop = []
+        assignment_nodes_in_loop = []
+
+        # #scan does not consider scope,
+        # but we don't need to care about it here.
+        scan(node) do |scanning_node|
+          case scanning_node.type
+          when :lvar
+            referenced_variable_names_in_loop << scanning_node.children.first
+          when :lvasgn
+            assignment_nodes_in_loop << scanning_node
+          end
+        end
+
+        referenced_variable_names_in_loop.each do |name|
+          variable = variable_table.find_variable(name)
+          # Non related references which are catched in the above scan
+          # would be skipped here.
+          next unless variable
+          variable.assignments.each do |assignment|
+            next if assignment_nodes_in_loop.none? do |assignment_node|
+                      assignment_node.equal?(assignment.node)
+                    end
+            assignment.reference!
+          end
         end
       end
 
-      def process_named_captures(match_with_lvasgn_node)
-        regexp_string = match_with_lvasgn_node.children[0]
-                                              .children[0]
-                                              .children[0]
-        regexp = Regexp.new(regexp_string)
-        variable_names = regexp.named_captures.keys
+      # Simple recursive scan
+      def scan(node, &block)
+        node.children.each do |child|
+          next unless child.is_a?(Parser::AST::Node)
+          yield child
+          scan(child, &block)
+        end
+        nil
+      end
 
-        variable_names.each do |name|
-          process_variable_assignment(match_with_lvasgn_node, name)
+      # Use Node#equal? for accurate check.
+      def scanned_node?(node)
+        scanned_nodes.any? do |scanned_node|
+          scanned_node.equal?(node)
         end
       end
 
+      def scanned_nodes
+        @scanned_nodes ||= []
+      end
+
       # Hooks
 
       def before_entering_scope(scope)
@@ -310,11 +334,75 @@ module Rubocop
       def after_leaving_scope(scope)
       end
 
-      def before_declaring_variable(variable_entry)
+      def before_declaring_variable(variable_variable)
       end
 
-      def after_declaring_variable(variable_entry)
+      def after_declaring_variable(variable_variable)
       end
+
+      # Post condition loops
+      #
+      # Loop body nodes need to be scanned first.
+      #
+      # Ruby:
+      #   begin
+      #     foo = 1
+      #   end while foo > 10
+      #   puts foo
+      #
+      # AST:
+      #   (begin
+      #     (while-post
+      #       (send
+      #         (lvar :foo) :>
+      #         (int 10))
+      #       (kwbegin
+      #         (lvasgn :foo
+      #           (int 1))))
+      #     (send nil :puts
+      #       (lvar :foo)))
+
+      # Twisted scope types
+      #
+      # The variable foo belongs to the top level scope,
+      # but in AST, it's under the block node.
+      #
+      # Ruby:
+      #   some_method(foo = 1) do
+      #   end
+      #   puts foo
+      #
+      # AST:
+      #   (begin
+      #     (block
+      #       (send nil :some_method
+      #         (lvasgn :foo
+      #           (int 1)))
+      #       (args) nil)
+      #     (send nil :puts
+      #       (lvar :foo)))
+      #
+      # So the the method argument nodes need to be processed
+      # in current scope.
+      #
+      # Same thing.
+      #
+      # Ruby:
+      #   instance = Object.new
+      #   class << instance
+      #     foo = 1
+      #   end
+      #
+      # AST:
+      #   (begin
+      #     (lvasgn :instance
+      #       (send
+      #         (const nil :Object) :new))
+      #     (sclass
+      #       (lvar :instance)
+      #       (begin
+      #         (lvasgn :foo
+      #           (int 1))
     end
   end
 end