adlint 1.4.0 → 1.6.0

data/lib/adlint/c/interp.rb

@@ -127,7 +127,7 @@ module C #:nodoc:
 
     # NOTE: Notified when the interpreter evaluates an expression which results
     #       a named variable.
-    def_plugin_and_notifier :variable_referred, :object_specifier, :variable
+    def_plugin_and_notifier :variable_referred, :expression, :variable
 
     # NOTE: Notified when the interpreter evaluates an expression which results
     #       a constant temporary variable.

data/lib/adlint/c/mediator.rb

@@ -31,6 +31,7 @@
 
 require "adlint/c/type"
 require "adlint/c/object"
+require "adlint/c/enum"
 require "adlint/c/syntax"
 
 module AdLint #:nodoc:

data/lib/adlint/c/message.rb

@@ -440,6 +440,9 @@ module C #:nodoc:
     private
     def check_comparison(binary_expression,
                          lhs_variable, rhs_variable, result)
+      return if binary_expression.lhs_operand.kind_of?(NullConstantSpecifier)
+      return if binary_expression.rhs_operand.kind_of?(NullConstantSpecifier)
+
       if lhs_variable.type.pointer? || rhs_variable.type.pointer?
         W(:W0027, binary_expression.location)
       end
@@ -453,11 +456,12 @@ module C #:nodoc:
       interp.on_indirection_expr_evaled += method(:check_indirection)
       interp.on_member_access_expr_evaled += method(:check_member_access)
       interp.on_array_subscript_expr_evaled += method(:check_array_subscript)
+      @enum_tbl = interp.environment.enumerator_table
     end
 
     private
     def check_indirection(indirection_expression, variable, dereferenced)
-      return unless indirection_expression.operand.constant?
+      return unless indirection_expression.operand.constant?(@enum_tbl)
 
       if variable.value.scalar? &&
           variable.value.must_be_equal_to?(ScalarValue.of(0))
@@ -468,7 +472,7 @@ module C #:nodoc:
     def check_member_access(member_access_expression,
                             outer_variable, member_variable)
       return unless outer_variable.type.pointer?
-      return unless member_access_expression.expression.constant?
+      return unless member_access_expression.expression.constant?(@enum_tbl)
       if outer_variable.value.scalar? &&
           outer_variable.value.must_be_equal_to?(ScalarValue.of(0))
         W(:W0028, member_access_expression.location)
@@ -479,7 +483,7 @@ module C #:nodoc:
                               pointer_variable, subscript_variable,
                               array_variable, result_variable)
       return unless pointer_variable.type.pointer?
-      return unless array_subscript_expression.expression.constant?
+      return unless array_subscript_expression.expression.constant?(@enum_tbl)
       if pointer_variable.value.scalar? &&
           pointer_variable.value.must_be_equal_to?(ScalarValue.of(0))
         W(:W0028, array_subscript_expression.location)
@@ -501,6 +505,7 @@ module C #:nodoc:
       interp.on_postfix_increment_expr_evaled += method(:check_unary_postfix)
       interp.on_prefix_decrement_expr_evaled += method(:check_unary_prefix)
       interp.on_postfix_decrement_expr_evaled += method(:check_unary_postfix)
+      @enum_tbl = interp.environment.enumerator_table
     end
 
     private
@@ -508,12 +513,12 @@ module C #:nodoc:
       lhs_type, lhs_value = lhs_variable.type, lhs_variable.value
       rhs_type, rhs_value = rhs_variable.type, rhs_variable.value
 
-      if binary_expression.lhs_operand.constant? &&
+      if binary_expression.lhs_operand.constant?(@enum_tbl) &&
           lhs_type.pointer? && lhs_value.must_be_equal_to?(ScalarValue.of(0))
         W(:W0030, binary_expression.lhs_operand.location)
       end
 
-      if binary_expression.rhs_operand.constant? &&
+      if binary_expression.rhs_operand.constant?(@enum_tbl) &&
           rhs_type.pointer? && rhs_value.must_be_equal_to?(ScalarValue.of(0))
         W(:W0030, binary_expression.rhs_operand.location)
       end
@@ -522,7 +527,7 @@ module C #:nodoc:
     def check_unary_prefix(unary_expression, operand_variable, original_value)
       type, value = operand_variable.type, original_value
 
-      if unary_expression.operand.constant? &&
+      if unary_expression.operand.constant?(@enum_tbl) &&
           type.pointer? && value.must_be_equal_to?(ScalarValue.of(0))
         W(:W0030, unary_expression.operand.location)
       end
@@ -532,7 +537,7 @@ module C #:nodoc:
                             operand_variable, result_variable)
       type, value = operand_variable.type, operand_variable.value
 
-      if postfix_expression.operand.constant? &&
+      if postfix_expression.operand.constant?(@enum_tbl) &&
           type.pointer? && value.must_be_equal_to?(ScalarValue.of(0))
         W(:W0030, postfix_expression.operand.location)
       end
@@ -546,6 +551,7 @@ module C #:nodoc:
       interp.on_function_started += method(:start_function)
       interp.on_parameter_defined += method(:add_parameter)
       interp.on_variable_referred += method(:use_parameter)
+      interp.on_variable_value_referred += method(:use_parameter)
       interp.on_function_ended += method(:check_unused_parameter)
       @parameters = nil
     end
@@ -563,7 +569,7 @@ module C #:nodoc:
       end
     end
 
-    def use_parameter(object_specifier, variable)
+    def use_parameter(expression, variable)
       return unless @parameters
 
       if variable.named?
@@ -1773,12 +1779,13 @@ module C #:nodoc:
       super
       interp = context[:c_interpreter]
       interp.on_multiplicative_expr_evaled += method(:check)
+      @enum_tbl = interp.environment.enumerator_table
     end
 
     private
     def check(multiplicative_expression, lhs_variable, rhs_variable, result)
       return if multiplicative_expression.operator.type == "*"
-      return if multiplicative_expression.rhs_operand.constant?
+      return if multiplicative_expression.rhs_operand.constant?(@enum_tbl)
 
       return unless rhs_variable.type.scalar? && rhs_variable.value.scalar?
       return if rhs_variable.value.must_be_equal_to?(ScalarValue.of(0))
