adlint 2.4.6 → 2.4.10

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

@@ -2782,7 +2782,7 @@ module CBuiltin #:nodoc:
   end
 
   class W0120 < W0119
-    def_registrant_phase C::Prepare2Phase 
+    def_registrant_phase C::Prepare2Phase
 
     private
     def from_type
@@ -7835,6 +7835,10 @@ module CBuiltin #:nodoc:
   class W0488 < PassiveCodeCheck
     def_registrant_phase C::Prepare2Phase
 
+    # NOTE: W0488 may be duplicative when problematic operators appear thrice
+    #       or more in an expression.
+    ensure_uniqueness_of :W0488
+
     def initialize(context)
       super
       visitor = context[:c_visitor]
@@ -7906,11 +7910,10 @@ module CBuiltin #:nodoc:
       def initialize(context, expression)
         @context = context
         @expression = expression
-        @already_warned = false
-        @group_depth = 0
-        @ungrouped_array_subscript_expr = 0
-        @ungrouped_function_call_expr = 0
-        @ungrouped_member_access_expr = 0
+        @enclosure_expr_stack = [expression]
+        @ary_subscript_exprs = Hash.new(0)
+        @function_call_exprs = Hash.new(0)
+        @member_access_exprs = Hash.new(0)
       end
 
       def execute
@@ -7918,20 +7921,20 @@ module CBuiltin #:nodoc:
       end
 
       def visit_grouped_expression(node)
-        @group_depth += 1
+        @enclosure_expr_stack.push(node)
         super
-        @group_depth -= 1
+        @enclosure_expr_stack.pop
       end
 
       def visit_array_subscript_expression(node)
         node.expression.accept(self)
-        @ungrouped_array_subscript_expr += 1 if @group_depth == 0
+        @ary_subscript_exprs[current_enclosure_expr] += 1
         AmbiguousExpressionDetector.new(@context, node.array_subscript).execute
       end
 
       def visit_function_call_expression(node)
         node.expression.accept(self)
-        @ungrouped_function_call_expr += 1 if @group_depth == 0
+        @function_call_exprs[current_enclosure_expr] += 1
         node.argument_expressions.each do |expr|
           AmbiguousExpressionDetector.new(@context, expr).execute
         end
@@ -7939,49 +7942,53 @@ module CBuiltin #:nodoc:
 
       def visit_member_access_by_value_expression(node)
         super
-        @ungrouped_member_access_expr += 1 if @group_depth == 0
+        @member_access_exprs[current_enclosure_expr] += 1
       end
 
       def visit_member_access_by_pointer_expression(node)
         super
-        @ungrouped_member_access_expr += 1 if @group_depth == 0
+        @member_access_exprs[current_enclosure_expr] += 1
       end
 
       def visit_bit_access_by_value_expression(node)
         super
-        @ungrouped_member_access_expr += 1 if @group_depth == 0
+        @member_access_exprs[current_enclosure_expr] += 1
       end
 
       def visit_bit_access_by_pointer_expression(node)
         super
-        @ungrouped_member_access_expr += 1 if @group_depth == 0
+        @member_access_exprs[current_enclosure_expr] += 1
       end
 
       def visit_logical_and_expression(node)
         super
-        unless @already_warned
-          if include_ambiguous_expr?
-            W(:W0488, @expression.head_location)
-            @already_warned = true
-          end
+        if include_ambiguous_expr?
+          W(:W0488, current_enclosure_expr.head_location)
         end
       end
 
       def visit_logical_or_expression(node)
         super
-        unless @already_warned
-          if include_ambiguous_expr?
-            W(:W0488, @expression.head_location)
-            @already_warned = true
-          end
+        if include_ambiguous_expr?
+          W(:W0488, current_enclosure_expr.head_location)
         end
       end
 
+      def visit_conditional_expression(node)
+        AmbiguousExpressionDetector.new(@context, node.condition).execute
+        AmbiguousExpressionDetector.new(@context, node.then_expression).execute
+        AmbiguousExpressionDetector.new(@context, node.else_expression).execute
+      end
+
       private
       def include_ambiguous_expr?
-        @ungrouped_array_subscript_expr > 0 ||
-          @ungrouped_function_call_expr > 0 ||
-          @ungrouped_member_access_expr > 0
+        @ary_subscript_exprs[current_enclosure_expr] > 0 or
+        @function_call_exprs[current_enclosure_expr] > 0 or
+        @member_access_exprs[current_enclosure_expr] > 0
+      end
+
+      def current_enclosure_expr
+        @enclosure_expr_stack.last
       end
 
       def report
@@ -7994,6 +8001,10 @@ module CBuiltin #:nodoc:
   class W0489 < PassiveCodeCheck
     def_registrant_phase C::Prepare2Phase
 
+    # NOTE: W0489 may be duplicative when operators of the same priority are
+    #       used thrice or more.
+    ensure_uniqueness_of :W0489
+
     def initialize(context)
       super
       visitor = context[:c_visitor]
@@ -8065,9 +8076,8 @@ module CBuiltin #:nodoc:
       def initialize(context, expression)
         @context = context
         @expression = expression
-        @already_warned = false
-        @group_depth = 0
-        @ungrouped_unary_expr = 0
+        @enclosure_expr_stack = [expression]
+        @unary_exprs = Hash.new(0)
       end
 
       def execute
@@ -8075,84 +8085,88 @@ module CBuiltin #:nodoc:
       end
 
       def visit_grouped_expression(node)
-        @group_depth += 1
+        @enclosure_expr_stack.push(node)
         super
-        @group_depth -= 1
+        @enclosure_expr_stack.pop
       end
 
       def visit_postfix_increment_expression(node)
         super
-        @ungrouped_unary_expr += 1 if @group_depth == 0
+        @unary_exprs[current_enclosure_expr] += 1
       end
 
       def visit_postfix_decrement_expression(node)
         super
-        @ungrouped_unary_expr += 1 if @group_depth == 0
+        @unary_exprs[current_enclosure_expr] += 1
       end
 
       def visit_prefix_increment_expression(node)
         super
-        @ungrouped_unary_expr += 1 if @group_depth == 0
+        @unary_exprs[current_enclosure_expr] += 1
       end
 
       def visit_prefix_decrement_expression(node)
         super
