adlint 2.4.10 → 2.6.0

data/lib/adlint/c/type.rb

@@ -5080,7 +5080,7 @@ module C #:nodoc:
         rhs_base = rhs_unqualified.base_type
 
         unless lhs_base.more_cv_qualified?(rhs_base)
-          lhs_base.void? || lhs_base.convertible?(rhs_base)
+          rhs_base.void? || lhs_base.convertible?(rhs_base)
         else
           false
         end
@@ -5555,7 +5555,7 @@ module C #:nodoc:
         rhs_base = rhs_unqualified.base_type
 
         unless lhs_base.more_cv_qualified?(rhs_base)
-          lhs_base.convertible?(rhs_base)
+          rhs_base.void? || lhs_base.convertible?(rhs_base)
         else
           false
         end
@@ -6741,7 +6741,11 @@ module C #:nodoc:
     extend Forwardable
 
     def_delegator :@base_type, :image
-    def_delegator :@base_type, :brief_image
+
+    def brief_image
+      name
+    end
+
     def_delegator :@base_type, :bit_size
     def_delegator :@base_type, :bit_alignment
     def_delegator :@base_type, :real_type
@@ -6911,6 +6915,8 @@ module C #:nodoc:
     def_delegator :@type, :incomplete?
     def_delegator :@type, :compatible?
     def_delegator :@type, :coercible?
+    def_delegator :@type, :convertible?
+    def_delegator :@type, :more_cv_qualified?
 
     def parameter?
       true
@@ -6942,6 +6948,7 @@ module C #:nodoc:
     def_delegator :@type, :parameter_types
     def_delegator :@type, :enumerators
     def_delegator :@type, :length
+    def_delegator :@type, :length=
     def_delegator :@type, :impl_length
     def_delegator :@type, :members
     def_delegator :@type, :member_named

data/lib/adlint/exam/c_builtin/c_check.rb

@@ -39,6 +39,7 @@ require "adlint/c/syntax"
 require "adlint/c/type"
 require "adlint/c/format"
 require "adlint/c/option"
+require "adlint/c/conv"
 require "adlint/c/util"
 require "adlint/cpp/syntax"
 
@@ -1818,29 +1819,34 @@ module CBuiltin #:nodoc:
 
     def initialize(context)
       super
-      visitor = context[:c_visitor]
-      visitor.enter_expression_statement += method(:enter_expression_statement)
-      visitor.leave_expression_statement += method(:leave_expression_statement)
-      visitor.enter_logical_and_expression += method(:check)
-      visitor.enter_logical_or_expression += method(:check)
-      @in_expression_statement = false
+      interp = context[:c_interpreter]
+      interp.on_expression_stmt_started += method(:enter_expression_statement)
+      interp.on_expression_stmt_ended += method(:leave_expression_statement)
+      interp.on_logical_and_expr_evaled += method(:check)
+      interp.on_logical_or_expr_evaled += method(:check)
+      @current_expr_stmt = nil
     end
 
     private
-    def enter_expression_statement(node)
-      @in_expression_statement = true
+    def enter_expression_statement(expr_stmt)
+      case expr_stmt.expression
+      when C::SimpleAssignmentExpression, C::CompoundAssignmentExpression,
+           C::FunctionCallExpression
+        @current_expr_stmt = nil
+      else
+        @current_expr_stmt = expr_stmt
+      end
     end
 
-    def leave_expression_statement(node)
-      @in_expression_statement = false
+    def leave_expression_statement(*)
+      @current_expr_stmt = nil
     end
 
-    def check(node)
-      if @in_expression_statement
-        unless node.rhs_operand.have_side_effect?
-          W(:W0088, node.operator.location)
+    def check(binary_expr, *)
+      if @current_expr_stmt
+        unless binary_expr.rhs_operand.have_side_effect?
+          W(:W0088, binary_expr.operator.location)
         end
-        @in_expression_statement = false
       end
     end
   end
@@ -2023,7 +2029,7 @@ module CBuiltin #:nodoc:
       if rhs_pointee = @interp.pointee_of(rhs_variable)
         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
