adlint 1.8.10 → 1.10.0

data/lib/adlint/c/message.rb

@@ -35,6 +35,7 @@ require "adlint/traits"
 require "adlint/monitor"
 require "adlint/c/syntax"
 require "adlint/c/format"
+require "adlint/c/option"
 require "adlint/c/util"
 require "adlint/cpp/syntax"
 
@@ -659,8 +660,8 @@ module C #:nodoc:
       end
     end
 
-    def check_conditional(conditional_expression, condition_variable, result)
-      unless condition_variable.type.scalar?
+    def check_conditional(conditional_expression, controlling_variable, result)
+      unless controlling_variable.type.scalar?
         W(:W0035, conditional_expression.location)
       end
     end
@@ -1160,7 +1161,7 @@ module C #:nodoc:
       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_function_defined += method(:add_function)
       interp.on_translation_unit_ended += method(:check)
       @identifiers = Hash.new { |hash, key| hash[key] = [] }
     end
@@ -2493,7 +2494,7 @@ module C #:nodoc:
       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_function_defined += method(:check_function)
       interp.on_variable_defined += method(:check_variable)
       @target_fpath = context[:sources].first.fpath
       @external_symbols = Set.new
@@ -4108,10 +4109,10 @@ module C #:nodoc:
     def check_return_statement(return_statement, result_variable)
       return unless @current_function
       return if from_type == to_type
-
       return unless result_variable
-      if from_type.same_as?(result_variable.type) &&
-          to_type.same_as?(@current_function.type.return_type)
+
+      if result_variable.type.same_as?(from_type) &&
+          @current_function.type.return_type.same_as?(to_type)
         W(message_id, return_statement.location, @current_function.name)
       end
     end
@@ -6868,7 +6869,7 @@ module C #:nodoc:
       super
       interp = context[:c_interpreter]
       interp.on_variable_defined += method(:check_variable)
-      interp.on_function_started += method(:check_function)
+      interp.on_function_defined += method(:check_function)
       @target_fpath = context[:sources].first.fpath
     end
 
@@ -8654,6 +8655,12 @@ module C #:nodoc:
         @group_depth -= 1
       end
 
+      def visit_conditional_expression(node)
+        @group_depth += 1
+        super
+        @group_depth -= 1
+      end
+
       def visit_array_subscript_expression(node)
         AmbiguousExpressionDetector.new(@context, node.array_subscript).execute
       end
@@ -8785,6 +8792,7 @@ module C #:nodoc:
       def initialize(context, expression)
         @context = context
         @expression = expression
+        @already_warned = false
         @group_depth = 0
         @ungrouped_binary_expr = 0
       end
@@ -8800,61 +8808,73 @@ module C #:nodoc:
       end
 
       def visit_multiplicative_expression(node)
-        super unless check_binary_expression
+        check_binary_expression
+        super
       end
 
       def visit_additive_expression(node)
-        super unless check_binary_expression
+        check_binary_expression
+        super
       end
 
       def visit_shift_expression(node)
-        super unless check_binary_expression
+        check_binary_expression
+        super
       end
 
       def visit_relational_expression(node)
-        super unless check_binary_expression
+        check_binary_expression
+        super
       end
 
       def visit_equality_expression(node)
-        super unless check_binary_expression
+        check_binary_expression
+        super
       end
 
       def visit_and_expression(node)
-        super unless check_binary_expression
+        check_binary_expression
+        super
       end
 
       def visit_exclusive_or_expression(node)
-        super unless check_binary_expression
+        check_binary_expression
+        super
       end
 
       def visit_inclusive_or_expression(node)
-        super unless check_binary_expression
+        check_binary_expression
+        super
       end
 
       def visit_logical_and_expression(node)
-        super unless check_binary_expression
+        check_binary_expression
+        super
       end
 
       def visit_logical_or_expression(node)
-        super unless check_binary_expression
+        check_binary_expression
+        super
       end
 
       def visit_simple_assignment_expression(node)