@@ -1794,12 +1801,13 @@ module C #:nodoc:
       super
       interp = context[:c_interpreter]
       interp.on_multiplicative_expr_evaled += method(:check)
+      @enum_tbl = interp.environment.enumerator_table
     end
 
     private
     def check(multiplicative_expression, lhs_variable, rhs_variable, result)
       return if multiplicative_expression.operator.type == "*"
-      return unless multiplicative_expression.rhs_operand.constant?
+      return unless multiplicative_expression.rhs_operand.constant?(@enum_tbl)
 
       return unless rhs_variable.type.scalar? && rhs_variable.value.scalar?
 
@@ -1814,12 +1822,13 @@ module C #:nodoc:
       super
       interp = context[:c_interpreter]
       interp.on_multiplicative_expr_evaled += method(:check)
+      @enum_tbl = interp.environment.enumerator_table
     end
 
     private
     def check(multiplicative_expression, lhs_variable, rhs_variable, result)
       return if multiplicative_expression.operator.type == "*"
-      return if multiplicative_expression.rhs_operand.constant?
+      return if multiplicative_expression.rhs_operand.constant?(@enum_tbl)
 
       return unless rhs_variable.type.scalar? && rhs_variable.value.scalar?
 
@@ -2059,6 +2068,8 @@ module C #:nodoc:
 
       @parameters.each do |name, (written, variable, location)|
         next if variable.type.const?
+        next if variable.type.array? && variable.type.base_type.const?
+
         W(:W0104, location, name) unless written
       end
 
@@ -6041,11 +6052,12 @@ module C #:nodoc:
       interp.on_indirection_expr_evaled += method(:check_indirection)
       interp.on_member_access_expr_evaled += method(:check_member_access)
       interp.on_array_subscript_expr_evaled += method(:check_array_subscript)
+      @enum_tbl = interp.environment.enumerator_table
     end
 
     private
     def check_indirection(indirection_expression, variable, dereferenced)
-      return if indirection_expression.operand.constant?
+      return if indirection_expression.operand.constant?(@enum_tbl)
       if variable.value.scalar? &&
           variable.value.must_be_equal_to?(ScalarValue.of(0))
         W(:W0421, indirection_expression.location)
@@ -6055,7 +6067,7 @@ module C #:nodoc:
     def check_member_access(member_access_expression,
                             outer_variable, member_variable)
       return unless outer_variable.type.pointer?
-      return if member_access_expression.expression.constant?
+      return if member_access_expression.expression.constant?(@enum_tbl)
       if outer_variable.value.scalar? &&
           outer_variable.value.must_be_equal_to?(ScalarValue.of(0))
         W(:W0421, member_access_expression.location)
@@ -6066,7 +6078,7 @@ module C #:nodoc:
                               pointer_variable, subscript_variable,
                               array_variable, result_variable)
       return unless pointer_variable.type.pointer?
-      return if array_subscript_expression.expression.constant?
+      return if array_subscript_expression.expression.constant?(@enum_tbl)
       if pointer_variable.value.scalar? &&
           pointer_variable.value.must_be_equal_to?(ScalarValue.of(0))
         W(:W0421, array_subscript_expression.location)
@@ -6081,11 +6093,12 @@ module C #:nodoc:
       interp.on_indirection_expr_evaled += method(:check_indirection)
       interp.on_member_access_expr_evaled += method(:check_member_access)
       interp.on_array_subscript_expr_evaled += method(:check_array_subscript)
+      @enum_tbl = interp.environment.enumerator_table
     end
 
     private
     def check_indirection(indirection_expression, variable, dereferenced)
-      return if indirection_expression.operand.constant?
+      return if indirection_expression.operand.constant?(@enum_tbl)
       return unless variable.value.scalar?
 
       if !variable.value.must_be_equal_to?(ScalarValue.of(0)) &&
@@ -6097,7 +6110,7 @@ module C #:nodoc:
     def check_member_access(member_access_expression,
                             outer_variable, member_variable)
       return unless outer_variable.type.pointer?
-      return if member_access_expression.expression.constant?
+      return if member_access_expression.expression.constant?(@enum_tbl)
       return unless outer_variable.value.scalar?
 
       if !outer_variable.value.must_be_equal_to?(ScalarValue.of(0)) &&
@@ -6110,7 +6123,7 @@ module C #:nodoc:
                               pointer_variable, subscript_variable,
                               array_variable, result_variable)
       return unless pointer_variable.type.pointer?
-      return if array_subscript_expression.expression.constant?
+      return if array_subscript_expression.expression.constant?(@enum_tbl)
       return unless pointer_variable.value.scalar?
 
       if !pointer_variable.value.must_be_equal_to?(ScalarValue.of(0)) &&
@@ -7029,7 +7042,7 @@ module C #:nodoc:
         base_type = type.unqualify.base_type
         next unless !base_type.function? && base_type.const?
 
-        if pointee = @interp.pointee_of(arg)
+        if pointee = @interp.pointee_of(arg) and pointee.variable?
           if pointee.value.must_be_undefined?
             W(:W0461,
               function_call_expression.argument_expressions[index].location)
@@ -7055,7 +7068,7 @@ module C #:nodoc:
         next unless type && type.pointer?
         next unless type.unqualify.base_type.const?
 
