adlint 1.6.0 → 1.8.0

data/lib/adlint/c/message.rb

@@ -557,7 +557,7 @@ module C #:nodoc:
     end
 
     private
-    def start_function(function_definition)
+    def start_function(function_definition, function)
       @parameters = {}
     end
 
@@ -579,7 +579,7 @@ module C #:nodoc:
       end
     end
 
-    def check_unused_parameter(function_definition)
+    def check_unused_parameter(function_definition, function)
       return unless @parameters
 
       @parameters.each do |name, param|
@@ -601,7 +601,7 @@ module C #:nodoc:
     end
 
     private
-    def collect_labels(function_definition)
+    def collect_labels(function_definition, function)
       collector = LabelCollector.new
       function_definition.function_body.accept(collector)
       @labels = collector.labels
@@ -619,7 +619,7 @@ module C #:nodoc:
       end
     end
 
-    def check_unused_label(function_definition)
+    def check_unused_label(function_definition, function)
       return unless @labels
 
       @labels.each do |name, label|
@@ -1943,12 +1943,12 @@ module C #:nodoc:
     end
 
     private
-    def start_function(function_definition)
+    def start_function(function_definition, function)
       @parameters = Set.new
       @pointer_relationship = {}
     end
 
-    def end_function(function_definition)
+    def end_function(function_definition, function)
       @parameters = nil
       @pointer_relationship = nil
     end
@@ -1999,11 +1999,11 @@ module C #:nodoc:
     end
 
     private
-    def start_function(function_definition)
+    def start_function(function_definition, function)
       @local_variables = Set.new
     end
 
-    def end_function(function_definition)
+    def end_function(function_definition, function)
       @local_variables = nil
     end
 
@@ -2042,7 +2042,7 @@ module C #:nodoc:
     end
 
     private
-    def start_function(function_definition)
+    def start_function(function_definition, function)
       @parameters = {}
     end
 
@@ -2063,7 +2063,7 @@ module C #:nodoc:
       end
     end
 
-    def check_constant_parameters(function_definition)
+    def check_constant_parameters(function_definition, function)
       return unless @parameters
 
       @parameters.each do |name, (written, variable, location)|
@@ -2092,7 +2092,7 @@ module C #:nodoc:
     end
 
     private
-    def start_function(function_definition)
+    def start_function(function_definition, function)
       @variable_relationship = {}
       @parameters = {}
     end
@@ -2131,7 +2131,7 @@ module C #:nodoc:
       end
     end
 
-    def check_constant_parameters(function_definition)
+    def check_constant_parameters(function_definition, function)
       return unless @parameters
 
       @parameters.each do |pointer, (location, written)|
@@ -4151,11 +4151,11 @@ module C #:nodoc:
     end
 
     private
-    def start_function(function_definition)
-      @current_function = function_definition
+    def start_function(function_definition, function)
+      @current_function = function
     end
 
-    def end_function(function_definition)
+    def end_function(function_definition, function)
       @current_function = nil
     end
 
@@ -4166,8 +4166,7 @@ module C #:nodoc:
       return unless result_variable
       if from_type.same_as?(result_variable.type) &&
           to_type.same_as?(@current_function.type.return_type)
-        W(message_id,
-          return_statement.location, @current_function.identifier.value)
+        W(message_id, return_statement.location, @current_function.name)
       end
     end
 
@@ -7043,7 +7042,7 @@ module C #:nodoc:
         next unless !base_type.function? && base_type.const?
 
         if pointee = @interp.pointee_of(arg) and pointee.variable?
-          if pointee.value.must_be_undefined?
+          if !pointee.temporary? && pointee.value.must_be_undefined?
             W(:W0461,
               function_call_expression.argument_expressions[index].location)
           end
@@ -7070,7 +7069,7 @@ module C #:nodoc:
 
         if pointee = @interp.pointee_of(arg) and pointee.variable?
           next if pointee.value.must_be_undefined?