-        super unless check_binary_expression
+        check_binary_expression
+        super
       end
 
       def visit_compound_assignment_expression(node)
-        super unless check_binary_expression
+        check_binary_expression
+        super
       end
 
       private
       def check_binary_expression
         @ungrouped_binary_expr += 1 if @group_depth == 0
-        if include_ambiguous_expr?
-          W(:W0501, @expression.head_location)
-          true
-        else
-          false
+        unless @already_warned
+          if include_ambiguous_expr?
+            W(:W0501, @expression.head_location)
+            @already_warned = true
+          end
         end
       end
 
@@ -10372,21 +10392,12 @@ module C #:nodoc:
       return unless function.named?
       return if function.type.have_va_list?
 
-      param_types = function.type.parameter_types.map { |type|
-        type.void? ? nil : type.unqualify
-      }.compact
+      param_types = function.type.parameter_types.reject { |type| type.void? }
 
       @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
+            atype.convertible?(ptype)
           }
         else
           conformed = false
@@ -10398,7 +10409,7 @@ module C #:nodoc:
 
     def call_function(expression, function, arg_variables, result_variable)
       if function.named?
-        arg_types = arg_variables.map { |var| var.type.unqualify }
+        arg_types = arg_variables.map { |var| var.type }
         @function_calls[function.name].push([expression, arg_types])
       end
     end
@@ -10409,7 +10420,7 @@ module C #:nodoc:
       super
       interp = context[:c_interpreter]
       interp.on_function_call_expr_evaled += method(:call_function)
-      interp.on_function_started += method(:check)
+      interp.on_function_defined += method(:check)
       @function_calls = Hash.new { |hash, key| hash[key] = [] }
     end
 
@@ -10418,21 +10429,12 @@ module C #:nodoc:
       return unless function.named?
       return if function.type.have_va_list?
 
-      param_types = function.type.parameter_types.map { |type|
-        type.void? ? nil : type.unqualify
-      }.compact
+      param_types = function.type.parameter_types.reject { |type| type.void? }
 
       @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
+            atype.convertible?(ptype)
           }
         else
           conformed = false
@@ -10444,7 +10446,7 @@ module C #:nodoc:
 
     def call_function(expression, function, arg_variables, result_variable)
       if function.named?
-        arg_types = arg_variables.map { |var| var.type.unqualify }
+        arg_types = arg_variables.map { |var| var.type }
         @function_calls[function.name].push([expression, arg_types])
       end
     end
@@ -10463,23 +10465,12 @@ module C #:nodoc:
       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
+      arg_types = arg_variables.map { |var| var.type }
+      param_types = function.type.parameter_types.reject { |type| type.void? }
 
       if arg_types.size == param_types.size
         arg_types.zip(param_types).each_with_index do |(atype, ptype), index|
-          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
+          unless atype.convertible?(ptype)
             W(:W0584,
               expression.argument_expressions[index].location, index + 1)
           end
@@ -11132,7 +11123,7 @@ module C #:nodoc:
       interp.on_variable_defined += method(:check)
       interp.on_variable_declared += method(:check)
       interp.on_function_declared += method(:check)
-      interp.on_function_started += method(:check)
+      interp.on_function_defined += method(:check)
       @typedef_types = {}
     end
 
@@ -11245,7 +11236,7 @@ module C #:nodoc:
     def initialize(context)
       super
       interp = context[:c_interpreter]
-      interp.on_function_started += method(:define_function)
+      interp.on_function_defined += method(:define_function)
       interp.on_function_referred += method(:refer_function)
       interp.on_translation_unit_ended += method(:check)
       @static_functions = {}
@@ -12166,7 +12157,7 @@ module C #:nodoc:
       interp.on_variable_declared += method(:declare_variable)
       interp.on_enum_declared += method(:declare_enum)
       interp.on_typedef_declared += method(:declare_typedef)