-        if pointee = @interp.pointee_of(arg)
+        if pointee = @interp.pointee_of(arg) and pointee.variable?
           next if pointee.value.must_be_undefined?
           if pointee.value.may_be_undefined?
             W(:W0462,
@@ -10048,6 +10061,7 @@ module C #:nodoc:
       super
       interp = context[:c_interpreter]
       interp.on_shift_expr_evaled += method(:check)
+      @enum_tbl = interp.environment.enumerator_table
     end
 
     private
@@ -10055,7 +10069,7 @@ module C #:nodoc:
       operator = shift_expression.operator.type
       return unless operator == "<<" || operator == "<<="
 
-      return unless shift_expression.lhs_operand.constant?
+      return unless shift_expression.lhs_operand.constant?(@enum_tbl)
       return unless lhs_variable.type.signed?
 
       if lhs_variable.value.must_be_less_than?(ScalarValue.of(0)) or
@@ -10076,6 +10090,7 @@ module C #:nodoc:
       super
       interp = context[:c_interpreter]
       interp.on_shift_expr_evaled += method(:check)
+      @enum_tbl = interp.environment.enumerator_table
     end
 
     private
@@ -10083,7 +10098,7 @@ module C #:nodoc:
       operator = shift_expression.operator.type
       return unless operator == "<<" || operator == "<<="
 
-      return if shift_expression.lhs_operand.constant?
+      return if shift_expression.lhs_operand.constant?(@enum_tbl)
       return unless lhs_variable.type.signed?
 
       if lhs_variable.value.must_be_less_than?(ScalarValue.of(0)) or
@@ -10104,6 +10119,7 @@ module C #:nodoc:
       super
       interp = context[:c_interpreter]
       interp.on_shift_expr_evaled += method(:check)
+      @enum_tbl = interp.environment.enumerator_table
     end
 
     private
@@ -10111,7 +10127,7 @@ module C #:nodoc:
       operator = shift_expression.operator.type
       return unless operator == "<<" || operator == "<<="
 
-      return if shift_expression.lhs_operand.constant?
+      return if shift_expression.lhs_operand.constant?(@enum_tbl)
       return unless lhs_variable.type.signed?
 
       if !lhs_variable.value.must_be_less_than?(ScalarValue.of(0)) &&
@@ -10211,7 +10227,7 @@ module C #:nodoc:
       if src_type.integer_conversion_rank < dst_type.integer_conversion_rank
         case @rvalues[original_variable]
         when UnaryArithmeticExpression, ShiftExpression,
-          AdditiveExpression, MultiplicativeExpression
+             AdditiveExpression, MultiplicativeExpression
           W(:W0578, initializer_or_expression.location)
         end
       end
@@ -10249,6 +10265,68 @@ module C #:nodoc:
     end
   end
 
+  class W0579 < PassiveMessageDetection
+    def initialize(context)
+      super
+      interp = context[:c_interpreter]
+      interp.on_explicit_conv_performed += method(:check)
+      interp.on_function_started += method(:clear_rvalues)
+      interp.on_unary_arithmetic_expr_evaled += method(:handle_unary)
+      interp.on_shift_expr_evaled += method(:handle_shift)
+      interp.on_additive_expr_evaled += method(:handle_additive)
+      interp.on_multiplicative_expr_evaled += method(:handle_multiplicative)
+      @rvalues = nil
+    end
+
+    private
+    def check(cast_expression, original_variable, result_variable)
+      return unless @rvalues
+      return unless original_variable.type.integer?
+
+      src_type = original_variable.type
+      dst_type = result_variable.type
+
+      if src_type.integer_conversion_rank < dst_type.integer_conversion_rank
+        case @rvalues[original_variable]
+        when UnaryArithmeticExpression, ShiftExpression,
+             AdditiveExpression, MultiplicativeExpression
+          W(:W0579, cast_expression.location)
+        end
+      end
+    end
+
+    def clear_rvalues(function_definition)
+      @rvalues = {}
+    end
+
+    def handle_unary(unary_arithmetic_expression,
+                     operand_variable, result_variable)
+      return unless unary_arithmetic_expression.operator == "~"
+      memorize_rvalue_derivation(result_variable, unary_arithmetic_expression)
+    end
+
+    def handle_shift(shift_expression,
+                     lhs_variable, rhs_variable, result_variable)
+      return unless shift_expression.operator.type == "<<"
+      memorize_rvalue_derivation(result_variable, shift_expression)
+    end
+
+    def handle_additive(additive_expression,
+                        lhs_variable, rhs_variable, result_variable)
+      memorize_rvalue_derivation(result_variable, additive_expression)
+    end
+
+    def handle_multiplicative(multiplicative_expression,
+                              lhs_variable, rhs_variable, result_variable)
+      return if multiplicative_expression.operator.type == "%"
+      memorize_rvalue_derivation(result_variable, multiplicative_expression)
+    end
+
+    def memorize_rvalue_derivation(rvalue_holder, expression)
+      @rvalues[rvalue_holder] = expression if @rvalues
+    end
+  end
+
   class W0580 < PassiveMessageDetection
     def initialize(context)
       super
@@ -10767,6 +10845,7 @@ module C #:nodoc:
       interp.on_do_stmt_ended += method(:check)
       interp.on_for_stmt_ended += method(:check)
       interp.on_c99_for_stmt_ended += method(:check)
+      @enum_tbl = interp.environment.enumerator_table
       @iteration_stmts = []
     end
 
@@ -10820,12 +10899,14 @@ module C #:nodoc:
     end
 
     def check(iteration_statement)
-      if ctrlexpr = @iteration_stmts.last.ctrlexpr and !ctrlexpr.constant?
-        ctrlexpr_value = @iteration_stmts.last.ctrlexpr_value
-        ctrl_vars = @iteration_stmts.last.ctrl_vars
-        if ctrlexpr_value && ctrlexpr_value.must_be_true? and
-            ctrl_vars && ctrl_vars.values.none?
-          W(:W0611, ctrlexpr.location)
+      if ctrlexpr = @iteration_stmts.last.ctrlexpr
+        unless ctrlexpr.constant?(@enum_tbl)
+          ctrlexpr_value = @iteration_stmts.last.ctrlexpr_value
+          ctrl_vars = @iteration_stmts.last.ctrl_vars
+          if ctrlexpr_value && ctrlexpr_value.must_be_true? and
+              ctrl_vars && ctrl_vars.values.none?
+            W(:W0611, ctrlexpr.location)
+          end
         end
       end
       @iteration_stmts.pop
@@ -10838,13 +10919,14 @@ module C #:nodoc:
       interp = context[:c_interpreter]
       interp.on_if_ctrlexpr_evaled += method(:check)
       interp.on_if_else_ctrlexpr_evaled += method(:check)
+      @enum_tbl = interp.environment.enumerator_table
     end
 
     private
     def check(selection_statement, ctrlexpr_value)
-      if ctrlexpr = selection_statement.expression and !ctrlexpr.constant?
-        if ctrlexpr_value.must_be_true?
-          W(:W0612, ctrlexpr.location)
+      if ctrlexpr = selection_statement.expression
+        unless ctrlexpr.constant?(@enum_tbl)
+          W(:W0612, ctrlexpr.location) if ctrlexpr_value.must_be_true?
         end
       end
     end
@@ -10902,11 +10984,12 @@ module C #:nodoc:
       super
       interp = context[:c_interpreter]
       interp.on_do_ctrlexpr_evaled += method(:check)
+      @enum_tbl = interp.environment.enumerator_table
     end
 
     private
     def check(do_statement, ctrlexpr_value)
-      unless do_statement.expression.constant?
+      unless do_statement.expression.constant?(@enum_tbl)
         if ctrlexpr_value.must_be_false?
           W(:W0614, do_statement.expression.location)
         end
@@ -12406,7 +12489,8 @@ module C #:nodoc:
 
       value = original_variable.value.unique_sample
 
-      unless result_variable.type.enumerators.any? { |enum| value == enum.value }
+      enumerators = result_variable.type.enumerators
+      unless enumerators.any? { |enum| value == enum.value }
         W(:W0727, initializer_or_expression.location)
       end
     end
@@ -12417,6 +12501,7 @@ module C #:nodoc:
       super
       interp = context[:c_interpreter]
       interp.on_function_call_expr_evaled += method(:check)
+      @enum_tbl = interp.environment.enumerator_table
     end
 
     private
@@ -12425,9 +12510,12 @@ module C #:nodoc:
       args.each_with_index do |(arg_variable, param_type), index|
         next unless param_type && param_type.enum?
 
+        arg_expr = expression.argument_expressions[index]
+        next unless arg_expr.constant?(@enum_tbl)
+
         if arg_variable.type.enum?
           unless arg_variable.type.same_as?(param_type)
-            W(:W0728, expression.argument_expressions[index].location)
+            W(:W0728, arg_expr.location)
           end
         end
       end
@@ -12439,11 +12527,13 @@ module C #:nodoc:
       super
       interp = context[:c_interpreter]
       interp.on_assignment_expr_evaled += method(:check)
+      @enum_tbl = interp.environment.enumerator_table
     end
 
     private
     def check(expression, lhs_variable, rhs_variable)
       return unless lhs_variable.type.enum?
+      return unless expression.rhs_operand.constant?(@enum_tbl)
 
       if rhs_variable.type.enum?
         unless lhs_variable.type.same_as?(rhs_variable.type)
@@ -12460,6 +12550,7 @@ module C #:nodoc:
       interp.on_function_started += method(:start_function)
       interp.on_function_ended += method(:end_function)
       interp.on_return_stmt_evaled += method(:check)
+      @enum_tbl = interp.environment.enumerator_table
       @current_function = nil
     end
 
@@ -12477,6 +12568,7 @@ module C #:nodoc:
 
       return unless return_type = @current_function.type.return_type
       return unless return_type.enum?
+      return unless return_statement.expression.constant?(@enum_tbl)
 
       if result_variable.type.enum?
         unless return_type.same_as?(result_variable.type)
@@ -12593,6 +12685,7 @@ module C #:nodoc:
       super
       interp = context[:c_interpreter]
       interp.on_implicit_conv_performed += method(:check)
+      @enum_tbl = interp.environment.enumerator_table
     end
 
     private
@@ -12606,7 +12699,7 @@ module C #:nodoc:
         expression = initializer_or_expression
       end
 
-      return unless expression.constant?
+      return unless expression.constant?(@enum_tbl)
 
       orig_type = original_variable.type
       conv_type = result_variable.type
@@ -12630,14 +12723,15 @@ module C #:nodoc:
       super
       interp = context[:c_interpreter]
       interp.on_additive_expr_evaled += method(:check)
+      @enum_tbl = interp.environment.enumerator_table
     end
 
     private
     def check(additive_expression, lhs_variable, rhs_variable, result_variable)
       return unless additive_expression.operator.type == "-"
 
-      return unless additive_expression.lhs_operand.constant?
-      return unless additive_expression.rhs_operand.constant?
+      return unless additive_expression.lhs_operand.constant?(@enum_tbl)
+      return unless additive_expression.rhs_operand.constant?(@enum_tbl)
 
       return unless lhs_variable.type.scalar? && lhs_variable.type.unsigned?
       return unless rhs_variable.type.scalar? && rhs_variable.type.unsigned?
@@ -12658,14 +12752,15 @@ module C #:nodoc:
       super
       interp = context[:c_interpreter]
       interp.on_additive_expr_evaled += method(:check)
+      @enum_tbl = interp.environment.enumerator_table
     end
 
     private
     def check(additive_expression, lhs_variable, rhs_variable, result_variable)
       return unless additive_expression.operator.type == "+"
 
-      return unless additive_expression.lhs_operand.constant?
-      return unless additive_expression.rhs_operand.constant?
+      return unless additive_expression.lhs_operand.constant?(@enum_tbl)
+      return unless additive_expression.rhs_operand.constant?(@enum_tbl)
 
       return unless lhs_variable.type.scalar? && lhs_variable.type.unsigned?
       return unless rhs_variable.type.scalar? && rhs_variable.type.unsigned?
@@ -12686,6 +12781,7 @@ module C #:nodoc:
       super
       interp = context[:c_interpreter]
       interp.on_multiplicative_expr_evaled += method(:check)
+      @enum_tbl = interp.environment.enumerator_table
     end
 
     private
@@ -12693,8 +12789,8 @@ module C #:nodoc:
               result_variable)
       return unless multiplicative_expression.operator.type == "*"
 
