adlint 1.8.2 → 1.8.10

data/lib/adlint/c/format.rb

@@ -765,15 +765,15 @@ module C #:nodoc:
       # Boolean -- True if types of arguments match this directive.
       def acceptable?
         if @field_width_argument
-          unless @field_width_argument.type.same_as?(signed_int_type) ||
-              @field_width_argument.type.same_as?(unsigned_int_type)
+          unless signed_int_type.same_as?(@field_width_argument.type) ||
+              unsigned_int_type.same_as?(@field_width_argument.type)
             return false
           end
         end
 
         if @precision_argument
-          unless @precision_argument.type.same_as?(signed_int_type) ||
-              @precision_argument.type.same_as?(unsigned_int_type)
+          unless signed_int_type.same_as?(@precision_argument.type) ||
+              unsigned_int_type.same_as?(@precision_argument.type)
             return false
           end
         end
@@ -781,7 +781,7 @@ module C #:nodoc:
         if @conversion_argument
           if argument_types
             argument_types.any? do |arg_type|
-              @conversion_argument.type.same_as?(arg_type)
+              arg_type.same_as?(@conversion_argument.type)
             end
           else
             true
@@ -2502,7 +2502,7 @@ module C #:nodoc:
         if @conversion_argument
           if argument_types
             argument_types.any? do |arg_type|
-              @conversion_argument.type.same_as?(arg_type)
+              arg_type.same_as?(@conversion_argument.type)
             end
           else
             true

data/lib/adlint/c/message.rb

@@ -1156,72 +1156,31 @@ module C #:nodoc:
   class W0051 < PassiveMessageDetection
     def initialize(context)
       super
-      visitor = context[:c_visitor]
-      visitor.enter_compound_statement += method(:enter_compound_statement)
-      visitor.leave_compound_statement += method(:leave_compound_statement)
-      visitor.enter_variable_declaration += method(:add_variable_decl)
-      visitor.enter_variable_definition += method(:add_variable_def)
-      visitor.enter_function_declaration += method(:add_function_decl)
-      visitor.enter_ansi_function_definition += method(:add_function_def)
-      visitor.enter_kandr_function_definition += method(:add_function_def)
-      visitor.leave_translation_unit += method(:check)
-      @block_level = 0
+      interp = context[:c_interpreter]
+      interp.on_variable_declared += method(:add_variable)
+      interp.on_variable_defined += method(:add_variable)
+      interp.on_function_declared += method(:add_function)
+      interp.on_function_started += method(:add_function)
+      interp.on_translation_unit_ended += method(:check)
       @identifiers = Hash.new { |hash, key| hash[key] = [] }
     end
 
     private
-    def enter_compound_statement(node)
-      @block_level += 1
-    end
-
-    def leave_compound_statement(node)
-      @block_level -= 1
-    end
-
-    def add_variable_decl(node)
-      if @block_level == 0 && node.storage_class_specifier &&
-          node.storage_class_specifier.type == :EXTERN
-        @identifiers[mangle(node.identifier.value)].push(
-          [node.identifier, true])
-      else
-        @identifiers[mangle(node.identifier.value)].push(
-          [node.identifier, false])
-      end
-    end
-
-    def add_variable_def(node)
-      if @block_level == 0 && node.storage_class_specifier.nil?
-        @identifiers[mangle(node.identifier.value)].push(
-          [node.identifier, true])
-      else
-        @identifiers[mangle(node.identifier.value)].push(
-          [node.identifier, false])
-      end
-    end
-
-    def add_function_decl(node)
-      if node.storage_class_specifier.nil? ||
-          node.storage_class_specifier.type == :EXTERN
-        @identifiers[mangle(node.identifier.value)].push(
-          [node.identifier, true])
-      else
-        @identifiers[mangle(node.identifier.value)].push(
-          [node.identifier, false])
+    def add_variable(decl_or_def, variable)
+      if variable.named?
+        @identifiers[mangle(variable.name)].push(
+          [decl_or_def.identifier, variable.declared_as_extern?])
       end
     end
 
-    def add_function_def(node)
-      if node.storage_class_specifier.nil? ||
-          node.storage_class_specifier.type == :EXTERN
-        @identifiers[mangle(node.identifier.value)].push(
-          [node.identifier, true])
-      else
-        @identifiers[mangle(node.identifier.value)].push(
-          [node.identifier, false])
+    def add_function(decl_or_def, function)
+      if function.named?
+        @identifiers[mangle(function.name)].push(
+          [decl_or_def.identifier, function.declared_as_extern?])
       end
     end
 