-          if pointee.value.may_be_undefined?
+          if !pointee.temporary? && pointee.value.may_be_undefined?
             W(:W0462,
               function_call_expression.argument_expressions[index].location)
           end
@@ -9735,17 +9734,11 @@ module C #:nodoc:
     end
 
     private
-    def enter_function(function_definition)
-      if declarator = function_definition.declarator
-        if identifier = declarator.identifier
-          @functions.push(@interp.function_named(identifier.value))
-          return
-        end
-      end
-      @functions.push(nil)
+    def enter_function(function_definition, function)
+      @functions.push(function)
     end
 
-    def leave_function(function_definition)
+    def leave_function(function_definition, function)
       @functions.pop
     end
 
@@ -10233,7 +10226,7 @@ module C #:nodoc:
       end
     end
 
-    def clear_rvalues(function_definition)
+    def clear_rvalues(function_definition, function)
       @rvalues = {}
     end
 
@@ -10295,7 +10288,7 @@ module C #:nodoc:
       end
     end
 
-    def clear_rvalues(function_definition)
+    def clear_rvalues(function_definition, function)
       @rvalues = {}
     end
 
@@ -10341,12 +10334,12 @@ module C #:nodoc:
     end
 
     private
-    def start_function(function_definition)
+    def start_function(function_definition, function)
       @parameters = Set.new
       @pointer_relationship = {}
     end
 
-    def end_function(function_definition)
+    def end_function(function_definition, function)
       @parameters = nil
       @pointer_relationship = nil
     end
@@ -10396,17 +10389,34 @@ module C #:nodoc:
     private
     def check(function_call_expression, function, arg_variables,
               result_variable)
+      return unless function.named?
       return if prototype_declaration_of(function)
 
       arg_types = arg_variables.map { |var| var.type.unqualify }
 
-      if call_history = @function_calls[function]
-        if call_history.any? { |prev_arg_types| prev_arg_types != arg_types }
+      @function_calls[function.name].each do |prev_arg_types|
+        if prev_arg_types.size == arg_types.size
+          conformed = prev_arg_types.zip(arg_types).all? { |prev, last|
+            case
+            when prev.array? && last.array?,
+                 prev.array? && last.pointer?,
+                 prev.pointer? && last.array?
+              prev.base_type == last.base_type
+            else
+              prev == last
+            end
+          }
+        else
+          conformed = false
+        end
+
+        unless conformed
           W(:W0581, function_call_expression.location)
+          break
         end
       end
 
-      @function_calls[function].push(arg_types)
+      @function_calls[function.name].push(arg_types)
     end
 
     def prototype_declaration_of(function)
@@ -10427,17 +10437,30 @@ module C #:nodoc:
 
     private
     def check(function_declaration, function)
+      return unless function.named?
       return if function.type.have_va_list?
 
-      if function.named?
-        if call_history = @function_calls[function.name]
-          call_history.each do |expr, arg_types|
-            param_types = function.type.parameter_types.map { |type|
-              type.unqualify
-            }
-            W(:W0582, expr.location) if param_types != arg_types
-          end
+      param_types = function.type.parameter_types.map { |type|
+        type.void? ? nil : type.unqualify
+      }.compact
+
+      @function_calls[function.name].each do |expr, arg_types|
+        if arg_types.size == param_types.size
+          conformed = arg_types.zip(param_types).all? { |atype, ptype|
+            case
+            when atype.array? && ptype.array?,
+                 atype.array? && ptype.pointer?,
+                 atype.pointer? && ptype.array?
+              atype.base_type == ptype.base_type
+            else
+              atype == ptype
+            end
+          }
+        else
+          conformed = false
         end
+
+        W(:W0582, expr.location) unless conformed
       end
     end
 
@@ -10459,16 +10482,31 @@ module C #:nodoc:
     end
 
     private
-    def check(function_definition)
-      return if function_definition.type.have_va_list?
+    def check(function_definition, function)
+      return unless function.named?
+      return if function.type.have_va_list?
 