-      return unless multiplicative_expression.lhs_operand.constant?
-      return unless multiplicative_expression.rhs_operand.constant?
+      return unless multiplicative_expression.lhs_operand.constant?(@enum_tbl)
+      return unless multiplicative_expression.rhs_operand.constant?(@enum_tbl)
 
       return unless lhs_variable.type.scalar? && lhs_variable.type.unsigned?
       return unless rhs_variable.type.scalar? && rhs_variable.type.unsigned?
@@ -12715,6 +12811,7 @@ module C #:nodoc:
       super
       interp = context[:c_interpreter]
       interp.on_implicit_conv_performed += method(:check)
+      @enum_tbl = interp.environment.enumerator_table
     end
 
     private
@@ -12730,7 +12827,7 @@ module C #:nodoc:
         expression = initializer_or_expression
       end
 
-      if expression && expression.constant? &&
+      if expression && expression.constant?(@enum_tbl) &&
           original_variable.value.must_be_less_than?(ScalarValue.of(0))
         W(:W0742, expression.location)
       end
@@ -12742,6 +12839,7 @@ module C #:nodoc:
       super
       interp = context[:c_interpreter]
       interp.on_implicit_conv_performed += method(:check)
+      @enum_tbl = interp.environment.enumerator_table
     end
 
     private