-      interp.on_function_started += method(:define_function)
+      interp.on_function_defined += method(:define_function)
       interp.on_parameter_defined += method(:define_parameter)
       interp.on_block_started += method(:enter_scope)
       interp.on_block_ended += method(:leave_scope)
@@ -13543,7 +13534,7 @@ module C #:nodoc:
       interp.on_variable_declared += method(:check_object_declaration)
       interp.on_variable_defined += method(:check_object_declaration)
       interp.on_function_declared += method(:check_object_declaration)
-      interp.on_function_started += method(:check_object_declaration)
+      interp.on_function_defined += method(:check_object_declaration)
       interp.on_typedef_declared += method(:check_typedef_declaration)
       interp.on_enum_declared += method(:check_enum_declaration)
       interp.on_block_started += method(:start_block)
@@ -13679,7 +13670,7 @@ module C #:nodoc:
       interp.on_variable_declared += method(:check_object_declaration)
       interp.on_variable_defined += method(:check_object_declaration)
       interp.on_function_declared += method(:check_object_declaration)
-      interp.on_function_started += method(:check_object_declaration)
+      interp.on_function_defined += method(:check_object_declaration)
       interp.on_typedef_declared += method(:check_typedef_declaration)
       interp.on_enum_declared += method(:check_enum_declaration)
       interp.on_block_started += method(:start_block)
@@ -13813,7 +13804,7 @@ module C #:nodoc:
       interp.on_variable_declared += method(:check_object_declaration)
       interp.on_variable_defined += method(:check_object_declaration)
       interp.on_function_declared += method(:check_object_declaration)
-      interp.on_function_started += method(:check_object_declaration)
+      interp.on_function_defined += method(:check_object_declaration)
       interp.on_typedef_declared += method(:check_typedef_declaration)
       interp.on_enum_declared += method(:check_enum_declaration)
       interp.on_block_started += method(:start_block)
@@ -13948,7 +13939,7 @@ module C #:nodoc:
       super
       interp = context[:c_interpreter]
       interp.on_variable_defined += method(:check_variable)
-      interp.on_function_started += method(:check_function)
+      interp.on_function_defined += method(:check_function)
       interp.on_block_started += method(:enter_block)
       interp.on_block_ended += method(:leave_block)
       @global_var_names = Set.new
@@ -14344,7 +14335,7 @@ module C #:nodoc:
     end
 
     def compute_bitfield_width(expression)
-      object = @c_interp.execute(expression, :suppress_notification)
+      object = @c_interp.execute(expression, InterpreterOptions::QUIET)
       if object.variable? && object.value.scalar?
         return object.value.unique_sample || 0
       end
@@ -14442,87 +14433,79 @@ module C #:nodoc:
   class W1031 < PassiveMessageDetection
     def initialize(context)
       super
-      visitor = context[:c_visitor]
-      visitor.enter_variable_declaration += method(:declare_variable)
-      visitor.enter_variable_definition += method(:define_variable)
-      visitor.enter_function_declaration += method(:declare_function)
-      visitor.enter_ansi_function_definition += method(:define_function)
-      visitor.enter_kandr_function_definition += method(:define_function)
-      visitor.enter_compound_statement += method(:enter_block)
-      visitor.leave_compound_statement += method(:leave_block)
-      @block_level = 0
-      @global_objects = {}
+      interp = context[:c_interpreter]
+      interp.on_variable_declared += method(:declare_variable)
+      interp.on_variable_defined += method(:define_variable)
+      interp.on_function_declared += method(:declare_function)
+      interp.on_function_defined += method(:define_function)
     end
 
     private
-    def declare_variable(variable_declaration)
-      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)
-      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
+    def declare_variable(variable_declaration, variable)
+      if variable.named?
+        case
+        when variable.declared_as_extern?
+          sc_specifier = variable_declaration.storage_class_specifier
+          if sc_specifier && sc_specifier.type == :STATIC
+            W(:W1031, variable_declaration.location, variable.name)
+          end
+        when variable.declared_as_static?
+          sc_specifier = variable_declaration.storage_class_specifier
+          if sc_specifier && sc_specifier.type == :EXTERN
+            W(:W1031, variable_declaration.location, variable.name)
+          end
+        end
       end
     end
 