-      if call_history = @function_calls[function_definition.identifier.value]
-        call_history.each do |expr, arg_types|
-          param_types = function_definition.type.parameter_types.map { |type|
-            type.unqualify
+      param_types = function.type.parameter_types.map { |type|
+        type.void? ? nil : type.unqualify
+      }.compact
+
+      @function_calls[function.name].each do |expr, arg_types|
+        if arg_types.size == param_types.size
+          conformed = arg_types.zip(param_types).all? { |atype, ptype|
+            case
+            when atype.array? && ptype.array?,
+                 atype.array? && ptype.pointer?,
+                 atype.pointer? && ptype.array?
+              atype.base_type == ptype.base_type
+            else
+              atype == ptype
+            end
           }
-          W(:W0583, expr.location) if param_types != arg_types
+        else
+          conformed = false
         end
+
+        W(:W0583, expr.location) unless conformed
       end
     end
 
@@ -10489,12 +10527,27 @@ module C #:nodoc:
 
     private
     def check(expression, function, arg_variables, result_variable)
-      if kandr_style_definition_of(function)
-        param_types = function.type.parameter_types
-        arg_types = arg_variables.map { |var| var.type }
+      return unless function.named?
+      return unless kandr_style_definition_of(function)
+      return if function.type.have_va_list?
+
+      arg_types = arg_variables.map { |var| var.type.unqualify }
+      param_types = function.type.parameter_types.map { |type|
+        type.void? ? nil : type.unqualify
+      }.compact
 
+      if arg_types.size == param_types.size
         arg_types.zip(param_types).each_with_index do |(atype, ptype), index|
-          if atype && ptype && !atype.same_as?(ptype)
+          conformed = case
+                      when atype.array? && ptype.array?,
+                           atype.array? && ptype.pointer?,
+                           atype.pointer? && ptype.array?
+                        atype.base_type == ptype.base_type
+                      else
+                        atype == ptype
+                      end
+
+          unless conformed
             W(:W0584,
               expression.argument_expressions[index].location, index + 1)
           end
@@ -10790,6 +10843,62 @@ module C #:nodoc:
     end
   end
 
+  class W0607 < PassiveMessageDetection
+    def initialize(context)
+      super
+      interp = context[:c_interpreter]
+      interp.on_explicit_conv_performed += method(:check)
+    end
+
+    private
+    def check(expression, original_variable, result_variable)
+      orig_type = original_variable.type
+      conv_type = result_variable.type
+
+      unless orig_type.scalar? && orig_type.integer? &&
+          conv_type.scalar? && conv_type.integer? && conv_type.unsigned?
+        return
+      end
+
+      orig_value = original_variable.value
+      return unless orig_value.scalar?
+
+      lower_test = orig_value < ScalarValue.of(0)
+
+      if lower_test.must_be_true?
+        W(:W0607, expression.location)
+      end
+    end
+  end
+
+  class W0608 < PassiveMessageDetection
+    def initialize(context)
+      super
+      interp = context[:c_interpreter]
+      interp.on_explicit_conv_performed += method(:check)
+    end
+
+    private
+    def check(expression, original_variable, result_variable)
+      orig_type = original_variable.type
+      conv_type = result_variable.type
+
+      unless orig_type.scalar? && orig_type.integer? &&
+          conv_type.scalar? && conv_type.integer? && conv_type.unsigned?
+        return
+      end
+
+      orig_value = original_variable.value
+      return unless orig_value.scalar?
+
+      lower_test = orig_value < ScalarValue.of(0)
+
+      if !lower_test.must_be_true? && lower_test.may_be_true?
+        W(:W0608, expression.location)
+      end
+    end
+  end
+
   class W0609 < PassiveMessageDetection
     def initialize(context)
       super
@@ -11086,6 +11195,54 @@ module C #:nodoc:
     end
   end
 
+  class W0625 < PassiveMessageDetection
+    # NOTE: W0625 may be duplicative when the same typedef is used twice or
+    #       more.
+    ensure_uniqueness_of :W0625
+
+    include SyntaxNodeCollector
+
+    def initialize(context)
+      super
+      @fpath = context[:sources].first.fpath
+      interp = context[:c_interpreter]
+      interp.on_typedef_declared += method(:declare_typedef)
+      interp.on_variable_defined += method(:check)
+      interp.on_variable_declared += method(:check)
+      interp.on_function_declared += method(:check)
+      interp.on_function_started += method(:check)
+      @typedef_types = {}
+    end
+
+    private
+    def declare_typedef(typedef_declaration)
+      typedef_name = typedef_declaration.identifier.value
+
+      if @fpath == typedef_declaration.location.fpath
+        @typedef_types[typedef_name] = typedef_declaration
+      else
+        @typedef_types.delete(typedef_name)
+      end
+    end
+
+    def check(decl_or_def, object, *)
+      return unless object.declared_as_extern?
+
+      if declaration_specifiers  = decl_or_def.declaration_specifiers
+        find_bad_typedef_decls(declaration_specifiers).each do |decl|
+          W(:W0625, decl.location, decl.identifier.value)
+          break
+        end
+      end
+    end
+
+    def find_bad_typedef_decls(node)
+      collect_typedef_type_specifiers(node).map { |type_spec|
+        @typedef_types[type_spec.identifier.value]
+      }.compact
+    end
+  end
+
   class W0626 < PassiveMessageDetection
     def initialize(context)
       super
@@ -11167,7 +11324,7 @@ module C #:nodoc:
       super
       interp = context[:c_interpreter]
       interp.on_function_started += method(:define_function)
-      interp.on_function_call_expr_evaled += method(:call_function)
+      interp.on_function_referred += method(:refer_function)
       interp.on_translation_unit_ended += method(:check)
       @static_functions = {}
     end
@@ -11181,18 +11338,14 @@ module C #:nodoc:
       end
     end
 
-    def define_function(function_definition)
-      if storage_class_specifier = function_definition.storage_class_specifier
-        if storage_class_specifier.type == :STATIC
-          name = function_definition.identifier.value
-          @static_functions[name] ||= [0, function_definition.location]
-          @static_functions[name][1] ||= function_definition.location
-        end
+    def define_function(function_definition, function)
+      if function.declared_as_static?
+        @static_functions[function.name] ||= [0, function_definition.location]
+        @static_functions[function.name][1] ||= function_definition.location
       end
     end
 
-    def call_function(function_call_expression,
-                      function, arg_variables, result_variable)
+    def refer_function(expression, function)
       return unless function.named?
 
       if record = @static_functions[function.name]
@@ -11473,6 +11626,28 @@ module C #:nodoc:
     end
   end
 
+  class W0642 < PassiveMessageDetection
+    def initialize(context)
+      super
+      interp = context[:c_interpreter]
+      interp.on_address_expr_evaled += method(:check_address_expression)
+      interp.on_implicit_conv_performed += method(:check_conversion)
+    end
+
+    private
+    def check_address_expression(expression, object, pointer_variable)
+      if object.declared_as_register?
+        W(:W0642, expression.location)
+      end
+    end
+
+    def check_conversion(expression, original_variable, result_variable)
+      if original_variable.declared_as_register?
+        W(:W0642, expression.location)
+      end
+    end
+  end
+
   class W0653 < PassiveMessageDetection
     def initialize(context)
       super
@@ -12149,7 +12324,7 @@ module C #:nodoc:
        @tdefs[0..-2] + @enums[0..-2]).reduce(Set.new) { |r, s| r + s }
     end
 