@@ -12755,7 +12853,7 @@ module C #:nodoc:
         expression = initializer_or_expression
       end
 
-      return unless expression.constant?
+      return unless expression.constant?(@enum_tbl)
 
       orig_type = original_variable.type
       conv_type = result_variable.type
@@ -12786,40 +12884,41 @@ module C #:nodoc:
       interp.on_while_ctrlexpr_evaled += method(:check_while_statement)
       interp.on_for_ctrlexpr_evaled += method(:check_for_statement)
       interp.on_c99_for_ctrlexpr_evaled += method(:check_c99_for_statement)
+      @enum_tbl = interp.environment.enumerator_table
     end
 
     private
     def check_if_statement(if_statement, ctrlexpr_value)
       ctrlexpr = if_statement.expression
-      if ctrlexpr.constant? && ctrlexpr_value.must_be_false?
+      if ctrlexpr.constant?(@enum_tbl) && ctrlexpr_value.must_be_false?
         W(:W0744, ctrlexpr.location)
       end
     end
 
     def check_if_else_statement(if_else_statement, ctrlexpr_value)
       ctrlexpr = if_else_statement.expression
-      if ctrlexpr.constant? && ctrlexpr_value.must_be_false?
+      if ctrlexpr.constant?(@enum_tbl) && ctrlexpr_value.must_be_false?
         W(:W0744, ctrlexpr.location)
       end
     end
 
     def check_while_statement(while_statement, ctrlexpr_value)
       ctrlexpr = while_statement.expression
-      if ctrlexpr.constant? && ctrlexpr_value.must_be_false?
+      if ctrlexpr.constant?(@enum_tbl) && ctrlexpr_value.must_be_false?
         W(:W0744, ctrlexpr.location)
       end
     end
 
     def check_for_statement(for_statement, ctrlexpr_value)
       ctrlexpr = for_statement.condition_statement.expression
-      if ctrlexpr.constant? && ctrlexpr_value.must_be_false?
+      if ctrlexpr.constant?(@enum_tbl) && ctrlexpr_value.must_be_false?
         W(:W0744, ctrlexpr.location)
       end
     end
 
     def check_c99_for_statement(c99_for_statement, ctrlexpr_value)
       ctrlexpr = c99_for_statement.condition_statement.expression
-      if ctrlexpr.constant? && ctrlexpr_value.must_be_false?
+      if ctrlexpr.constant?(@enum_tbl) && ctrlexpr_value.must_be_false?
         W(:W0744, ctrlexpr.location)
       end
     end
@@ -13338,6 +13437,413 @@ module C #:nodoc:
     end
   end
 