-    def declare_function(function_declaration)
-      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
+    def define_variable(variable_definition, variable)
+      if variable.named?
+        case
+        when variable.declared_as_extern?
+          sc_specifier = variable_definition.storage_class_specifier
+          if sc_specifier && sc_specifier.type == :STATIC
+            W(:W1031, variable_definition.location, variable.name)
+          end
+        when variable.declared_as_static?
+          sc_specifier = variable_definition.storage_class_specifier
+          if sc_specifier && sc_specifier.type == :EXTERN
+            W(:W1031, variable_definition.location, variable.name)
+          end
+        end
       end
     end
 
-    def define_function(function_definition)
-      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
+    def declare_function(function_declaration, function)
+      if function.named?
+        case
+        when function.declared_as_extern?
+          sc_specifier = function_declaration.storage_class_specifier
+          if sc_specifier && sc_specifier.type == :STATIC
+            W(:W1031, function_declaration.location, function.name)
+          end
+        when function.declared_as_static?
+          sc_specifier = function_declaration.storage_class_specifier
+          if sc_specifier && sc_specifier.type == :EXTERN
+            W(:W1031, function_declaration.location, function.name)
+          end
+        end
       end
     end
 
-    def enter_block(*)
-      @block_level += 1
-    end
-
-    def leave_block(*)
-      @block_level -= 1
-    end
-
-    def linkage_of(decl_or_def)
-      if storage_class_specifier = decl_or_def.storage_class_specifier
-        case storage_class_specifier.type
-        when :STATIC
-          :internal
-        when :EXTERN
-          :external
-        else
-          nil
+    def define_function(function_definition, function)
+      if function.named?
+        case
+        when function.declared_as_extern?
+          sc_specifier = function_definition.storage_class_specifier
+          if sc_specifier && sc_specifier.type == :STATIC
+            W(:W1031, function_definition.location, function.name)
+          end
+        when function.declared_as_static?
+          sc_specifier = function_definition.storage_class_specifier
+          if sc_specifier && sc_specifier.type == :EXTERN
+            W(:W1031, function_definition.location, function.name)
+          end
         end
-      else
-        @block_level == 0 ? :external : nil
       end
     end
   end

data/lib/adlint/c/message_shima.rb

@@ -250,6 +250,50 @@ module C #:nodoc:
     end
   end
 
+  class W0716 < PassiveMessageDetection
+    def initialize(context)
+      super
+      visitor = context[:c_visitor]
+      visitor.enter_additive_expression += method(:check)
+      visitor.enter_multiplicative_expression += method(:check)
+      visitor.enter_shift_expression += method(:check)
+      visitor.enter_and_expression += method(:check)
+      visitor.enter_exclusive_or_expression += method(:check)
+      visitor.enter_inclusive_or_expression += method(:check)
+      visitor.enter_compound_assignment_expression += lambda { |expr|
+        case expr.operator.type
+        when "+=", "-=", "*=", "/=", "%=", "<<=", ">>=", "&=", "^=", "|="
+          check(expr)
+        end
+      }
+    end
+
+    private
+    def check(expression)
+      if expression.lhs_operand.logical? && expression.rhs_operand.logical?
+        W(:W0716, expression.location)
+      end
+    end
+  end
+
+  class W0717 < W0716
+    private
+    def check(expression)
+      if expression.lhs_operand.logical? && !expression.rhs_operand.logical?
+        W(:W0717, expression.lhs_operand.location)
+      end
+    end
+  end
+
+  class W0718 < W0716
+    private
+    def check(expression)
+      if !expression.lhs_operand.logical? && expression.rhs_operand.logical?
+        W(:W0718, expression.rhs_operand.location)
+      end
+    end
+  end
+
   class W0726 < W0698
     private
     def check(return_statement)