-    def define_function(function_definition)
+    def define_function(function_definition, function)
       identifier = function_definition.identifier.value
       if wider_identifiers_of_function_definition.include?(identifier)
         W(:W0704, function_definition.location, identifier)
@@ -12555,11 +12730,11 @@ module C #:nodoc:
     end
 
     private
-    def start_function(function_definition)
-      @current_function = function_definition
+    def start_function(function_definition, function)
+      @current_function = function
     end
 
-    def end_function(function_definition)
+    def end_function(function_definition, function)
       @current_function = nil
     end
 
@@ -12645,11 +12820,11 @@ module C #:nodoc:
       end
     end
 
-    def enter_function(function_definition)
-      @functions.push(function_definition)
+    def enter_function(function_definition, function)
+      @functions.push(function)
     end
 
-    def leave_function(function_definition)
+    def leave_function(function_definition, function)
       @functions.pop
     end
 
@@ -13306,7 +13481,7 @@ module C #:nodoc:
       end
     end
 
-    def clear_rvalues(function_definition)
+    def clear_rvalues(function_definition, function)
       @rvalues = {}
     end
 
@@ -14381,12 +14556,13 @@ module C #:nodoc:
     def declare_variable(variable_declaration)
       if @block_depth == 0
         name = variable_declaration.identifier.value