-        @ungrouped_unary_expr += 1 if @group_depth == 0
+        @unary_exprs[current_enclosure_expr] += 1
       end
 
       def visit_address_expression(node)
         super
-        @ungrouped_unary_expr += 1 if @group_depth == 0
+        @unary_exprs[current_enclosure_expr] += 1
       end
 
       def visit_indirection_expression(node)
         super
-        @ungrouped_unary_expr += 1 if @group_depth == 0
+        @unary_exprs[current_enclosure_expr] += 1
       end
 
       def visit_unary_arithmetic_expression(node)
         super
-        @ungrouped_unary_expr += 1 if @group_depth == 0
+        @unary_exprs[current_enclosure_expr] += 1
       end
 
       def visit_sizeof_expression(node)
         super
-        @ungrouped_unary_expr += 1 if @group_depth == 0
+        @unary_exprs[current_enclosure_expr] += 1
       end
 
       def visit_alignof_expression(node)
         super
-        @ungrouped_unary_expr += 1 if @group_depth == 0
+        @unary_exprs[current_enclosure_expr] += 1
       end
 
       def visit_cast_expression(node)
         node.operand.accept(self)
-        @ungrouped_unary_expr += 1 if @group_depth == 0
+        @unary_exprs[current_enclosure_expr] += 1
       end
 
       def visit_logical_and_expression(node)
         super
-        unless @already_warned
-          if include_ambiguous_expr?
-            W(:W0489, @expression.head_location)
-            @already_warned = true
-          end
+        if include_ambiguous_expr?
+          W(:W0489, current_enclosure_expr.head_location)
         end
       end
 
       def visit_logical_or_expression(node)
         super
-        unless @already_warned
-          if include_ambiguous_expr?
-            W(:W0489, @expression.head_location)
-            @already_warned = true
-          end
+        if include_ambiguous_expr?
+          W(:W0489, current_enclosure_expr.head_location)
         end
       end
 
+      def visit_conditional_expression(node)
+        AmbiguousExpressionDetector.new(@context, node.condition).execute
+        AmbiguousExpressionDetector.new(@context, node.then_expression).execute
+        AmbiguousExpressionDetector.new(@context, node.else_expression).execute
+      end
+
       private
       def include_ambiguous_expr?
-        @ungrouped_unary_expr > 0
+        @unary_exprs[current_enclosure_expr] > 0
+      end
+
+      def current_enclosure_expr
+        @enclosure_expr_stack.last
       end
 
       def report
@@ -8165,6 +8179,10 @@ module CBuiltin #:nodoc:
   class W0490 < PassiveCodeCheck
     def_registrant_phase C::Prepare2Phase
 
+    # NOTE: W0490 may be duplicative when problematic operators appear thrice
+    #       or more in an expression.
+    ensure_uniqueness_of :W0490
+
     def initialize(context)
       super
       visitor = context[:c_visitor]
@@ -8236,10 +8254,9 @@ module CBuiltin #:nodoc:
       def initialize(context, expression)
         @context = context
         @expression = expression
-        @already_warned = false
-        @group_depth = 0
-        @ungrouped_highprec_binary_expr = 0
-        @ungrouped_logical_and_expr = 0
+        @enclosure_expr_stack = [expression]
+        @highprec_binary_exprs = Hash.new(0)
+        @logical_and_exprs = Hash.new(0)
       end
 
       def execute
@@ -8247,9 +8264,9 @@ module CBuiltin #:nodoc:
       end
 
       def visit_grouped_expression(node)
-        @group_depth += 1
+        @enclosure_expr_stack.push(node)
         super
-        @group_depth -= 1
+        @enclosure_expr_stack.pop
       end
 
       def visit_array_subscript_expression(node)
@@ -8266,67 +8283,72 @@ module CBuiltin #:nodoc:
 
       def visit_multiplicative_expression(node)
         super
-        @ungrouped_highprec_binary_expr += 1 if @group_depth == 0
+        @highprec_binary_exprs[current_enclosure_expr] += 1
       end
 
       def visit_additive_expression(node)
         super
-        @ungrouped_highprec_binary_expr += 1 if @group_depth == 0
+        @highprec_binary_exprs[current_enclosure_expr] += 1
       end
 
       def visit_shift_expression(node)
         super
-        @ungrouped_highprec_binary_expr += 1 if @group_depth == 0
+        @highprec_binary_exprs[current_enclosure_expr] += 1
       end
 
       def visit_relational_expression(node)
         super
-        @ungrouped_highprec_binary_expr += 1 if @group_depth == 0
+        @highprec_binary_exprs[current_enclosure_expr] += 1
       end
 
       def visit_equality_expression(node)
         super
-        @ungrouped_highprec_binary_expr += 1 if @group_depth == 0
+        @highprec_binary_exprs[current_enclosure_expr] += 1
       end
 
       def visit_and_expression(node)
         super
-        @ungrouped_highprec_binary_expr += 1 if @group_depth == 0
+        @highprec_binary_exprs[current_enclosure_expr] += 1
       end
 
       def visit_exclusive_or_expression(node)
         super
-        @ungrouped_highprec_binary_expr += 1 if @group_depth == 0
+        @highprec_binary_exprs[current_enclosure_expr] += 1
       end
 
       def visit_inclusive_or_expression(node)
         super
-        @ungrouped_highprec_binary_expr += 1 if @group_depth == 0
+        @highprec_binary_exprs[current_enclosure_expr] += 1
       end
 
       def visit_logical_and_expression(node)
         super
-        @ungrouped_logical_and_expr += 1 if @group_depth == 0
-
-        unless @already_warned
-          if @ungrouped_highprec_binary_expr > 0
-            W(:W0490, @expression.head_location)
-            @already_warned = true
-          end
+        current_enclosure = current_enclosure_expr
+        @logical_and_exprs[current_enclosure] += 1
+        if @highprec_binary_exprs[current_enclosure] > 0
+          W(:W0490, current_enclosure.head_location)
         end
       end
 
       def visit_logical_or_expression(node)
         super
-        unless @already_warned
-          if @ungrouped_highprec_binary_expr + @ungrouped_logical_and_expr > 0
-            W(:W0490, @expression.head_location)
-            @already_warned = true
-          end
+        encl = current_enclosure_expr
+        if @highprec_binary_exprs[encl] + @logical_and_exprs[encl] > 0
+          W(:W0490, encl.head_location)
         end
       end
 