-    def check(node)
+    def check(*)
       @identifiers.each do |key, id_array|
         id_array.uniq! { |id| id[0].value }
         if id_array.size > 1
@@ -1578,30 +1537,29 @@ module C #:nodoc:
   class W0080 < PassiveMessageDetection
     def initialize(context)
       super
-      visitor = context[:c_visitor]
-      visitor.enter_variable_definition += method(:check)
-      visitor.enter_compound_statement += method(:enter_block)
-      visitor.leave_compound_statement += method(:leave_block)
+      interp = context[:c_interpreter]
+      interp.on_variable_defined += method(:check)
+      interp.on_block_started += method(:enter_block)
+      interp.on_block_ended += method(:leave_block)
       @block_level = 0
     end
 
     private
-    def check(node)
-      return if @block_level > 0
-
-      return if node.storage_class_specifier &&
-        node.storage_class_specifier.type == :EXTERN
-
-      if node.type.const?
-        W(:W0080, node.location) unless node.initializer
+    def check(variable_definition, variable)
+      if @block_level == 0
+        if variable.declared_as_extern? || variable.declared_as_static?
+          if variable.type.const? && variable_definition.initializer.nil?
+            W(:W0080, variable_definition.location)
+          end
+        end
       end
     end
 
-    def enter_block(node)
+    def enter_block(*)
       @block_level += 1
     end
 
-    def leave_block(node)
+    def leave_block(*)
       @block_level -= 1
     end
   end
@@ -1916,8 +1874,13 @@ module C #:nodoc:
       return unless lhs_variable.type.pointer? && rhs_variable.type.pointer?
 
       if rhs_pointee = @interp.pointee_of(rhs_variable)
-        if rhs_pointee.variable? && rhs_pointee.named? &&
-            rhs_pointee.binding.memory.dynamic?
+        if rhs_pointee.variable? && rhs_pointee.named?
+          return unless rhs_pointee.binding.memory.dynamic?
+          # NOTE: An array typed parameter can be considerd as an alias of the
+          #       corresponding argument.  So, it is safe to return an address
+          #       of the argument.
+          return if rhs_pointee.type.parameter? && rhs_pointee.type.array?
+
           case
           when lhs_variable.binding.memory.static?
             W(:W0101, assignment_expression.location)
@@ -1978,8 +1941,12 @@ module C #:nodoc:
       end
 
       if rhs_pointee = @interp.pointee_of(rhs_variable)
-        if rhs_pointee.variable? && rhs_pointee.named? &&
-            rhs_pointee.binding.memory.dynamic?
+        if rhs_pointee.variable? && rhs_pointee.named?
+          return unless rhs_pointee.binding.memory.dynamic?
+          # NOTE: An array typed parameter can be considerd as an alias of the
+          #       corresponding argument.  So, it is safe to return an address
+          #       of the argument.
+          return if rhs_pointee.type.parameter? && rhs_pointee.type.array?
           W(:W0102, assignment_expression.location)
         end
       end
@@ -2022,6 +1989,10 @@ module C #:nodoc:
 
       if pointee = @interp.pointee_of(result_variable)
         if pointee.variable? && pointee.named?
+          # NOTE: An array typed parameter can be considerd as an alias of the
+          #       corresponding argument.  So, it is safe to return an address
+          #       of the argument.
+          return if pointee.type.parameter? && pointee.type.array?
           if @local_variables.include?(pointee.name)
             W(:W0103, return_statement.location)
           end
@@ -2161,9 +2132,13 @@ module C #:nodoc:
 
       if rhs_pointee = @interp.pointee_of(rhs_variable)
         if rhs_pointee.variable? && rhs_pointee.named?
-          if lhs_variable.scope.local? &&
-              lhs_variable.binding.memory.static? &&
-              rhs_pointee.binding.memory.dynamic?
+          return unless rhs_pointee.binding.memory.dynamic?
+          # NOTE: An array typed parameter can be considerd as an alias of the
+          #       corresponding argument.  So, it is safe to return an address
+          #       of the argument.
+          return if rhs_pointee.type.parameter? && rhs_pointee.type.array?
+
+          if lhs_variable.scope.local? && lhs_variable.binding.memory.static?
             W(:W0107, assignment_expression.location)
           end
         end