+  class W0787 < PassiveMessageDetection
+    def initialize(context)
+      super
+      interp = context[:c_interpreter]
+      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_typedef_declared += method(:check_typedef_declaration)
+      interp.on_enum_declared += method(:check_enum_declaration)
+      interp.on_block_started += method(:start_block)
+      interp.on_block_ended += method(:end_block)
+
+      @object_decls_stack = [Hash.new { |hash, key| hash[key] = [] }]
+      @typedef_decls_stack = [Hash.new { |hash, key| hash[key] = [] }]
+      @enumerators_stack = [Hash.new(0)]
+
+      @object_decls_in_other_scope = Hash.new { |hash, key| hash[key] = [] }
+      @typedef_decls_in_other_scope = Hash.new { |hash, key| hash[key] = [] }
+      @enumerators_in_other_scope = Hash.new(0)
+    end
+
+    private
+    def check_object_declaration(declaration_or_definition, *)
+      name = declaration_or_definition.identifier.value
+      type = declaration_or_definition.type
+
+      same_name_object_decls = @object_decls_in_other_scope[name]
+      unless same_name_object_decls.all? { |decl| decl.type == type }
+        W(:W0787, declaration_or_definition.location, name)
+        return
+      end
+
+      same_name_typedef_decls = @typedef_decls_in_other_scope[name]
+      unless same_name_typedef_decls.empty?
+        W(:W0787, declaration_or_definition.location, name)
+        return
+      end
+
+      same_name_enumerators = @enumerators_in_other_scope[name]
+      unless same_name_enumerators == 0
+        W(:W0787, declaration_or_definition.location, name)
+        return
+      end
+    ensure
+      unless @object_decls_stack.empty?
+        @object_decls_stack.last[name].push(declaration_or_definition)
+      end
+    end
+
+    def check_typedef_declaration(typedef_declaration)
+      name = typedef_declaration.identifier.value
+      type = typedef_declaration.type
+
+      same_name_object_decls = @object_decls_in_other_scope[name]
+      unless same_name_object_decls.empty?
+        W(:W0787, typedef_declaration.location, name)
+        return
+      end
+
+      same_name_typedef_decls = @typedef_decls_in_other_scope[name]
+      unless same_name_typedef_decls.all? { |decl| decl.type == type }
+        W(:W0787, typedef_declaration.location, name)
+        return
+      end
+
+      same_name_enumerators = @enumerators_in_other_scope[name]
+      unless same_name_enumerators == 0
+        W(:W0787, typedef_declaration.location, name)
+        return
+      end
+    ensure
+      unless @typedef_decls_stack.empty?
+        @typedef_decls_stack.last[name].push(typedef_declaration)
+      end
+    end
+
+    def check_enum_declaration(enum_type_declaration)
+      enum_type_declaration.enumerators.each { |enum| check_enumerator(enum) }
+    end
+
+    def check_enumerator(enumerator)
+      name = enumerator.identifier.value
+
+      same_name_object_decls = @object_decls_in_other_scope[name]
+      unless same_name_object_decls.empty?
+        W(:W0787, enumerator.location, name)
+        return
+      end
+
+      same_name_typedef_decls = @typedef_decls_in_other_scope[name]
+      unless same_name_typedef_decls.empty?
+        W(:W0787, enumerator.location, name)
+        return
+      end
+
+      same_name_enumerators = @enumerators_in_other_scope[name]
+      unless same_name_enumerators == 0
+        W(:W0787, enumerator.location, name)
+        return
+      end
+    ensure
+      unless @enumerators_stack.empty?
+        @enumerators_stack.last[name] += 1
+      end
+    end
+
+    def start_block(compound_statement)
+      @object_decls_stack.push(Hash.new { |hash, key| hash[key] = [] })
+      @typedef_decls_stack.push(Hash.new { |hash, key| hash[key] = [] })
+      @enumerators_stack.push(Hash.new(0))
+    end
+
+    def end_block(compound_statement)
+      unless @object_decls_stack.empty?
+        @object_decls_stack.last.each do |name, decls|
+          @object_decls_in_other_scope[name].concat(decls)
+        end
+        @object_decls_stack.pop
+      end
+
+      unless @typedef_decls_stack.empty?
+        @typedef_decls_stack.last.each do |name, decls|
+          @typedef_decls_in_other_scope[name].concat(decls)
+        end
+        @typedef_decls_stack.pop
+      end
+
+      unless @enumerators_stack.empty?
+        @enumerators_stack.last.each do |name, decl_num|
+          @enumerators_in_other_scope[name] += decl_num
+        end
+      end
+    end
+  end
+
+  class W0788 < PassiveMessageDetection
+    def initialize(context)
+      super
+      interp = context[:c_interpreter]
+      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_typedef_declared += method(:check_typedef_declaration)
+      interp.on_enum_declared += method(:check_enum_declaration)
+      interp.on_block_started += method(:start_block)
+      interp.on_block_ended += method(:end_block)
+
+      @object_decls_stack = [Hash.new { |hash, key| hash[key] = [] }]
+      @typedef_decls_stack = [Hash.new { |hash, key| hash[key] = [] }]
+      @enumerators_stack = [Hash.new(0)]
+    end
+
+    private
+    def check_object_declaration(declaration_or_definition, *)
+      name = declaration_or_definition.identifier.value
+      type = declaration_or_definition.type
+
+      unless @object_decls_stack.empty?
+        same_name_object_decls = @object_decls_stack.last[name]
+        unless same_name_object_decls.all? { |decl| decl.type == type }
+          W(:W0788, declaration_or_definition.location, name)
+          return
+        end
+      end
+
+      unless @typedef_decls_stack.empty?
+        same_name_typedef_decls = @typedef_decls_stack.last[name]
+        unless same_name_typedef_decls.empty?
+          W(:W0788, declaration_or_definition.location, name)
+          return
+        end
+      end
+
+      unless @enumerators_stack.empty?
+        same_name_enumerators = @enumerators_stack.last[name]
+        unless same_name_enumerators == 0
+          W(:W0788, declaration_or_definition.location, name)
+          return
+        end
+      end
+    ensure
+      unless @object_decls_stack.empty?
+        @object_decls_stack.last[name].push(declaration_or_definition)
+      end
+    end
+
+    def check_typedef_declaration(typedef_declaration)
+      name = typedef_declaration.identifier.value
+      type = typedef_declaration.type
+
+      unless @object_decls_stack.empty?
+        same_name_object_decls = @object_decls_stack.last[name]
+        unless same_name_object_decls.empty?
+          W(:W0788, typedef_declaration.location, name)
+          return
+        end
+      end
+
+      unless @typedef_decls_stack.empty?
+        same_name_typedef_decls = @typedef_decls_stack.last[name]
+        unless same_name_typedef_decls.all? { |decl| decl.type == type }
+          W(:W0788, typedef_declaration.location, name)
+          return
+        end
+      end
+
+      unless @enumerators_stack.empty?
+        same_name_enumerators = @enumerators_stack.last[name]
+        unless same_name_enumerators == 0
+          W(:W0788, typedef_declaration.location, name)
+          return
+        end
+      end
+    ensure
+      unless @typedef_decls_stack.empty?
+        @typedef_decls_stack.last[name].push(typedef_declaration)
+      end
+    end
+
+    def check_enum_declaration(enum_type_declaration)
+      enum_type_declaration.enumerators.each { |enum| check_enumerator(enum) }
+    end
+
+    def check_enumerator(enumerator)
+      name = enumerator.identifier.value
+
+      unless @object_decls_stack.empty?
+        same_name_object_decls = @object_decls_stack.last[name]
+        unless same_name_object_decls.empty?
+          W(:W0788, enumerator.location, name)
+          return
+        end
+      end
+
+      unless @typedef_decls_stack.empty?
+        same_name_typedef_decls = @typedef_decls_stack.last[name]
+        unless same_name_typedef_decls.empty?
+          W(:W0788, enumerator.location, name)
+          return
+        end
+      end
+
+      unless @enumerators_stack.empty?
+        same_name_enumerators = @enumerators_stack.last[name]
+        unless same_name_enumerators == 0
+          W(:W0788, enumerator.location, name)
+          return
+        end
+      end
+    ensure
+      unless @enumerators_stack.empty?
+        @enumerators_stack.last[name] += 1
+      end
+    end
+
+    def start_block(compound_statement)
+      @object_decls_stack.push(Hash.new { |hash, key| hash[key] = [] })
+      @typedef_decls_stack.push(Hash.new { |hash, key| hash[key] = [] })
+      @enumerators_stack.push(Hash.new(0))
+    end
+
+    def end_block(compound_statement)
+      @object_decls_stack.pop
+      @typedef_decls_stack.pop
+      @enumerators_stack.pop
+    end
+  end
+
+  class W0789 < PassiveMessageDetection
+    def initialize(context)
+      super
+      interp = context[:c_interpreter]
+      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_typedef_declared += method(:check_typedef_declaration)
+      interp.on_enum_declared += method(:check_enum_declaration)
+      interp.on_block_started += method(:start_block)
+      interp.on_block_ended += method(:end_block)
+
+      @object_decls_stack = [Hash.new { |hash, key| hash[key] = [] }]
+      @typedef_decls_stack = [Hash.new { |hash, key| hash[key] = [] }]
+      @enumerators_stack = [Hash.new(0)]
+    end
+
+    private
+    def check_object_declaration(declaration_or_definition, *)
+      name = declaration_or_definition.identifier.value
+      type = declaration_or_definition.type
+
+      same_name_object_decls =
+        merge_same_name_object_decls(name, @object_decls_stack[0..-2])
+      unless same_name_object_decls.all? { |decl| decl.type == type }
+        W(:W0789, declaration_or_definition.location, name)
+        return
+      end
+
+      same_name_typedef_decls =
+        merge_same_name_typedef_decls(name, @typedef_decls_stack[0..-2])
+      unless same_name_typedef_decls.empty?
+        W(:W0789, declaration_or_definition.location, name)
+        return
+      end
+
+      same_name_enumerators =
+        merge_same_name_enumerators(name, @enumerators_stack[0..-2])
+      unless same_name_enumerators == 0
+        W(:W0789, declaration_or_definition.location, name)
+        return
+      end
+    ensure
+      unless @object_decls_stack.empty?
+        @object_decls_stack.last[name].push(declaration_or_definition)
+      end
+    end
+
+    def check_typedef_declaration(typedef_declaration)
+      name = typedef_declaration.identifier.value
+      type = typedef_declaration.type
+
+      same_name_object_decls =
+        merge_same_name_object_decls(name, @object_decls_stack[0..-2])
+      unless same_name_object_decls.empty?
+        W(:W0789, typedef_declaration.location, name)
+        return
+      end
+
+      same_name_typedef_decls =
+        merge_same_name_typedef_decls(name, @typedef_decls_stack[0..-2])
+      unless same_name_typedef_decls.all? { |decl| decl.type == type }
+        W(:W0789, typedef_declaration.location, name)
+        return
+      end
+
+      same_name_enumerators =
+        merge_same_name_enumerators(name, @enumerators_stack[0..-2])
+      unless same_name_enumerators == 0
+        W(:W0789, typedef_declaration.location, name)
+        return
+      end
+    ensure
+      unless @typedef_decls_stack.empty?
+        @typedef_decls_stack.last[name].push(typedef_declaration)
+      end
+    end
+
+    def check_enum_declaration(enum_type_declaration)
+      enum_type_declaration.enumerators.each { |enum| check_enumerator(enum) }
+    end
+
+    def check_enumerator(enumerator)
+      name = enumerator.identifier.value
+
+      same_name_object_decls =
+        merge_same_name_object_decls(name, @object_decls_stack[0..-2])
+      unless same_name_object_decls.empty?
+        W(:W0789, enumerator.location, name)
+        return
+      end
+
+      same_name_typedef_decls =
+        merge_same_name_typedef_decls(name, @typedef_decls_stack[0..-2])
+      unless same_name_typedef_decls.empty?
+        W(:W0789, enumerator.location, name)
+        return
+      end
+
+      same_name_enumerators =
+        merge_same_name_enumerators(name, @enumerators_stack[0..-2])
+      unless same_name_enumerators == 0
+        W(:W0789, enumerator.location, name)
+        return
+      end
+    ensure
+      unless @enumerators_stack.empty?
+        @enumerators_stack.last[name] += 1
+      end
+    end
+
+    def start_block(compound_statement)
+      @object_decls_stack.push(Hash.new { |hash, key| hash[key] = [] })
+      @typedef_decls_stack.push(Hash.new { |hash, key| hash[key] = [] })
+      @enumerators_stack.push(Hash.new(0))
+    end
+
+    def end_block(compound_statement)
+      @object_decls_stack.pop
+      @typedef_decls_stack.pop
+      @enumerators_stack.pop
+    end
+
+    def merge_same_name_object_decls(name, scopes)
+      scopes.each_with_object([]) { |hash, result| result.concat(hash[name]) }
+    end
+
+    def merge_same_name_typedef_decls(name, scopes)
+      scopes.each_with_object([]) { |hash, result| result.concat(hash[name]) }
+    end
+
+    def merge_same_name_enumerators(name, scopes)
+      scopes.reduce(0) { |result, hash| result + hash[name] }
+    end
+  end
+
   class W0790 < PassiveMessageDetection
     def initialize(context)
       super