+      def visit_conditional_expression(node)
+        AmbiguousExpressionDetector.new(@context, node.condition).execute
+        AmbiguousExpressionDetector.new(@context, node.then_expression).execute
+        AmbiguousExpressionDetector.new(@context, node.else_expression).execute
+      end
+
       private
+      def current_enclosure_expr
+        @enclosure_expr_stack.last
+      end
+
       def report
         @context.report
       end
@@ -8705,6 +8727,10 @@ module CBuiltin #:nodoc:
   class W0495 < PassiveCodeCheck
     def_registrant_phase C::Prepare2Phase
 
+    # NOTE: W0495 may be duplicative when problematic operators appear thrice
+    #       or more in an expression.
+    ensure_uniqueness_of :W0495
+
     def initialize(context)
       super
       visitor = context[:c_visitor]
@@ -8776,12 +8802,12 @@ module CBuiltin #:nodoc:
       def initialize(context, expression)
         @context = context
         @expression = expression
-        @group_depth = 0
-        @ungrouped_add_expr = 0
-        @ungrouped_sub_expr = 0
-        @ungrouped_mul_expr = 0
-        @ungrouped_div_expr = 0
-        @ungrouped_mod_expr = 0
+        @enclosure_expr_stack = [expression]
+        @add_exprs = Hash.new(0)
+        @sub_exprs = Hash.new(0)
+        @mul_exprs = Hash.new(0)
+        @div_exprs = Hash.new(0)
+        @mod_exprs = Hash.new(0)
       end
 
       def execute
@@ -8789,9 +8815,9 @@ module CBuiltin #:nodoc:
       end
 
       def visit_grouped_expression(node)
-        @group_depth += 1
+        @enclosure_expr_stack.push(node)
         super
-        @group_depth -= 1
+        @enclosure_expr_stack.pop
       end
 
       def visit_array_subscript_expression(node)
@@ -8805,51 +8831,56 @@ module CBuiltin #:nodoc:
       end
 
       def visit_additive_expression(node)
-        if @group_depth == 0
-          case node.operator.type
-          when "+"
-            @ungrouped_add_expr += 1
-          when "-"
-            @ungrouped_sub_expr += 1
-          end
-        end
-
-        if include_ambiguous_expr?
-          W(:W0495, @expression.head_location)
-        else
-          super
+        current_enclosure = current_enclosure_expr
+        case node.operator.type
+        when "+"
+          @add_exprs[current_enclosure] += 1
+          W(:W0495, current_enclosure.head_location) if include_ambiguous_expr?
+        when "-"
+          @sub_exprs[current_enclosure] += 1
+          W(:W0495, current_enclosure.head_location) if include_ambiguous_expr?
         end
+        super
       end
 
       def visit_multiplicative_expression(node)
-        if @group_depth == 0
-          case node.operator.type
-          when "*"
-            @ungrouped_mul_expr += 1
-          when "/"
-            @ungrouped_div_expr += 1
-          when "%"
-            @ungrouped_mod_expr += 1
-          end
+        current_enclosure = current_enclosure_expr
+        case node.operator.type
+        when "*"
+          @mul_exprs[current_enclosure] += 1
+          W(:W0495, current_enclosure.head_location) if include_ambiguous_expr?
+        when "/"
+          @div_exprs[current_enclosure] += 1
+          W(:W0495, current_enclosure.head_location) if include_ambiguous_expr?
+        when "%"
+          @mod_exprs[current_enclosure] += 1
+          W(:W0495, current_enclosure.head_location) if include_ambiguous_expr?
         end
+        super
+      end
 
-        if include_ambiguous_expr?
-          W(:W0495, @expression.head_location)
-        else
-          super
-        end
+      def visit_conditional_expression(node)
+        AmbiguousExpressionDetector.new(@context, node.condition).execute
+        AmbiguousExpressionDetector.new(@context, node.then_expression).execute
+        AmbiguousExpressionDetector.new(@context, node.else_expression).execute
       end
 
       private
       def include_ambiguous_expr?
-        return false if @ungrouped_mod_expr == 0
+        enclosure = current_enclosure_expr
+        return false if @mod_exprs[enclosure] == 0
 
-        ungrouped_multiplicative_expr =
-          @ungrouped_mul_expr + @ungrouped_div_expr + @ungrouped_mod_expr
+        additive_exprs =
+          @add_exprs[enclosure] + @sub_exprs[enclosure]
+        multiplicative_exprs =
+          @mul_exprs[enclosure] + @div_exprs[enclosure] + @mod_exprs[enclosure]
 
-        (@ungrouped_add_expr + @ungrouped_sub_expr) > 0 &&
-          ungrouped_multiplicative_expr > 0 or
-        ungrouped_multiplicative_expr > 1
+        additive_exprs > 0 && multiplicative_exprs > 0 or
+        multiplicative_exprs > 1
+      end
+
+      def current_enclosure_expr
+        @enclosure_expr_stack.last
       end
 
       def report
@@ -8862,6 +8893,10 @@ module CBuiltin #:nodoc:
   class W0496 < PassiveCodeCheck
     def_registrant_phase C::Prepare2Phase
 
+    # NOTE: W0496 may be duplicative when problematic operators appear thrice
+    #       or more in an expression.
+    ensure_uniqueness_of :W0496
+
     def initialize(context)
       super
       visitor = context[:c_visitor]
@@ -8935,9 +8970,8 @@ module CBuiltin #:nodoc:
       def initialize(context, expression)
         @context = context
         @expression = expression
-        @already_warned = false
-        @group_depth = 0
-        @ungrouped_conditional_expr = 0
+        @enclosure_expr_stack = [expression]
+        @conditional_exprs = Hash.new(0)
       end
 
       def execute
@@ -8945,23 +8979,25 @@ module CBuiltin #:nodoc:
       end
 
       def visit_grouped_expression(node)
-        @group_depth += 1
+        @enclosure_expr_stack.push(node)
         super
-        @group_depth -= 1
+        @enclosure_expr_stack.pop
       end
 
       def visit_conditional_expression(node)
         super
-        unless @already_warned
-          if @ungrouped_conditional_expr > 0
-            W(:W0496, @expression.head_location)
-            @already_warned = true
-          end
+        current_enclosure = current_enclosure_expr
+        if @conditional_exprs[current_enclosure] > 0
+          W(:W0496, current_enclosure.head_location)
         end