@@ -2515,114 +2490,85 @@ module C #:nodoc:
   class W0117 < PassiveMessageDetection
     def initialize(context)
       super
-      visitor = context[:c_visitor]
-      visitor.enter_function_declaration += method(:declare_function)
-      visitor.enter_variable_declaration += method(:declare_variable)
-      visitor.enter_ansi_function_definition += method(:check_function)
-      visitor.enter_kandr_function_definition += method(:check_function)
-      visitor.enter_variable_definition += method(:check_variable)
-      visitor.enter_compound_statement += method(:enter_block)
-      visitor.leave_compound_statement += method(:leave_block)
+      interp = context[:c_interpreter]
+      interp.on_function_declared += method(:declare_function)
+      interp.on_variable_declared += method(:declare_variable)
+      interp.on_function_started += method(:check_function)
+      interp.on_variable_defined += method(:check_variable)
       @target_fpath = context[:sources].first.fpath
       @external_symbols = Set.new
-      @scope_depth = 0
     end
 
     private
-    def declare_function(node)
-      if external_declaration?(node)
-        unless @external_symbols.include?(node.identifier.value)
-          @external_symbols.add(node.identifier.value)
-        end
+    def declare_function(function_declaration, function)
+      if function.named? && function.declared_as_extern?
+        @external_symbols.add(function.name)
       end
     end
 
-    def declare_variable(node)
-      if external_declaration?(node)
-        unless @external_symbols.include?(node.identifier.value)
-          @external_symbols.add(node.identifier.value)
-        end
+    def declare_variable(variable_declaration, variable)
+      if variable.named? && variable.declared_as_extern?
+        @external_symbols.add(variable.name)
       end
     end
 
-    def check_function(node)
-      return if node.identifier.value == "main"
-      if external_definition?(node)
-        unless @external_symbols.include?(node.identifier.value)
-          if node.location.fpath == @target_fpath
-            W(:W0117, node.location, node.identifier.value)
+    def check_function(function_definition, function)
+      if function.named? && function.declared_as_extern?
+        return if function.name == "main"
+
+        unless @external_symbols.include?(function.name)
+          if function_definition.location.fpath == @target_fpath
+            W(:W0117, function_definition.location, function.name)
           end
         end
       end
     end
 
-    def check_variable(node)
-      if external_definition?(node)
-        unless @external_symbols.include?(node.identifier.value)
-          if node.location.fpath == @target_fpath
-            W(:W0117, node.location, node.identifier.value)
+    def check_variable(variable_definition, variable)
+      if variable.named? && variable.declared_as_extern?
+        unless @external_symbols.include?(variable.name)
+          if variable_definition.location.fpath == @target_fpath
+            W(:W0117, variable_definition.location, variable.name)
           end
         end
       end
     end
-
-    def enter_block(node)
-      @scope_depth += 1
-    end
-
-    def leave_block(node)
-      @scope_depth -= 1
-    end
-
-    def external_declaration?(node)
-      node.storage_class_specifier &&
-        node.storage_class_specifier.type == :EXTERN
-    end
-
-    def external_definition?(node)
-      (@scope_depth == 0 && node.storage_class_specifier.nil?) ||
-        (node.storage_class_specifier &&
-         node.storage_class_specifier.type == :EXTERN)
-    end
   end
 
   class W0118 < PassiveMessageDetection
     def initialize(context)
       super
-      visitor = context[:c_visitor]
-      visitor.enter_function_declaration += method(:check_function)
-      visitor.enter_variable_declaration += method(:check_variable)
+      interp = context[:c_interpreter]
+      interp.on_function_declared += method(:check_function)
+      interp.on_variable_declared += method(:check_variable)
       @target_fpath = context[:sources].first.fpath
       @external_symbols = Set.new
     end
 
     private
-    def check_function(node)
-      if external?(node)
-        unless @external_symbols.include?(node.identifier.value)
-          if node.location.fpath == @target_fpath
-            W(:W0118, node.location, node.identifier.value)
+    def check_function(function_declaration, function)
+      if function.named? && function.declared_as_extern?
+        unless @external_symbols.include?(function.name)
+          if function_declaration.location.fpath == @target_fpath
+            W(:W0118, function_declaration.location, function.name)
+          else
+            @external_symbols.add(function.name)
           end
-          @external_symbols.add(node.identifier.value)
         end
       end
     end
 