+          # NOTE: An array typed parameter can be considered 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?
@@ -2092,7 +2098,7 @@ module CBuiltin #:nodoc:
       if rhs_pointee = @interp.pointee_of(rhs_variable)
         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
+          # NOTE: An array typed parameter can be considered 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?
@@ -2140,7 +2146,7 @@ module CBuiltin #: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
+          # NOTE: An array typed parameter can be considered 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?
@@ -2290,7 +2296,7 @@ module CBuiltin #:nodoc:
       if rhs_pointee = @interp.pointee_of(rhs_variable)
         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
+          # NOTE: An array typed parameter can be considered 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?
@@ -11462,11 +11468,14 @@ module CBuiltin #:nodoc:
   class W0582 < PassiveCodeCheck
     def_registrant_phase C::Prepare2Phase
 
+    include C::Conversion
+
     def initialize(context)
       super
       interp = context[:c_interpreter]
       interp.on_function_call_expr_evaled += method(:call_function)
       interp.on_function_declared += method(:check)
+      @enum_tbl = interp.environment.enumerator_table
       @function_calls = Hash.new { |hash, key| hash[key] = [] }
     end
 
@@ -11477,23 +11486,26 @@ module CBuiltin #:nodoc:
 
       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|
+      @function_calls[function.name].each do |funcall_expr, args|
+        if args.size == param_types.size
+          types = args.map { |ary| ary.first }.zip(param_types)
+          conformed = types.each_with_index.all? { |(atype, ptype), index|
+            funcall_expr.argument_expressions[index].constant?(@enum_tbl) &&
+              untyped_pointer_conversion?(atype, ptype, args[index].last) or
             atype.convertible?(ptype)
           }
         else
           conformed = false
         end
 
-        W(:W0582, expr.location) unless conformed
+        W(:W0582, funcall_expr.location) unless conformed
       end
     end
 
-    def call_function(expression, function, arg_variables, result_variable)
+    def call_function(funcall_expr, function, arg_vars, result_var)
       if function.named?
-        arg_types = arg_variables.map { |var| var.type }
-        @function_calls[function.name].push([expression, arg_types])
+        args = arg_vars.map { |var| [var.type, var.value.to_single_value] }
+        @function_calls[function.name].push([funcall_expr, args])
       end
     end
   end
@@ -11501,11 +11513,14 @@ module CBuiltin #:nodoc:
   class W0583 < PassiveCodeCheck
     def_registrant_phase C::Prepare2Phase
 
+    include C::Conversion
+
     def initialize(context)
       super
       interp = context[:c_interpreter]
       interp.on_function_call_expr_evaled += method(:call_function)
       interp.on_function_defined += method(:check)
+      @enum_tbl = interp.environment.enumerator_table
       @function_calls = Hash.new { |hash, key| hash[key] = [] }
     end
 
@@ -11516,23 +11531,26 @@ module CBuiltin #:nodoc:
 
       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|
+      @function_calls[function.name].each do |funcall_expr, args|
+        if args.size == param_types.size
+          types = args.map { |ary| ary.first }.zip(param_types)
+          conformed = types.each_with_index.all? { |(atype, ptype), index|
+            funcall_expr.argument_expressions[index].constant?(@enum_tbl) &&
+              untyped_pointer_conversion?(atype, ptype, args[index].last) or
             atype.convertible?(ptype)
           }
         else
           conformed = false
         end
 
-        W(:W0583, expr.location) unless conformed
+        W(:W0583, funcall_expr.location) unless conformed
       end
     end
 
-    def call_function(expression, function, arg_variables, result_variable)
+    def call_function(funcall_expr, function, arg_vars, result_var)
       if function.named?
-        arg_types = arg_variables.map { |var| var.type }
-        @function_calls[function.name].push([expression, arg_types])
+        args = arg_vars.map { |var| [var.type, var.value.to_single_value] }
+        @function_calls[function.name].push([funcall_expr, args])
       end
     end
   end
@@ -11540,27 +11558,34 @@ module CBuiltin #:nodoc:
   class W0584 < PassiveCodeCheck
     def_registrant_phase C::Prepare2Phase
 