@@ -14136,6 +14642,282 @@ module C #:nodoc:
     end
   end
 
+  class W1053 < PassiveMessageDetection
+    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)
+      args = arg_variables.zip(function.type.parameter_types)
+      args.each_with_index do |(arg_variable, param_type), index|
+        next unless param_type && param_type.enum?
+
+        arg_expr = expression.argument_expressions[index]
+        next unless arg_expr.constant?(@enum_tbl)
+
+        unless arg_variable.type.enum?
+          W(:W1053, arg_expr.location)
+        end
+      end
+    end
+  end
+
+  class W1054 < PassiveMessageDetection
+    def initialize(context)
+      super
+      interp = context[:c_interpreter]
+      interp.on_assignment_expr_evaled += method(:check)
+    end
+
+    private
+    def check(expression, lhs_variable, rhs_variable)
+      return unless lhs_variable.type.enum?
+      W(:W1054, expression.location) unless rhs_variable.type.enum?
+    end
+  end
+
+  class W1055 < PassiveMessageDetection
+    def initialize(context)
+      super
+      interp = context[:c_interpreter]
+      interp.on_function_started += method(:start_function)
+      interp.on_function_ended += method(:end_function)
+      interp.on_return_stmt_evaled += method(:check)
+      @current_function = nil
+    end
+
+    private
+    def start_function(function_definition)
+      @current_function = function_definition
+    end
+
+    def end_function(function_definition)
+      @current_function = nil
+    end
+
+    def check(return_statement, result_variable)
+      return unless @current_function && result_variable
+
+      return unless return_type = @current_function.type.return_type
+      return unless return_type.enum?
+
+      unless result_variable.type.enum?
+        W(:W1055, return_statement.expression.location)
+      end
+    end
+  end
+
+  class W1056 < PassiveMessageDetection
+    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)
+      args = arg_variables.zip(function.type.parameter_types)
+      args.each_with_index do |(arg_variable, param_type), index|
+        next unless param_type && param_type.enum?
+
+        arg_expr = expression.argument_expressions[index]
+        next if arg_expr.constant?(@enum_tbl)
+
+        if arg_variable.type.enum?
+          unless arg_variable.type.same_as?(param_type)
+            W(:W1056, arg_expr.location)
+          end
+        end
+      end
+    end
+  end
+
+  class W1057 < PassiveMessageDetection
+    def initialize(context)
+      super
+      interp = context[:c_interpreter]
+      interp.on_assignment_expr_evaled += method(:check)
+      @enum_tbl = interp.environment.enumerator_table
+    end
+
+    private
+    def check(expression, lhs_variable, rhs_variable)
+      return unless lhs_variable.type.enum?
+      return if expression.rhs_operand.constant?(@enum_tbl)
+
+      if rhs_variable.type.enum?
+        unless lhs_variable.type.same_as?(rhs_variable.type)
+          W(:W1057, expression.location)
+        end
+      end
+    end
+  end
+
+  class W1058 < PassiveMessageDetection
+    def initialize(context)
+      super
+      interp = context[:c_interpreter]
+      interp.on_function_started += method(:start_function)
+      interp.on_function_ended += method(:end_function)
+      interp.on_return_stmt_evaled += method(:check)
+      @enum_tbl = interp.environment.enumerator_table
+      @current_function = nil
+    end
+
+    private
+    def start_function(function_definition)
+      @current_function = function_definition
+    end
+
+    def end_function(function_definition)
+      @current_function = nil
+    end
+
+    def check(return_statement, result_variable)
+      return unless @current_function && result_variable
+
+      return unless return_type = @current_function.type.return_type
+      return unless return_type.enum?
+      return if return_statement.expression.constant?(@enum_tbl)
+
+      if result_variable.type.enum?
+        unless return_type.same_as?(result_variable.type)
+          W(:W1058, return_statement.expression.location)
+        end
+      end
+    end
+  end
+
+  class W1059 < PassiveMessageDetection
+    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)
+      args = arg_variables.zip(function.type.parameter_types)
+      args.each_with_index do |(arg_variable, param_type), index|
+        next if param_type.nil? || param_type.enum?
+
+        if arg_variable.type.enum?
+          W(:W1059, expression.argument_expressions[index].location)
+        end
+      end
+    end
+  end
+
+  class W1060 < PassiveMessageDetection
+    def initialize(context)
+      super
+      interp = context[:c_interpreter]
+      interp.on_function_started += method(:start_function)
+      interp.on_function_ended += method(:end_function)
+      interp.on_return_stmt_evaled += method(:check)
+      @enum_tbl = interp.environment.enumerator_table
+      @current_function = nil
+    end
+
+    private
+    def start_function(function_definition)
+      @current_function = function_definition
+    end
+
+    def end_function(function_definition)
+      @current_function = nil
+    end
+
+    def check(return_statement, result_variable)
+      return unless @current_function && result_variable
+
+      return unless return_type = @current_function.type.return_type
+      return if return_type.enum?
+
+      if result_variable.type.enum?
+        W(:W1060, return_statement.expression.location)
+      end
+    end
+  end
+
+  class W1061 < PassiveMessageDetection
+    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)
+      args = arg_variables.zip(function.type.parameter_types)
+      args.each_with_index do |(arg_variable, param_type), index|
+        next unless param_type && param_type.enum?
+
+        arg_expr = expression.argument_expressions[index]
+        next if arg_expr.constant?(@enum_tbl)
+
+        W(:W1061, arg_expr.location) unless arg_variable.type.enum?
+      end
+    end
+  end
+
+  class W1062 < PassiveMessageDetection
+    def initialize(context)
+      super
+      interp = context[:c_interpreter]
+      interp.on_assignment_expr_evaled += method(:check)
+      @enum_tbl = interp.environment.enumerator_table
+    end
+
+    private
+    def check(expression, lhs_variable, rhs_variable)
+      return unless lhs_variable.type.enum?
+      return if expression.rhs_operand.constant?(@enum_tbl)
+
+      W(:W1062, expression.location) unless rhs_variable.type.enum?
+    end
+  end
+
+  class W1063 < PassiveMessageDetection
+    def initialize(context)
+      super
+      interp = context[:c_interpreter]
+      interp.on_function_started += method(:start_function)
+      interp.on_function_ended += method(:end_function)
+      interp.on_return_stmt_evaled += method(:check)
+      @enum_tbl = interp.environment.enumerator_table
+      @current_function = nil
+    end
+
+    private
+    def start_function(function_definition)
+      @current_function = function_definition
+    end
+
+    def end_function(function_definition)
+      @current_function = nil
+    end
+
+    def check(return_statement, result_variable)
+      return unless @current_function && result_variable
+
+      return unless return_type = @current_function.type.return_type
+      return unless return_type.enum?
+      return if return_statement.expression.constant?(@enum_tbl)
+
+      unless result_variable.type.enum?
+        W(:W1063, return_statement.expression.location)
+      end
+    end
+  end
+
   class W1064 < W0731
     private
     def check(case_labeled_statement, ctrlexpr_result)