-    def check_variable(node)
-      if external?(node)
-        unless @external_symbols.include?(node.identifier.value)
-          if node.location.fpath == @target_fpath
-            W(:W0118, node.location, node.identifier.value)
+    def check_variable(variable_declaration, variable)
+      if variable.named? && variable.declared_as_extern?
+        unless @external_symbols.include?(variable.name)
+          if variable_declaration.location.fpath == @target_fpath
+            W(:W0118, variable_declaration.location, variable.name)
+          else
+            @external_symbols.add(variable.name)
           end
-          @external_symbols.add(node.identifier.value)
         end
       end
     end
-
-    def external?(node)
-      node.storage_class_specifier &&
-        node.storage_class_specifier.type == :EXTERN
-    end
   end
 
   class W0119 < PassiveMessageDetection
@@ -6920,42 +6866,28 @@ module C #:nodoc:
   class W0456 < PassiveMessageDetection
     def initialize(context)
       super
-      visitor = context[:c_visitor]
-      visitor.enter_variable_definition += method(:check_variable)
-      visitor.enter_ansi_function_definition += method(:check_function)
-      visitor.enter_kandr_function_definition += method(:check_function)
-      visitor.enter_compound_statement += method(:enter_block)
-      visitor.leave_compound_statement += method(:leave_block)
+      interp = context[:c_interpreter]
+      interp.on_variable_defined += method(:check_variable)
+      interp.on_function_started += method(:check_function)
       @target_fpath = context[:sources].first.fpath
-      @scope_depth = 0
     end
 
     private
-    def check_variable(node)
-      if external?(node) && node.location.fpath != @target_fpath
-        W(:W0456, node.location, node.identifier.value)
+    def check_variable(variable_definition, variable)
+      if variable.declared_as_extern?
+        unless variable_definition.location.fpath == @target_fpath
+          W(:W0456, variable_definition.location, variable.name)
+        end
       end
     end
 
-    def check_function(node)
-      if external?(node) && node.location.fpath != @target_fpath
-        W(:W0456, node.location, node.identifier.value)
+    def check_function(function_definition, function)
+      if function.declared_as_extern?
+        unless function_definition.location.fpath == @target_fpath
+          W(:W0456, function_definition.location, function.name)
+        end
       end
     end
-
-    def enter_block(node)
-      @scope_depth += 1
-    end
-
-    def leave_block(node)
-      @scope_depth -= 1
-    end
-
-    def external?(node)
-      (@scope_depth == 0 && node.storage_class_specifier.nil?) ||
-        (node.storage_class_specifier &&
-         node.storage_class_specifier.type == :EXTERN)
-    end
   end
 
   class W0457 < PassiveMessageDetection
@@ -11109,62 +11041,52 @@ module C #:nodoc:
   class W0622 < PassiveMessageDetection
     def initialize(context)
       super
-      visitor = context[:c_visitor]
-      visitor.enter_function_declaration += method(:check)
-      visitor.enter_compound_statement += method(:enter_block)
-      visitor.leave_compound_statement += method(:leave_block)
-      @block_depth = 0
+      interp = context[:c_interpreter]
+      interp.on_function_declared += method(:check)
+      interp.on_block_started += method(:enter_block)
+      interp.on_block_ended += method(:leave_block)
+      @block_level = 0
     end
 
     private
-    def check(function_declaration)
-      if @block_depth > 0 && external_declaration?(function_declaration)
+    def check(function_declaration, function)
+      if @block_level > 0 && function.declared_as_extern?
         W(:W0622, function_declaration.location)
       end
     end
 
-    def enter_block(node)
-      @block_depth += 1
-    end
-
-    def leave_block(node)
-      @block_depth -= 1
+    def enter_block(*)
+      @block_level += 1
     end
 
-    def external_declaration?(node)
-      node.storage_class_specifier.nil? ||
-        node.storage_class_specifier.type == :EXTERN
+    def leave_block(*)
+      @block_level -= 1
     end
   end
 
   class W0623 < PassiveMessageDetection
     def initialize(context)
       super
-      visitor = context[:c_visitor]
-      visitor.enter_variable_declaration += method(:check)
-      visitor.enter_compound_statement += method(:enter_block)
-      visitor.leave_compound_statement += method(:leave_block)
-      @block_depth = 0
+      interp = context[:c_interpreter]
+      interp.on_variable_declared += method(:check)
+      interp.on_block_started += method(:enter_block)
+      interp.on_block_ended += method(:leave_block)
+      @block_level = 0
     end
 
     private