+    include C::Conversion
+
     def initialize(context)
       super
       interp = context[:c_interpreter]
       interp.on_function_call_expr_evaled += method(:check)
+      @enum_tbl = interp.environment.enumerator_table
     end
 
     private
-    def check(expression, function, arg_variables, result_variable)
+    def check(funcall_expr, function, arg_vars, result_var)
       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 }
+      args = arg_vars.map { |var| [var.type, var.value.to_single_value] }
       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|
-          unless atype.convertible?(ptype)
-            W(:W0584,
-              expression.argument_expressions[index].location, index + 1)
-          end
+      return unless args.size == param_types.size
+
+      args.zip(param_types).each_with_index do |(arg, ptype), index|
+        arg_expr = funcall_expr.argument_expressions[index]
+        if arg_expr.constant?(@enum_tbl)
+          next if untyped_pointer_conversion?(arg.first, ptype, arg.last)
+        end
+
+        unless arg.first.convertible?(ptype)
+          W(:W0584, arg_expr.location, index + 1)
         end
       end
     end
@@ -11928,6 +11953,8 @@ module CBuiltin #:nodoc:
   class W0609 < PassiveCodeCheck
     def_registrant_phase C::Prepare2Phase
 
+    include C::SyntaxNodeCollector
+
     def initialize(context)
       super
       interp = context[:c_interpreter]
@@ -11935,12 +11962,46 @@ module CBuiltin #:nodoc:
       interp.on_equality_expr_evaled += method(:check)
       interp.on_logical_and_expr_evaled += method(:check)
       interp.on_logical_or_expr_evaled += method(:check)
+      interp.on_for_stmt_started += method(:enter_for_statement)
+      interp.on_c99_for_stmt_started += method(:enter_for_statement)
+      interp.on_for_stmt_ended += method(:leave_for_statement)
+      interp.on_c99_for_stmt_ended += method(:leave_for_statement)
+      interp.on_for_ctrlexpr_evaled += method(:memorize_for_ctrlexpr)
+      interp.on_c99_for_ctrlexpr_evaled += method(:memorize_for_ctrlexpr)
+      @for_ctrlexpr_stack = []
     end
 
     private
     def check(binary_expression, lhs_variable, rhs_variable, result_variable)
       if result_variable.value.must_be_true?
-        W(:W0609, binary_expression.location)
+        unless should_not_check?(binary_expression)
+          W(:W0609, binary_expression.location)
+        end
+      end
+    end
+
+    def enter_for_statement(for_statement)
+      @for_ctrlexpr_stack.push(nil)
+    end
+
+    def leave_for_statement(*)
+      @for_ctrlexpr_stack.pop
+    end
+
+    def memorize_for_ctrlexpr(for_statement, *)
+      if explicit_ctrlexpr = for_statement.condition_statement.expression
+        @for_ctrlexpr_stack[-1] = explicit_ctrlexpr
+      end
+    end
+
+    def should_not_check?(expr)
+      if ctrlexpr = @for_ctrlexpr_stack.last
+        collect_relational_expressions(ctrlexpr).include?(expr)  ||
+        collect_equality_expressions(ctrlexpr).include?(expr)    ||
+        collect_logical_and_expressions(ctrlexpr).include?(expr) ||
+        collect_logical_or_expressions(ctrlexpr).include?(expr)
+      else
+        false
       end
     end
   end
@@ -11948,6 +12009,8 @@ module CBuiltin #:nodoc:
   class W0610 < PassiveCodeCheck
     def_registrant_phase C::Prepare2Phase
 
+    include C::SyntaxNodeCollector
+
     def initialize(context)
       super
       interp = context[:c_interpreter]
@@ -11955,12 +12018,46 @@ module CBuiltin #:nodoc:
       interp.on_equality_expr_evaled += method(:check)
       interp.on_logical_and_expr_evaled += method(:check)
       interp.on_logical_or_expr_evaled += method(:check)