-        @ungrouped_conditional_expr += 1 if @group_depth == 0
+        @conditional_exprs[current_enclosure] += 1
       end
 
       private
+      def current_enclosure_expr
+        @enclosure_expr_stack.last
+      end
+
       def report
         @context.report
       end
@@ -8972,6 +9008,10 @@ module CBuiltin #:nodoc:
   class W0497 < PassiveCodeCheck
     def_registrant_phase C::Prepare2Phase
 
+    # NOTE: W0497 may be duplicative when problematic operators appear thrice
+    #       or more in an expression.
+    ensure_uniqueness_of :W0497
+
     def initialize(context)
       super
       visitor = context[:c_visitor]
@@ -9043,15 +9083,15 @@ module CBuiltin #:nodoc:
       def initialize(context, expression)
         @context = context
         @expression = expression
-        @group_depth = 0
-        @ungrouped_shr_expr = 0
-        @ungrouped_shl_expr = 0
-        @ungrouped_lt_expr = 0
-        @ungrouped_gt_expr = 0
-        @ungrouped_le_expr = 0
-        @ungrouped_ge_expr = 0
-        @ungrouped_eq_expr = 0
-        @ungrouped_ne_expr = 0
+        @enclosure_expr_stack = [expression]
+        @shr_exprs = Hash.new(0)
+        @shl_exprs = Hash.new(0)
+        @lt_exprs = Hash.new(0)
+        @gt_exprs = Hash.new(0)
+        @le_exprs = Hash.new(0)
+        @ge_exprs = Hash.new(0)
+        @eq_exprs = Hash.new(0)
+        @ne_exprs = Hash.new(0)
       end
 
       def execute
@@ -9059,9 +9099,9 @@ module CBuiltin #:nodoc:
       end
 
       def visit_grouped_expression(node)
-        @group_depth += 1
+        @enclosure_expr_stack.push(node)
         super
-        @group_depth -= 1
+        @enclosure_expr_stack.pop
       end
 
       def visit_array_subscript_expression(node)
@@ -9075,66 +9115,67 @@ module CBuiltin #:nodoc:
       end
 
       def visit_shift_expression(node)
-        if @group_depth == 0
-          case node.operator.type
-          when "<<"
-            @ungrouped_shl_expr += 1
-          when ">>"
-            @ungrouped_shr_expr += 1
-          end
-        end
-
-        if include_ambiguous_expr?
-          W(:W0497, @expression.head_location)
-        else
-          super
+        current_enclosure = current_enclosure_expr
+        case node.operator.type
+        when "<<"
+          @shl_exprs[current_enclosure] += 1
+          W(:W0497, current_enclosure.head_location) if include_ambiguous_expr?
+        when ">>"
+          @shr_exprs[current_enclosure] += 1
+          W(:W0497, current_enclosure.head_location) if include_ambiguous_expr?
         end
+        super
       end
 
       def visit_relational_expression(node)
-        if @group_depth == 0
-          case node.operator.type
-          when "<"
-            @ungrouped_lt_expr += 1
-          when ">"
-            @ungrouped_gt_expr += 1
-          when "<="
-            @ungrouped_le_expr += 1
-          when ">="
-            @ungrouped_ge_expr += 1
-          end
-        end
-
-        if include_ambiguous_expr?
-          W(:W0497, @expression.head_location)
-        else
-          super
+        current_enclosure = current_enclosure_expr
+        case node.operator.type
+        when "<"
+          @lt_exprs[current_enclosure] += 1
+          W(:W0497, current_enclosure.head_location) if include_ambiguous_expr?
+        when ">"
+          @gt_exprs[current_enclosure] += 1
+          W(:W0497, current_enclosure.head_location) if include_ambiguous_expr?
+        when "<="
+          @le_exprs[current_enclosure] += 1
+          W(:W0497, current_enclosure.head_location) if include_ambiguous_expr?
+        when ">="
+          @ge_exprs[current_enclosure] += 1
+          W(:W0497, current_enclosure.head_location) if include_ambiguous_expr?
         end
+        super
       end
 
       def visit_equality_expression(node)
-        if @group_depth == 0
-          case node.operator.type
-          when "=="
-            @ungrouped_eq_expr += 1
-          when "!="
-            @ungrouped_ne_expr += 1
-          end
+        current_enclosure = current_enclosure_expr
+        case node.operator.type
+        when "=="
+          @eq_exprs[current_enclosure] += 1
+          W(:W0497, current_enclosure.head_location) if include_ambiguous_expr?
+        when "!="
+          @ne_exprs[current_enclosure] += 1
+          W(:W0497, current_enclosure.head_location) if include_ambiguous_expr?
         end
+        super
+      end
 
-        if include_ambiguous_expr?
-          W(:W0497, @expression.head_location)
-        else
-          super
-        end
+      def visit_conditional_expression(node)
+        AmbiguousExpressionDetector.new(@context, node.condition).execute
+        AmbiguousExpressionDetector.new(@context, node.then_expression).execute
+        AmbiguousExpressionDetector.new(@context, node.else_expression).execute
       end
 
       private
       def include_ambiguous_expr?
-        @ungrouped_shl_expr > 1 || @ungrouped_shr_expr > 1 ||
-          @ungrouped_lt_expr > 1 || @ungrouped_gt_expr > 1 ||
-          @ungrouped_le_expr > 1 || @ungrouped_ge_expr > 1 ||
-          @ungrouped_eq_expr > 1 || @ungrouped_ne_expr > 1
+        enclosure = current_enclosure_expr
+        @shl_exprs[enclosure] > 1 || @shr_exprs[enclosure] > 1 ||
+          @lt_exprs[enclosure] > 1 || @gt_exprs[enclosure] > 1 ||
+          @le_exprs[enclosure] > 1 || @ge_exprs[enclosure] > 1 ||
+          @eq_exprs[enclosure] > 1 || @ne_exprs[enclosure] > 1
+      end
+
+      def current_enclosure_expr
+        @enclosure_expr_stack.last
       end
 
       def report
@@ -9147,6 +9188,10 @@ module CBuiltin #:nodoc:
   class W0498 < PassiveCodeCheck
     def_registrant_phase C::Prepare2Phase
 