-    def check(variable_declaration)
-      if @block_depth > 0 && external_declaration?(variable_declaration)
+    def check(variable_declaration, variable)
+      if @block_level > 0 && variable.declared_as_extern?
         W(:W0623, variable_declaration.location)
       end
     end
 
-    def enter_block(node)
-      @block_depth += 1
-    end
-
-    def leave_block(node)
-      @block_depth -= 1
+    def enter_block(*)
+      @block_level += 1
     end
 
-    def external_declaration?(node)
-      node.storage_class_specifier.nil? ||
-        node.storage_class_specifier.type == :EXTERN
+    def leave_block(*)
+      @block_level -= 1
     end
   end
 
@@ -12805,10 +12727,8 @@ module C #:nodoc:
     def define_variable(variable_definition, variable)
       return unless @functions.empty?
 
-      if storage_class_specifier = variable_definition.storage_class_specifier
-        if storage_class_specifier.type == :STATIC
-          @static_variables[variable] = [variable_definition, Set.new]
-        end
+      if variable.declared_as_static?
+        @static_variables[variable] = [variable_definition, Set.new]
       end
     end
 
@@ -13381,42 +13301,46 @@ module C #:nodoc:
   class W0771 < PassiveMessageDetection
     def initialize(context)
       super
-      visitor = context[:c_visitor]
-      visitor.enter_variable_declaration += method(:add_variable_declaration)
-      visitor.enter_function_declaration += method(:add_function_declaration)
-      visitor.leave_translation_unit += method(:check)
+      interp = context[:c_interpreter]
+      interp.on_variable_declared += method(:declare_variable)
+      interp.on_function_declared += method(:declare_function)
+      interp.on_translation_unit_ended += method(:check)
       @variable_declarations = Hash.new { |hash, key| hash[key] = [] }
       @function_declarations = Hash.new { |hash, key| hash[key] = [] }
     end
 
     private
-    def add_variable_declaration(declaration)
-      if declaration.storage_class_specifier &&
-          declaration.storage_class_specifier.type == :EXTERN
-        @variable_declarations[declaration.identifier.value].push(declaration)
+    def declare_variable(variable_declaration, variable)
+      if variable.named? && variable.declared_as_extern?
+        @variable_declarations[variable.name].push(variable_declaration)
       end
     end
 
-    def add_function_declaration(declaration)
-      if declaration.storage_class_specifier &&
-          declaration.storage_class_specifier.type == :EXTERN
-        @function_declarations[declaration.identifier.value].push(declaration)
+    def declare_function(function_declaration, function)
+      if function.named? && function.declared_as_extern?
+        @function_declarations[function.name].push(function_declaration)
       end
     end
 
-    def check(node)
+    def check(*)
       @variable_declarations.each_value do |declarations|
-        if declarations.size > 1
-          declarations.each do |decl|
-            W(:W0771, decl.location, decl.identifier.value)
+        decl_locations = declarations.map { |decl|
+          decl.location
+        }.uniq { |location| location.fpath }
+        if decl_locations.size > 1
+          decl_locations.each do |location|
+            W(:W0771, location, declarations.first.identifier.value)
           end
         end
       end
 
       @function_declarations.each_value do |declarations|
-        if declarations.size > 1
-          declarations.each do |decl|
-            W(:W0771, decl.location, decl.identifier.value)
+        decl_locations = declarations.map { |decl|
+          decl.location
+        }.uniq { |location| location.fpath }
+        if decl_locations.size > 1
+          decl_locations.each do |location|
+            W(:W0771, location, declarations.first.identifier.value)
           end
         end
       end
@@ -14022,20 +13946,19 @@ module C #:nodoc:
   class W0790 < PassiveMessageDetection
     def initialize(context)
       super
-      visitor = context[:c_visitor]
-      visitor.enter_variable_definition += method(:check_variable)
-      visitor.enter_ansi_function_definition += method(:check_function)
-      visitor.enter_kandr_function_definition += method(:check_function)
-      visitor.enter_compound_statement += method(:enter_block)
-      visitor.leave_compound_statement += method(:leave_block)
+      interp = context[:c_interpreter]
+      interp.on_variable_defined += method(:check_variable)
+      interp.on_function_started += method(:check_function)
+      interp.on_block_started += method(:enter_block)
+      interp.on_block_ended += method(:leave_block)
       @global_var_names = Set.new
       @global_fun_names = Set.new
       @block_level = 0
     end
 
     private