-        if prev_linkage = @global_objects[name]
-          unless prev_linkage == linkage_of(variable_declaration)
-            W(:W1031, variable_declaration.location, name)
-          end
-        else
-          @global_objects[name] = linkage_of(variable_declaration)
+        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
     end
@@ -14394,12 +14570,13 @@ module C #:nodoc:
     def define_variable(variable_definition)
       if @block_depth == 0
         name = variable_definition.identifier.value
-        if prev_linkage = @global_objects[name]
-          unless prev_linkage == linkage_of(variable_definition)
-            W(:W1031, variable_definition.location, name)
-          end
-        else
-          @global_objects[name] = linkage_of(variable_definition)
+        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
     end
@@ -14407,12 +14584,13 @@ module C #:nodoc:
     def declare_function(function_declaration)
       if @block_depth == 0
         name = function_declaration.identifier.value
-        if prev_linkage = @global_objects[name]
-          unless prev_linkage == linkage_of(function_declaration)
-            W(:W1031, function_declaration.location, name)
-          end
-        else
-          @global_objects[name] = linkage_of(function_declaration)
+        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
     end
@@ -14420,12 +14598,13 @@ module C #:nodoc:
     def define_function(function_definition)
       if @block_depth == 0
         name = function_definition.identifier.value
-        if prev_linkage = @global_objects[name]
-          unless prev_linkage == linkage_of(function_definition)
-            W(:W1031, function_definition.location, name)
-          end
-        else
-          @global_objects[name] = linkage_of(function_definition)
+        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
     end
@@ -14440,10 +14619,14 @@ module C #:nodoc:
 
     def linkage_of(node)
       if storage_class_specifier = node.storage_class_specifier
-        storage_class_specifier.type == :STATIC ? :internal : :external
-      else
-        :external
+        case storage_class_specifier.type
+        when :STATIC
+          return :internal
+        when :EXTERN
+          return :external
+        end
       end
+      nil
     end
   end
 
@@ -14691,11 +14874,11 @@ module C #:nodoc:
     end
 
     private
-    def start_function(function_definition)
-      @current_function = function_definition
+    def start_function(function_definition, function)
+      @current_function = function
     end
 
-    def end_function(function_definition)
+    def end_function(function_definition, function)
       @current_function = nil
     end
 
@@ -14770,11 +14953,11 @@ module C #:nodoc:
     end
 
     private
-    def start_function(function_definition)
-      @current_function = function_definition
+    def start_function(function_definition, function)
+      @current_function = function
     end
 
-    def end_function(function_definition)
+    def end_function(function_definition, function)
       @current_function = nil
     end
 
@@ -14826,11 +15009,11 @@ module C #:nodoc:
     end
 
     private
-    def start_function(function_definition)
-      @current_function = function_definition
+    def start_function(function_definition, function)
+      @current_function = function
     end
 
-    def end_function(function_definition)
+    def end_function(function_definition, function)
       @current_function = nil
     end
 
@@ -14897,11 +15080,11 @@ module C #:nodoc:
     end
 
     private
-    def start_function(function_definition)
-      @current_function = function_definition
+    def start_function(function_definition, function)
+      @current_function = function
     end
 
-    def end_function(function_definition)
+    def end_function(function_definition, function)
       @current_function = nil
     end