+      interp.on_for_stmt_started += method(:enter_for_statement)
+      interp.on_c99_for_stmt_started += method(:enter_for_statement)
+      interp.on_for_stmt_ended += method(:leave_for_statement)
+      interp.on_c99_for_stmt_ended += method(:leave_for_statement)
+      interp.on_for_ctrlexpr_evaled += method(:memorize_for_ctrlexpr)
+      interp.on_c99_for_ctrlexpr_evaled += method(:memorize_for_ctrlexpr)
+      @for_ctrlexpr_stack = []
     end
 
     private
     def check(binary_expression, lhs_variable, rhs_variable, result_variable)
       if result_variable.value.must_be_false?
-        W(:W0610, binary_expression.location)
+        unless should_not_check?(binary_expression)
+          W(:W0610, binary_expression.location)
+        end
+      end
+    end
+
+    def enter_for_statement(for_statement)
+      @for_ctrlexpr_stack.push(nil)
+    end
+
+    def leave_for_statement(*)
+      @for_ctrlexpr_stack.pop
+    end
+
+    def memorize_for_ctrlexpr(for_statement, *)
+      if explicit_ctrlexpr = for_statement.condition_statement.expression
+        @for_ctrlexpr_stack[-1] = explicit_ctrlexpr
+      end
+    end
+
+    def should_not_check?(expr)
+      if ctrlexpr = @for_ctrlexpr_stack.last
+        collect_relational_expressions(ctrlexpr).include?(expr)  ||
+        collect_equality_expressions(ctrlexpr).include?(expr)    ||
+        collect_logical_and_expressions(ctrlexpr).include?(expr) ||
+        collect_logical_or_expressions(ctrlexpr).include?(expr)
+      else
+        false
       end
     end
   end
@@ -14520,7 +14617,7 @@ module CBuiltin #:nodoc:
       when "+"
         unbound_value = lhs_variable.value + rhs_variable.value
       when "-"
-        unbound_value = lhs_variable.value + rhs_variable.value
+        unbound_value = lhs_variable.value - rhs_variable.value
       when "*"
         unbound_value = lhs_variable.value * rhs_variable.value
       else
@@ -18051,25 +18148,44 @@ module CBuiltin #:nodoc:
   class W9003 < PassiveCodeCheck
     def_registrant_phase C::Prepare2Phase
 
+    include C::Conversion
+
     def initialize(context)
       super
       interp = context[:c_interpreter]
       interp.on_implicit_conv_performed += method(:check)
+      @enum_tbl = interp.environment.enumerator_table
     end
 
     private
-    def check(initializer_or_expression, original_variable, result_variable)
-      from_type = original_variable.type
-      to_type = result_variable.type
+    def check(init_or_expr, orig_var, result_var)
+      from_type = orig_var.type
+      to_type = result_var.type
 
       if from_type.undeclared? || from_type.unresolved? ||
           to_type.undeclared? || to_type.unresolved?
         return
       end
 
+      case init_or_expr
+      when C::Initializer
+        if expr = init_or_expr.expression and expr.constant?(@enum_tbl)
+          if untyped_pointer_conversion?(from_type, to_type, orig_var.value)
+            return
+          end
+        end
+      when C::Expression
+        if init_or_expr.constant?(@enum_tbl)
+          if untyped_pointer_conversion?(from_type, to_type, orig_var.value)
+            return
+          end
+        end
+      end
+
       unless from_type.standard? && to_type.standard?
         unless from_type.convertible?(to_type)
-          W(:W9003, initializer_or_expression.location, from_type.brief_image)
+          W(:W9003, init_or_expr.location,
+            from_type.brief_image, to_type.brief_image)
         end
       end
     end

data/lib/adlint/version.rb

@@ -32,9 +32,9 @@
 module AdLint #:nodoc:
 
   MAJOR_VERSION = 2
-  MINOR_VERSION = 4
-  PATCH_VERSION = 10
-  RELEASE_DATE  = "2012-10-15"
+  MINOR_VERSION = 6
+  PATCH_VERSION = 0
+  RELEASE_DATE  = "2012-10-22"
 
   TRAITS_SCHEMA_VERSION = "2.4.0"