-    def check_variable(variable_definition)
-      return unless global?(variable_definition)
+    def check_variable(variable_definition, variable)
+      return unless @block_level == 0 && variable.declared_as_extern?
 
       name = variable_definition.identifier.value
       if @global_var_names.include?(name) || @global_fun_names.include?(name)
@@ -14045,8 +13968,8 @@ module C #:nodoc:
       end
     end
 
-    def check_function(function_definition)
-      return unless global?(function_definition)
+    def check_function(function_definition, function)
+      return unless @block_level == 0 && function.declared_as_extern?
 
       name = function_definition.identifier.value
       if @global_var_names.include?(name) || @global_fun_names.include?(name)
@@ -14056,25 +13979,13 @@ module C #:nodoc:
       end
     end
 
-    def enter_block(node)
+    def enter_block(*)
       @block_level += 1
     end
 
-    def leave_block(node)
+    def leave_block(*)
       @block_level -= 1
     end
-
-    def global?(definition)
-      return false if @block_level > 0
-
-      if declaration_specifiers = definition.declaration_specifiers
-        if declaration_specifiers.storage_class_specifier &&
-            declaration_specifiers.storage_class_specifier.type == :STATIC
-          return false
-        end
-      end
-      true
-    end
   end
 
   class W0795 < PassiveMessageDetection
@@ -14256,27 +14167,16 @@ module C #:nodoc:
       super
       interp = context[:c_interpreter]
       interp.on_variable_defined += method(:check)
-      interp.on_block_started += method(:enter_block)
-      interp.on_block_ended += method(:leave_block)
-      @block_depth = 0
     end
 
     private
     def check(variable_definition, variable)
-      unless variable_definition.storage_class_specifier
+      unless variable.declared_as_extern?
         if variable.type.incomplete?
           W(:W0800, variable_definition.location, variable.name)
         end
       end
     end
-
-    def enter_block(compound_statement)
-      @block_depth += 1
-    end
-
-    def leave_block(compound_statement)
-      @block_depth -= 1
-    end
   end
 
   class W0810 < PassiveMessageDetection
@@ -14373,7 +14273,8 @@ module C #:nodoc:
     def check(type, initializer)
       return unless initializer
 
-      if initializers = initializer.initializers
+      case
+      when initializers = initializer.initializers
         case
         when type.array?
           check(type.base_type, initializers.first)
@@ -14382,6 +14283,7 @@ module C #:nodoc:
             check(memb.type, init) if init
           end
         end
+      when initializer.expression.kind_of?(StringLiteralSpecifier)
       else
         W(:W0828, initializer.location) if type.array?
       end
@@ -14548,110 +14450,94 @@ module C #:nodoc:
       visitor.enter_kandr_function_definition += method(:define_function)
       visitor.enter_compound_statement += method(:enter_block)
       visitor.leave_compound_statement += method(:leave_block)
-      @block_depth = 0
+      @block_level = 0
       @global_objects = {}
     end
 
     private
     def declare_variable(variable_declaration)
-      if @block_depth == 0
-        name = variable_declaration.identifier.value
-        linkage = linkage_of(variable_declaration)
-        prev_linkage = @global_objects[name]
-        case
-        when linkage && prev_linkage && linkage != prev_linkage
-          W(:W1031, variable_declaration.location, name)
-        when linkage
-          @global_objects[name] = linkage
-        end
+      name = variable_declaration.identifier.value
+      linkage = linkage_of(variable_declaration)
+      prev_linkage = @global_objects[name]
+      case
+      when linkage && prev_linkage && linkage != prev_linkage
+        W(:W1031, variable_declaration.location, name)
+      when linkage
+        @global_objects[name] = linkage
       end
     end
 
     def define_variable(variable_definition)
-      if @block_depth == 0
-        name = variable_definition.identifier.value
-        linkage = linkage_of(variable_definition)
-        prev_linkage = @global_objects[name]
-        case
-        when linkage && prev_linkage && linkage != prev_linkage
-          W(:W1031, variable_definition.location, name)
-        when linkage
-          @global_objects[name] = linkage
-        end
+      name = variable_definition.identifier.value
+      linkage = linkage_of(variable_definition)
+      prev_linkage = @global_objects[name]
+      case
+      when linkage && prev_linkage && linkage != prev_linkage
+        W(:W1031, variable_definition.location, name)
+      when linkage
+        @global_objects[name] = linkage
       end
     end
 
     def declare_function(function_declaration)