+    # NOTE: W0498 may be duplicative when operators of the same priority are
+    #       used thrice or more.
+    ensure_uniqueness_of :W0498
+
     def initialize(context)
       super
       visitor = context[:c_visitor]
@@ -9218,11 +9263,11 @@ module CBuiltin #:nodoc:
       def initialize(context, expression)
         @context = context
         @expression = expression
-        @group_depth = 0
-        @ungrouped_add_expr = 0
-        @ungrouped_sub_expr = 0
-        @ungrouped_mul_expr = 0
-        @ungrouped_div_expr = 0
+        @enclosure_expr_stack = [expression]
+        @add_exprs = Hash.new(0)
+        @sub_exprs = Hash.new(0)
+        @mul_exprs = Hash.new(0)
+        @div_exprs = Hash.new(0)
       end
 
       def execute
@@ -9230,9 +9275,9 @@ module CBuiltin #:nodoc:
       end
 
       def visit_grouped_expression(node)
-        @group_depth += 1
+        @enclosure_expr_stack.push(node)
         super
-        @group_depth -= 1
+        @enclosure_expr_stack.pop
       end
 
       def visit_array_subscript_expression(node)
@@ -9246,43 +9291,46 @@ module CBuiltin #:nodoc:
       end
 
       def visit_additive_expression(node)
-        if @group_depth == 0
-          case node.operator.type
-          when "+"
-            @ungrouped_add_expr += 1
-          when "-"
-            @ungrouped_sub_expr += 1
-          end
-        end
-
-        if include_ambiguous_expr?
-          W(:W0498, @expression.head_location)
-        else
-          super
+        current_enclosure = current_enclosure_expr
+        case node.operator.type
+        when "+"
+          @add_exprs[current_enclosure] += 1
+          W(:W0498, current_enclosure.head_location) if include_ambiguous_expr?
+        when "-"
+          @sub_exprs[current_enclosure] += 1
+          W(:W0498, current_enclosure.head_location) if include_ambiguous_expr?
         end
+        super
       end
 
       def visit_multiplicative_expression(node)
-        if @group_depth == 0
-          case node.operator.type
-          when "*"
-            @ungrouped_mul_expr += 1
-          when "/"
-            @ungrouped_div_expr += 1
-          end
+        current_enclosure = current_enclosure_expr
+        case node.operator.type
+        when "*"
+          @mul_exprs[current_enclosure] += 1
+          W(:W0498, current_enclosure.head_location) if include_ambiguous_expr?
+        when "/"
+          @div_exprs[current_enclosure] += 1
+          W(:W0498, current_enclosure.head_location) if include_ambiguous_expr?
         end
+        super
+      end
 
-        if include_ambiguous_expr?
-          W(:W0498, @expression.head_location)
-        else
-          super
-        end
+      def visit_conditional_expression(node)
+        AmbiguousExpressionDetector.new(@context, node.condition).execute
+        AmbiguousExpressionDetector.new(@context, node.then_expression).execute
+        AmbiguousExpressionDetector.new(@context, node.else_expression).execute
       end
 
       private
       def include_ambiguous_expr?
-        @ungrouped_add_expr > 0 && @ungrouped_sub_expr > 0 or
-        @ungrouped_mul_expr > 0 && @ungrouped_div_expr > 0
+        enclosure = current_enclosure_expr
+        @add_exprs[enclosure] > 0 && @sub_exprs[enclosure] > 0 or
+        @mul_exprs[enclosure] > 0 && @div_exprs[enclosure] > 0
+      end
+
+      def current_enclosure_expr
+        @enclosure_expr_stack.last
       end
 
       def report
@@ -9295,6 +9343,10 @@ module CBuiltin #:nodoc:
   class W0499 < PassiveCodeCheck
     def_registrant_phase C::Prepare2Phase
 
+    # NOTE: W0499 may be duplicative when operators of the same priority are
+    #       used thrice or more.
+    ensure_uniqueness_of :W0499
+
     def initialize(context)
       super
       visitor = context[:c_visitor]
@@ -9366,15 +9418,15 @@ module CBuiltin #:nodoc:
       def initialize(context, expression)
         @context = context
         @expression = expression
-        @group_depth = 0
-        @ungrouped_shr_expr = 0
-        @ungrouped_shl_expr = 0
-        @ungrouped_lt_expr = 0
-        @ungrouped_gt_expr = 0
-        @ungrouped_le_expr = 0
-        @ungrouped_ge_expr = 0
-        @ungrouped_eq_expr = 0
-        @ungrouped_ne_expr = 0
+        @enclosure_expr_stack = [expression]
+        @shr_exprs = Hash.new(0)
+        @shl_exprs = Hash.new(0)
+        @lt_exprs = Hash.new(0)
+        @gt_exprs = Hash.new(0)
+        @le_exprs = Hash.new(0)
+        @ge_exprs = Hash.new(0)
+        @eq_exprs = Hash.new(0)
+        @ne_exprs = Hash.new(0)
       end
 
       def execute
@@ -9382,9 +9434,9 @@ module CBuiltin #:nodoc:
       end
 
       def visit_grouped_expression(node)
-        @group_depth += 1
+        @enclosure_expr_stack.push(node)
         super
-        @group_depth -= 1
+        @enclosure_expr_stack.pop
       end
 
       def visit_array_subscript_expression(node)
@@ -9398,72 +9450,77 @@ module CBuiltin #:nodoc:
       end
 
       def visit_shift_expression(node)
-        if @group_depth == 0
-          case node.operator.type
-          when "<<"
-            @ungrouped_shl_expr += 1
-          when ">>"
-            @ungrouped_shr_expr += 1
-          end
-        end
-
-        if include_ambiguous_expr?
-          W(:W0499, @expression.head_location)
-        else
-          super
+        current_enclosure = current_enclosure_expr
+        case node.operator.type
+        when "<<"
+          @shl_exprs[current_enclosure] += 1
+          W(:W0499, current_enclosure.head_location) if include_ambiguous_expr?
+        when ">>"
+          @shr_exprs[current_enclosure] += 1
+          W(:W0499, current_enclosure.head_location) if include_ambiguous_expr?
         end
+        super
       end
 
       def visit_relational_expression(node)
-        if @group_depth == 0
-          case node.operator.type
-          when "<"
-            @ungrouped_lt_expr += 1
-          when ">"
-            @ungrouped_gt_expr += 1
-          when "<="
-            @ungrouped_le_expr += 1
-          when ">="
-            @ungrouped_ge_expr += 1
-          end
-        end
-
-        if include_ambiguous_expr?
-          W(:W0499, @expression.head_location)
-        else
-          super
+        current_enclosure = current_enclosure_expr
+        case node.operator.type
+        when "<"
+          @lt_exprs[current_enclosure] += 1
+          W(:W0499, current_enclosure.head_location) if include_ambiguous_expr?
+        when ">"
+          @gt_exprs[current_enclosure] += 1
+          W(:W0499, current_enclosure.head_location) if include_ambiguous_expr?
+        when "<="
+          @le_exprs[current_enclosure] += 1
+          W(:W0499, current_enclosure.head_location) if include_ambiguous_expr?
+        when ">="
+          @ge_exprs[current_enclosure] += 1
+          W(:W0499, current_enclosure.head_location) if include_ambiguous_expr?
         end
+        super
       end
 
       def visit_equality_expression(node)
-        if @group_depth == 0
-          case node.operator.type
-          when "=="
-            @ungrouped_eq_expr += 1
-          when "!="
-            @ungrouped_ne_expr += 1
-          end
+        current_enclosure = current_enclosure_expr
+        case node.operator.type
+        when "=="
+          @eq_exprs[current_enclosure] += 1
+          W(:W0499, current_enclosure.head_location) if include_ambiguous_expr?
+        when "!="
+          @ne_exprs[current_enclosure] += 1
+          W(:W0499, current_enclosure.head_location) if include_ambiguous_expr?
         end
+        super
+      end
 
-        if include_ambiguous_expr?
-          W(:W0499, @expression.head_location)
-        else
-          super
-        end
+      def visit_conditional_expression(node)
+        AmbiguousExpressionDetector.new(@context, node.condition).execute
+        AmbiguousExpressionDetector.new(@context, node.then_expression).execute
+        AmbiguousExpressionDetector.new(@context, node.else_expression).execute
       end
 
       private
       def include_ambiguous_expr?
-        @ungrouped_shl_expr > 0 && @ungrouped_shr_expr > 0 or
-        @ungrouped_lt_expr > 0 &&
-          (@ungrouped_gt_expr + @ungrouped_le_expr + @ungrouped_ge_expr) > 0 or
-        @ungrouped_gt_expr > 0 &&
-          (@ungrouped_lt_expr + @ungrouped_le_expr + @ungrouped_ge_expr) > 0 or
-        @ungrouped_le_expr > 0 &&
-          (@ungrouped_lt_expr + @ungrouped_gt_expr + @ungrouped_ge_expr) > 0 or
-        @ungrouped_ge_expr > 0 &&
-          (@ungrouped_lt_expr + @ungrouped_gt_expr + @ungrouped_le_expr) > 0 or
-        @ungrouped_eq_expr > 0 && @ungrouped_ne_expr > 0
+        shl_expr_num = @shl_exprs[current_enclosure_expr]
+        shr_expr_num = @shr_exprs[current_enclosure_expr]
+        lt_expr_num = @lt_exprs[current_enclosure_expr]
+        gt_expr_num = @gt_exprs[current_enclosure_expr]
+        le_expr_num = @le_exprs[current_enclosure_expr]
+        ge_expr_num = @ge_exprs[current_enclosure_expr]
+        eq_expr_num = @eq_exprs[current_enclosure_expr]
+        ne_expr_num = @ne_exprs[current_enclosure_expr]
+
+        shl_expr_num > 0 && shr_expr_num > 0 or
+        lt_expr_num > 0 && (gt_expr_num + le_expr_num + ge_expr_num) > 0 or
+        gt_expr_num > 0 && (lt_expr_num + le_expr_num + ge_expr_num) > 0 or
+        le_expr_num > 0 && (lt_expr_num + gt_expr_num + ge_expr_num) > 0 or
+        ge_expr_num > 0 && (lt_expr_num + gt_expr_num + le_expr_num) > 0 or
+        eq_expr_num > 0 && ne_expr_num > 0
+      end
+
+      def current_enclosure_expr
+        @enclosure_expr_stack.last
       end
 
       def report
@@ -9476,6 +9533,10 @@ module CBuiltin #:nodoc:
   class W0500 < PassiveCodeCheck
     def_registrant_phase C::Prepare2Phase
 
+    # NOTE: W0500 may be duplicative when operators of the different priority
+    #       are used thrice or more.
+    ensure_uniqueness_of :W0500
+
     def initialize(context)
       super
       visitor = context[:c_visitor]
@@ -9547,11 +9608,11 @@ module CBuiltin #:nodoc:
       def initialize(context, expression)
         @context = context
         @expression = expression
-        @group_depth = 0
-        @ungrouped_add_expr = 0
-        @ungrouped_sub_expr = 0
-        @ungrouped_mul_expr = 0
-        @ungrouped_div_expr = 0
+        @enclosure_expr_stack = [expression]
+        @add_exprs = Hash.new(0)
+        @sub_exprs = Hash.new(0)
+        @mul_exprs = Hash.new(0)
+        @div_exprs = Hash.new(0)
       end
 
       def execute
@@ -9559,15 +9620,9 @@ module CBuiltin #:nodoc:
       end
 
       def visit_grouped_expression(node)
-        @group_depth += 1
+        @enclosure_expr_stack.push(node)
         super
-        @group_depth -= 1
-      end
-
-      def visit_conditional_expression(node)
-        @group_depth += 1
-        super
-        @group_depth -= 1
+        @enclosure_expr_stack.pop
       end
 
       def visit_array_subscript_expression(node)
@@ -9581,43 +9636,46 @@ module CBuiltin #:nodoc:
       end
 
       def visit_multiplicative_expression(node)
-        if @group_depth == 0
-          case node.operator.type
-          when "*"
-            @ungrouped_mul_expr += 1
-          when "/"
-            @ungrouped_div_expr += 1
-          end
-        end
-
-        if include_ambiguous_expr?
-          W(:W0500, @expression.head_location)
-        else
-          super
+        current_enclosure = current_enclosure_expr
+        case node.operator.type
+        when "*"
+          @mul_exprs[current_enclosure] += 1
+          W(:W0500, current_enclosure.head_location) if include_ambiguous_expr?
+        when "/"
+          @div_exprs[current_enclosure] += 1
+          W(:W0500, current_enclosure.head_location) if include_ambiguous_expr?
         end