-      if @block_depth == 0
-        name = function_declaration.identifier.value
-        linkage = linkage_of(function_declaration)
-        prev_linkage = @global_objects[name]
-        case
-        when linkage && prev_linkage && linkage != prev_linkage
-          W(:W1031, function_declaration.location, name)
-        when linkage
-          @global_objects[name] = linkage
-        end
+      name = function_declaration.identifier.value
+      linkage = linkage_of(function_declaration)
+      prev_linkage = @global_objects[name]
+      case
+      when linkage && prev_linkage && linkage != prev_linkage
+        W(:W1031, function_declaration.location, name)
+      when linkage
+        @global_objects[name] = linkage
       end
     end
 
     def define_function(function_definition)
-      if @block_depth == 0
-        name = function_definition.identifier.value
-        linkage = linkage_of(function_definition)
-        prev_linkage = @global_objects[name]
-        case
-        when linkage && prev_linkage && linkage != prev_linkage
-          W(:W1031, function_definition.location, name)
-        when linkage
-          @global_objects[name] = linkage
-        end
+      name = function_definition.identifier.value
+      linkage = linkage_of(function_definition)
+      prev_linkage = @global_objects[name]
+      case
+      when linkage && prev_linkage && linkage != prev_linkage
+        W(:W1031, function_definition.location, name)
+      when linkage
+        @global_objects[name] = linkage
       end
     end
 
-    def enter_block(node)
-      @block_depth += 1
+    def enter_block(*)
+      @block_level += 1
     end
 
-    def leave_block(node)
-      @block_depth -= 1
+    def leave_block(*)
+      @block_level -= 1
     end
 
-    def linkage_of(node)
-      if storage_class_specifier = node.storage_class_specifier
+    def linkage_of(decl_or_def)
+      if storage_class_specifier = decl_or_def.storage_class_specifier
         case storage_class_specifier.type
         when :STATIC
-          return :internal
+          :internal
         when :EXTERN
-          return :external
+          :external
+        else
+          nil
         end
+      else
+        @block_level == 0 ? :external : nil
       end
-      nil
     end
   end
 
   class W1032 < PassiveMessageDetection
     def initialize(context)
       super
-      visitor = context[:c_visitor]
-      visitor.enter_variable_definition += method(:check)
+      interp = context[:c_interpreter]
+      interp.on_variable_defined += method(:check)
     end
 
     private
-    def check(variable_definition)
-      if linkage_of(variable_definition) == :internal
-        if variable_definition.type.incomplete?
-          W(:W1032, variable_definition.location,
-            variable_definition.identifier.value)
-        end
-      end
-    end
-
-    def linkage_of(node)
-      if storage_class_specifier = node.storage_class_specifier
-        storage_class_specifier.type == :STATIC ? :internal : :external
-      else
-        :external
+    def check(variable_definition, variable)
+      if variable.declared_as_static? && variable.type.incomplete?
+        W(:W1032, variable_definition.location, variable.name)
       end
     end
   end
@@ -14663,33 +14549,24 @@ module C #:nodoc:
       visitor.enter_function_declaration += method(:check)
       visitor.enter_compound_statement += method(:enter_block)
       visitor.leave_compound_statement += method(:leave_block)
-      @block_depth = 0
+      @block_level = 0
     end
 
     private
-    def check(function_declaration)
-      return if @block_depth == 0
-
-      if linkage_of(function_declaration) == :internal
-        W(:W1034, function_declaration.location,
-          function_declaration.identifier.value)
+    def check(declaration)
+      if @block_level > 0
+        if scs = declaration.storage_class_specifier and scs.type == :STATIC
+          W(:W1034, declaration.location, declaration.identifier.value)
+        end
       end
     end
 
-    def enter_block(node)
-      @block_depth += 1
-    end
-
-    def leave_block(node)
-      @block_depth -= 1
+    def enter_block(*)
+      @block_level += 1
     end
 
-    def linkage_of(node)
-      if storage_class_specifier = node.storage_class_specifier
-        storage_class_specifier.type == :STATIC ? :internal : :external
-      else
-        :external
-      end
+    def leave_block(*)
+      @block_level -= 1
     end
   end