+        super
       end
 
       def visit_additive_expression(node)
-        if @group_depth == 0
-          case node.operator.type
-          when "+"
-            @ungrouped_add_expr += 1
-          when "-"
-            @ungrouped_sub_expr += 1
-          end
+        current_enclosure = current_enclosure_expr
+        case node.operator.type
+        when "+"
+          @add_exprs[current_enclosure] += 1
+          W(:W0500, current_enclosure.head_location) if include_ambiguous_expr?
+        when "-"
+          @sub_exprs[current_enclosure] += 1
+          W(:W0500, current_enclosure.head_location) if include_ambiguous_expr?
         end
+        super
+      end
 
-        if include_ambiguous_expr?
-          W(:W0500, @expression.head_location)
-        else
-          super
-        end
+      def visit_conditional_expression(node)
+        AmbiguousExpressionDetector.new(@context, node.condition).execute
+        AmbiguousExpressionDetector.new(@context, node.then_expression).execute
+        AmbiguousExpressionDetector.new(@context, node.else_expression).execute
       end
 
       private
       def include_ambiguous_expr?
-        (@ungrouped_add_expr + @ungrouped_sub_expr) > 0 &&
-          (@ungrouped_mul_expr + @ungrouped_div_expr) > 0
+        current_enclosure = current_enclosure_expr
+        (@add_exprs[current_enclosure] + @sub_exprs[current_enclosure]) > 0 &&
+          (@mul_exprs[current_enclosure] + @div_exprs[current_enclosure]) > 0
+      end
+
+      def current_enclosure_expr
+        @enclosure_expr_stack.last
       end
 
       def report
@@ -9630,6 +9688,10 @@ module CBuiltin #:nodoc:
   class W0501 < PassiveCodeCheck
     def_registrant_phase C::Prepare2Phase
 
+    # NOTE: W0501 may be duplicative when problematic operators appear thrice
+    #       or more in an expression.
+    ensure_uniqueness_of :W0501
+
     def initialize(context)
       super
       visitor = context[:c_visitor]
@@ -9703,7 +9765,6 @@ module CBuiltin #:nodoc:
       def initialize(context, expression)
         @context = context
         @expression = expression
-        @already_warned = false
         @group_depth = 0
         @ungrouped_binary_expr = 0
       end
@@ -9781,12 +9842,7 @@ module CBuiltin #:nodoc:
       private
       def check_binary_expression
         @ungrouped_binary_expr += 1 if @group_depth == 0
-        unless @already_warned
-          if include_ambiguous_expr?
-            W(:W0501, @expression.head_location)
-            @already_warned = true
-          end
-        end
+        W(:W0501, @expression.location) if include_ambiguous_expr?
       end
 
       def include_ambiguous_expr?
@@ -9803,6 +9859,10 @@ module CBuiltin #:nodoc:
   class W0502 < PassiveCodeCheck
     def_registrant_phase C::Prepare2Phase
 
+    # NOTE: W0502 may be duplicative when operators of the different priority
+    #       are used thrice or more.
+    ensure_uniqueness_of :W0502
+
     def initialize(context)
       super
       visitor = context[:c_visitor]
@@ -9874,18 +9934,17 @@ module CBuiltin #:nodoc:
       def initialize(context, expression)
         @context = context
         @expression = expression
-        @already_warned = false
-        @group_depth = 0
-        @ungrouped_multiplicative_expr = 0
-        @ungrouped_additive_expr = 0
-        @ungrouped_shift_expr = 0
-        @ungrouped_relational_expr = 0
-        @ungrouped_equality_expr = 0
-        @ungrouped_and_expr = 0
-        @ungrouped_xor_expr = 0
-        @ungrouped_or_expr = 0
-        @ungrouped_logical_and_expr = 0
-        @ungrouped_logical_or_expr = 0
+        @enclosure_expr_stack = [expression]
+        @multiplicative_exprs = Hash.new(0)
+        @additive_exprs = Hash.new(0)
+        @shift_exprs = Hash.new(0)
+        @relational_exprs = Hash.new(0)
+        @equality_exprs = Hash.new(0)
+        @and_exprs = Hash.new(0)
+        @xor_exprs = Hash.new(0)
+        @or_exprs = Hash.new(0)
+        @logical_and_exprs = Hash.new(0)
+        @logical_or_exprs = Hash.new(0)
       end
 
       def execute
@@ -9893,134 +9952,157 @@ module CBuiltin #:nodoc:
       end
 
       def visit_grouped_expression(node)
-        @group_depth += 1
+        @enclosure_expr_stack.push(node)
         super
-        @group_depth -= 1
+        @enclosure_expr_stack.pop
+      end
+
+      def visit_array_subscript_expression(node)
+        AmbiguousExpressionDetector.new(@context, node.array_subscript).execute
+      end
+
+      def visit_function_call_expression(node)
+        node.argument_expressions.each do |expr|
+          AmbiguousExpressionDetector.new(@context, expr).execute
+        end
       end
 
       def visit_multiplicative_expression(node)
         super
-        @ungrouped_multiplicative_expr += 1 if @group_depth == 0
+        @multiplicative_exprs[current_enclosure_expr] += 1
       end
 
       def visit_additive_expression(node)
         super
-        @ungrouped_additive_expr += 1 if @group_depth == 0
+        @additive_exprs[current_enclosure_expr] += 1
       end
 
       def visit_shift_expression(node)
         super
-        @ungrouped_shift_expr += 1 if @group_depth == 0
-
-        unless @already_warned
-          if @ungrouped_multiplicative_expr + @ungrouped_additive_expr > 0
-            W(:W0502, @expression.head_location)
-            @already_warned = true
-          end
+        @shift_exprs[current_enclosure_expr] += 1
+        if current_multiplicative_exprs + current_additive_exprs > 0
+          W(:W0502, current_enclosure_expr.head_location)
         end
       end
 
       def visit_relational_expression(node)
         super
-        @ungrouped_relational_expr += 1 if @group_depth == 0
-
-        unless @already_warned
-          if @ungrouped_multiplicative_expr + @ungrouped_additive_expr +
-              @ungrouped_shift_expr > 0
-            W(:W0502, @expression.head_location)
-            @already_warned = true
-          end
+        @relational_exprs[current_enclosure_expr] += 1
+        if current_multiplicative_exprs + current_additive_exprs +
+            current_shift_exprs > 0
+          W(:W0502, current_enclosure_expr.head_location)
         end
       end
 
       def visit_equality_expression(node)
         super
-        @ungrouped_equality_expr += 1 if @group_depth == 0
-
-        unless @already_warned
-          if @ungrouped_multiplicative_expr + @ungrouped_additive_expr +
-              @ungrouped_shift_expr + @ungrouped_relational_expr > 0
-            W(:W0502, @expression.head_location)
-            @already_warned = true
-          end
+        @equality_exprs[current_enclosure_expr] += 1
+        if current_multiplicative_exprs + current_additive_exprs +
+            current_shift_exprs + current_relational_exprs > 0
+          W(:W0502, current_enclosure_expr.head_location)
         end
       end
 
       def visit_and_expression(node)
         super
-        @ungrouped_and_expr += 1 if @group_depth == 0
-
-        unless @already_warned
-          if @ungrouped_multiplicative_expr + @ungrouped_additive_expr +
-              @ungrouped_shift_expr + @ungrouped_relational_expr +
-              @ungrouped_equality_expr > 0
-            W(:W0502, @expression.head_location)
-            @already_warned = true
-          end
+        @and_exprs[current_enclosure_expr] += 1
+        if current_multiplicative_exprs + current_additive_exprs +
+            current_shift_exprs + current_relational_exprs +
+            current_equality_exprs > 0
+          W(:W0502, current_enclosure_expr.head_location)
         end
       end
 
       def visit_exclusive_or_expression(node)
         super
-        @ungrouped_xor_expr += 1 if @group_depth == 0
-
-        unless @already_warned
-          if @ungrouped_multiplicative_expr + @ungrouped_additive_expr +
-              @ungrouped_shift_expr + @ungrouped_relational_expr +
-              @ungrouped_equality_expr + @ungrouped_and_expr > 0
-            W(:W0502, @expression.head_location)
-            @already_warned = true
-          end
+        @xor_exprs[current_enclosure_expr] += 1
+        if current_multiplicative_exprs + current_additive_exprs +
+            current_shift_exprs + current_relational_exprs +
+            current_equality_exprs + current_and_exprs > 0
+          W(:W0502, current_enclosure_expr.head_location)
         end
       end
 
       def visit_inclusive_or_expression(node)
         super
-        @ungrouped_or_expr += 1 if @group_depth == 0
-
-        unless @already_warned
-          if @ungrouped_multiplicative_expr + @ungrouped_additive_expr +
-              @ungrouped_shift_expr + @ungrouped_relational_expr +
-              @ungrouped_equality_expr + @ungrouped_and_expr +
-              @ungrouped_xor_expr > 0
-            W(:W0502, @expression.head_location)
-            @already_warned = true
-          end
+        @or_exprs[current_enclosure_expr] += 1
+        if current_multiplicative_exprs + current_additive_exprs +
+            current_shift_exprs + current_relational_exprs +
+            current_equality_exprs + current_and_exprs + current_xor_exprs > 0
+          W(:W0502, current_enclosure_expr.head_location)
         end
       end
 
       def visit_logical_and_expression(node)
         super
-        @ungrouped_logical_and_expr += 1 if @group_depth == 0
-
-        unless @already_warned
-          if @ungrouped_multiplicative_expr + @ungrouped_additive_expr +
-              @ungrouped_shift_expr + @ungrouped_relational_expr +
-              @ungrouped_equality_expr + @ungrouped_and_expr +
-              @ungrouped_xor_expr + @ungrouped_or_expr > 0
-            W(:W0502, @expression.head_location)
-            @already_warned = true
-          end
+        @logical_and_exprs[current_enclosure_expr] += 1
+        if current_multiplicative_exprs + current_additive_exprs +
+            current_shift_exprs + current_relational_exprs +
+            current_equality_exprs + current_and_exprs +
+            current_xor_exprs + current_or_exprs > 0
+          W(:W0502, current_enclosure_expr.head_location)
         end
       end
 
       def visit_logical_or_expression(node)
         super
-        @ungrouped_logical_or_expr += 1 if @group_depth == 0
-
-        unless @already_warned
-          if @ungrouped_multiplicative_expr + @ungrouped_additive_expr +
-              @ungrouped_shift_expr + @ungrouped_relational_expr +
-              @ungrouped_equality_expr + @ungrouped_and_expr +
-              @ungrouped_xor_expr + @ungrouped_or_expr +
-              @ungrouped_logical_and_expr > 0
-            W(:W0502, @expression.head_location)
-            @already_warned = true
-          end
+        @logical_or_exprs[current_enclosure_expr] += 1
+        if current_multiplicative_exprs + current_additive_exprs +
+            current_shift_exprs + current_relational_exprs +
+            current_equality_exprs + current_and_exprs +
+            current_xor_exprs + current_or_exprs +
+            current_logical_and_exprs > 0
+          W(:W0502, current_enclosure_expr.head_location)
         end
       end
 
+      def visit_conditional_expression(node)
+        AmbiguousExpressionDetector.new(@context, node.condition).execute
+        AmbiguousExpressionDetector.new(@context, node.then_expression).execute
+        AmbiguousExpressionDetector.new(@context, node.else_expression).execute
+      end
+
       private
+      def current_multiplicative_exprs
+        @multiplicative_exprs[current_enclosure_expr]
+      end
+
+      def current_additive_exprs
+        @additive_exprs[current_enclosure_expr]
+      end
+
+      def current_shift_exprs
+        @shift_exprs[current_enclosure_expr]
+      end
+
+      def current_relational_exprs
+        @relational_exprs[current_enclosure_expr]
+      end
+
+      def current_equality_exprs
+        @equality_exprs[current_enclosure_expr]
+      end
+
+      def current_and_exprs
+        @and_exprs[current_enclosure_expr]
+      end
+
+      def current_xor_exprs
+        @xor_exprs[current_enclosure_expr]
+      end
+
+      def current_or_exprs
+        @or_exprs[current_enclosure_expr]
+      end
+
+      def current_logical_and_exprs
+        @logical_and_exprs[current_enclosure_expr]
+      end
+
+      def current_enclosure_expr
+        @enclosure_expr_stack.last
+      end
+
       def report
         @context.report
       end