adlint 2.6.14 → 3.0.0

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

@@ -1,7 +1,7 @@
 # Code checkings (cpp-phase) of adlint-exam-c_builtin package.
 #
 # Author::    Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
-# Copyright:: Copyright (C) 2010-2012, OGIS-RI Co.,Ltd.
+# Copyright:: Copyright (C) 2010-2013, OGIS-RI Co.,Ltd.
 # License::   GPLv3+: GNU General Public License version 3 or later
 #
 # Owner::     Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
@@ -11,7 +11,7 @@
 #    /   |  / _  |/ /   / / | / /__  __/           Source Code Static Analyzer
 #   / /| | / / / / /   / /  |/ /  / /                   AdLint - Advanced Lint
 #  / __  |/ /_/ / /___/ / /|  /  / /
-# /_/  |_|_____/_____/_/_/ |_/  /_/   Copyright (C) 2010-2012, OGIS-RI Co.,Ltd.
+# /_/  |_|_____/_____/_/_/ |_/  /_/   Copyright (C) 2010-2013, OGIS-RI Co.,Ltd.
 #
 # This file is part of AdLint.
 #
@@ -31,6 +31,7 @@
 
 require "adlint/exam"
 require "adlint/report"
+require "adlint/traits"
 require "adlint/cpp/phase"
 require "adlint/cpp/util"
 
@@ -43,20 +44,20 @@ module CBuiltin #:nodoc:
 
     # NOTE: W0001 may be duplicative when the same header which has the deeply
     #       grouped expression is included twice or more.
-    ensure_uniqueness_of :W0001
+    mark_as_unique
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      visitor = context[:cpp_visitor]
-      visitor.enter_grouped_expression += method(:enter_grouped_expression)
-      visitor.leave_grouped_expression += method(:leave_grouped_expression)
+      visitor = phase_ctxt[:cpp_visitor]
+      visitor.enter_grouped_expression += T(:enter_grouped_expression)
+      visitor.leave_grouped_expression += T(:leave_grouped_expression)
       @group_depth = 0
     end
 
     private
     def enter_grouped_expression(node)
       @group_depth += 1
-      W(:W0001, node.location) if @group_depth == 32
+      W(node.location) if @group_depth == 32
     end
 
     def leave_grouped_expression(node)
@@ -67,32 +68,32 @@ module CBuiltin #:nodoc:
   class W0025 < PassiveCodeCheck
     def_registrant_phase Cpp::Prepare2Phase
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      interp = context[:cpp_interpreter]
-      interp.on_user_header_included += method(:check_user_include)
-      interp.on_system_header_included += method(:check_system_include)
-      @user_header_fpaths = Set.new
-      @system_header_fpaths = Set.new
+      interp = phase_ctxt[:cpp_interpreter]
+      interp.on_user_header_included   += T(:check_user_include)
+      interp.on_system_header_included += T(:check_system_include)
+      @usr_header_fpaths = Set.new
+      @sys_header_fpaths = Set.new
     end
 
     private
-    def check_user_include(user_include_line, user_header)
-      if @user_header_fpaths.include?(user_header.fpath)
-        W(:W0025, user_include_line.location, user_include_line.fpath)
+    def check_user_include(usr_include_line, usr_header)
+      if @usr_header_fpaths.include?(usr_header.fpath)
+        W(usr_include_line.location, usr_include_line.fpath)
       else
-        if user_include_line.include_depth == 1
-          @user_header_fpaths.add(user_header.fpath)
+        if usr_include_line.include_depth == 1
+          @usr_header_fpaths.add(usr_header.fpath)
         end
       end
     end
 
-    def check_system_include(system_include_line, system_header)
-      if @system_header_fpaths.include?(system_header.fpath)
-        W(:W0025, system_include_line.location, system_include_line.fpath)
+    def check_system_include(sys_include_line, sys_header)
+      if @sys_header_fpaths.include?(sys_header.fpath)
+        W(sys_include_line.location, sys_include_line.fpath)
       else
-        if system_include_line.include_depth == 1
-          @system_header_fpaths.add(system_header.fpath)
+        if sys_include_line.include_depth == 1
+          @sys_header_fpaths.add(sys_header.fpath)
         end
       end
     end
@@ -101,32 +102,32 @@ module CBuiltin #:nodoc:
   class W0026 < PassiveCodeCheck
     def_registrant_phase Cpp::Prepare2Phase
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      interp = context[:cpp_interpreter]
-      interp.on_user_header_included += method(:check_user_include)
-      interp.on_system_header_included += method(:check_system_include)
-      @user_header_fpaths = Set.new
-      @system_header_fpaths = Set.new
+      interp = phase_ctxt[:cpp_interpreter]
+      interp.on_user_header_included   += T(:check_user_include)
+      interp.on_system_header_included += T(:check_system_include)
+      @usr_header_fpaths = Set.new
+      @sys_header_fpaths = Set.new
     end
 
     private
-    def check_user_include(user_include_line, user_header)
-      if @user_header_fpaths.include?(user_header.fpath)
-        W(:W0026, user_include_line.location, user_include_line.fpath)
+    def check_user_include(usr_include_line, usr_header)
+      if @usr_header_fpaths.include?(usr_header.fpath)
+        W(usr_include_line.location, usr_include_line.fpath)
       else
-        if user_include_line.include_depth > 1
-          @user_header_fpaths.add(user_header.fpath)
+        if usr_include_line.include_depth > 1
+          @usr_header_fpaths.add(usr_header.fpath)
         end
       end
     end
 
-    def check_system_include(system_include_line, system_header)
-      if @system_header_fpaths.include?(system_header.fpath)
-        W(:W0026, system_include_line.location, system_include_line.fpath)
+    def check_system_include(sys_include_line, sys_header)
+      if @sys_header_fpaths.include?(sys_header.fpath)
+        W(sys_include_line.location, sys_include_line.fpath)
       else
-        if system_include_line.include_depth > 1
-          @system_header_fpaths.add(system_header.fpath)
+        if sys_include_line.include_depth > 1
+          @sys_header_fpaths.add(sys_header.fpath)
         end
       end
     end
@@ -135,16 +136,16 @@ module CBuiltin #:nodoc:
   class W0053 < PassiveCodeCheck
     def_registrant_phase Cpp::Prepare2Phase
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      interp = context[:cpp_interpreter]
-      interp.on_user_header_included += method(:check_user_include)
+      interp = phase_ctxt[:cpp_interpreter]
+      interp.on_user_header_included += T(:check_user_include)
     end
 
     private
-    def check_user_include(user_include_line, user_header)
-      if user_include_line.include_depth == 7
-        W(:W0053, user_include_line.location, user_header.fpath)
+    def check_user_include(usr_include_line, usr_header)
+      if usr_include_line.include_depth == 7
+        W(usr_include_line.location, usr_header.fpath)
       end
     end
   end
@@ -152,21 +153,21 @@ module CBuiltin #:nodoc:
   class W0054 < PassiveCodeCheck
     def_registrant_phase Cpp::Prepare2Phase
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      visitor = context[:cpp_visitor]
-      visitor.enter_if_section += method(:enter_if_section)
-      visitor.leave_if_section += method(:leave_if_section)
+      visitor = phase_ctxt[:cpp_visitor]
+      visitor.enter_if_section += T(:enter_if_section)
+      visitor.leave_if_section += T(:leave_if_section)
       @if_depth = 0
     end
 
     private
     def enter_if_section(node)
       @if_depth += 1
-      W(:W0054, node.location) if @if_depth == 9
+      W(node.location) if @if_depth == 9
     end
 
-    def leave_if_section(node)
+    def leave_if_section(*)
       @if_depth -= 1
     end
   end
@@ -174,33 +175,45 @@ module CBuiltin #:nodoc:
   class W0055 < PassiveCodeCheck
     def_registrant_phase Cpp::Prepare2Phase
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      interp = context[:cpp_interpreter]
-      interp.on_object_like_macro_defined += method(:check)
-      interp.on_function_like_macro_defined += method(:check)
-      interp.on_va_function_like_macro_defined += method(:check)
+      interp = phase_ctxt[:cpp_interpreter]
+      interp.on_object_like_macro_defined      += T(:check)
+      interp.on_function_like_macro_defined    += T(:check)
+      interp.on_va_function_like_macro_defined += T(:check)
       @macro_num = 0
     end
 
     private
-    def check(define_line, macro)
+    def check(define_line, *)
       unless in_initial_header?(define_line)
         @macro_num += 1
-        W(:W0055, define_line.location) if @macro_num == 1025
+        W(define_line.location) if @macro_num == 1025
       end
     end
 
     def in_initial_header?(node)
-      case
-      when pinit_fpath = Traits.instance.of_project.initial_header
-        File.identical?(node.location.fpath, pinit_fpath)
-      when cinit_fpath = Traits.instance.of_compiler.initial_header
-        File.identical?(node.location.fpath, cinit_fpath)
+      node.location.fpath.identical?(pinit_fpath) ||
+        node.location.fpath.identical?(cinit_fpath)
+    end
+
+    def pinit_fpath
+      if fpath = traits.of_project.initial_header
+        Pathname.new(fpath)
       else
-        false
+        nil
       end
     end
+    memoize :pinit_fpath
+
+    def cinit_fpath
+      if fpath = traits.of_compiler.initial_header
+        Pathname.new(fpath)
+      else
+        nil
+      end
+    end
+    memoize :cinit_fpath
   end
 
   class W0056 < PassiveCodeCheck
@@ -208,20 +221,18 @@ module CBuiltin #:nodoc:
 
     # NOTE: W0056 may be duplicative when the same header which has macro
     #       definition with too many parameters is included twice or more.
-    ensure_uniqueness_of :W0056
+    mark_as_unique
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      interp = context[:cpp_interpreter]
-      interp.on_function_like_macro_defined += method(:check)
-      interp.on_va_function_like_macro_defined += method(:check)
+      interp = phase_ctxt[:cpp_interpreter]
+      interp.on_function_like_macro_defined    += T(:check)
+      interp.on_va_function_like_macro_defined += T(:check)
     end
 
     private
     def check(define_line, macro)
-      if macro.parameter_names.size > 31
-        W(:W0056, define_line.location)
-      end
+      W(define_line.location) if macro.parameter_names.size > 31
     end
   end
 
@@ -230,19 +241,17 @@ module CBuiltin #:nodoc:
 
     # NOTE: W0057 may be duplicative when the same header which has macro call
     #       with too many arguments is included twice or more.
-    ensure_uniqueness_of :W0057
+    mark_as_unique
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      macro_table = context[:cpp_macro_table]
-      macro_table.on_function_like_macro_replacement += method(:check)
+      macro_table = phase_ctxt[:cpp_macro_table]
+      macro_table.on_function_like_macro_replacement += T(:check)
     end
 
     private
-    def check(macro, replacing_tokens, *)
-      if macro.parameter_names.size > 31
-        W(:W0057, replacing_tokens.first.location)
-      end
+    def check(macro, repl_toks, *)
+      W(repl_toks.first.location) if macro.parameter_names.size > 31
     end
   end
 
@@ -251,12 +260,20 @@ module CBuiltin #:nodoc:
 
     # NOTE: W0059 may be duplicative when the same header which has carriage
     #       return at end of lines is included twice or more.
-    ensure_uniqueness_of :W0059
+    mark_as_unique
+
+    # NOTE: W0059 may be detected before evaluating the annotation for message
+    #       suppression.
+    mark_as_deferred
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      context[:cpp_interpreter].on_cr_at_eol_found +=
-        lambda { |location| W(:W0059, location) }
+      phase_ctxt[:cpp_interpreter].on_cr_at_eol_found += M(:check)
+    end
+
+    private
+    def check(loc)
+      W(loc) if loc.in_analysis_target?(traits)
     end
   end
 
@@ -265,12 +282,20 @@ module CBuiltin #:nodoc:
 
     # NOTE: W0060 may be duplicative when the same header which has the
     #       end-of-file mark is included twice or more.
-    ensure_uniqueness_of :W0060
+    mark_as_unique
 
-    def initialize(context)
+    # NOTE: W0060 may be detected before evaluating the annotation for message
+    #       suppression.
+    mark_as_deferred
+
+    def initialize(phase_ctxt)
       super
-      context[:cpp_interpreter].on_eof_mark_at_eof_found +=
-        lambda { |location| W(:W0060, location) }
+      phase_ctxt[:cpp_interpreter].on_eof_mark_at_eof_found += M(:check)
+    end
+
+    private
+    def check(loc)
+      W(loc) if loc.in_analysis_target?(traits)
     end
   end
 
@@ -280,21 +305,24 @@ module CBuiltin #:nodoc:
     # NOTE: W0061 may be duplicative when the same header which has the token
     #       sequence of the compiler specific extension is included twice or
     #       more.
-    ensure_uniqueness_of :W0061
+    mark_as_unique
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      context[:c_source].on_language_extension += method(:check)
+      phase_ctxt[:cc1_source].on_language_extension += M(:check)
     end
 
     private
-    def check(matched_tokens)
-      W(:W0061, matched_tokens.first.location, tokens_to_str(matched_tokens))
+    def check(matched_toks)
+      head_loc = matched_toks.first.location
+      if head_loc.in_analysis_target?(traits)
+        W(head_loc, tokens_to_str(matched_toks))
+      end
     end
 
-    def tokens_to_str(tokens)
-      tokens.map { |token|
-        token.type == :NEW_LINE ? nil : token.value
+    def tokens_to_str(toks)
+      toks.map { |tok|
+        tok.type == :NEW_LINE ? nil : tok.value
       }.compact.join(" ")
     end
   end
@@ -304,12 +332,16 @@ module CBuiltin #:nodoc:
 
     # NOTE: W0069 may be duplicative when the same header which has the nested
     #       block comment is included twice or more.
-    ensure_uniqueness_of :W0069
+    mark_as_unique
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      context[:cpp_interpreter].on_nested_block_comment_found +=
-        lambda { |location| W(:W0069, location) }
+      phase_ctxt[:cpp_interpreter].on_nested_block_comment_found += M(:check)
+    end
+
+    private
+    def check(loc)
+      W(loc) if loc.in_analysis_target?(traits)
     end
   end
 
@@ -319,25 +351,25 @@ module CBuiltin #:nodoc:
     # NOTE: W0072 may be duplicative when the same header which has non
     #       basic-source-character in the #include directive is included twice
     #       or more.
-    ensure_uniqueness_of :W0072
+    mark_as_unique
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      visitor = context[:cpp_visitor]
-      visitor.enter_user_include_line += method(:check_user_include_line)
-      visitor.enter_system_include_line += method(:check_system_include_line)
+      visitor = phase_ctxt[:cpp_visitor]
+      visitor.enter_user_include_line   += T(:check_user_include_line)
+      visitor.enter_system_include_line += T(:check_system_include_line)
     end
 
     private
     def check_user_include_line(node)
       unless Cpp::BasicSourceCharacterSet.include?(node.header_name.value)
-        W(:W0072, node.header_name.location)
+        W(node.header_name.location)
       end
     end
 
     def check_system_include_line(node)
       unless Cpp::BasicSourceCharacterSet.include?(node.header_name.value)
-        W(:W0072, node.header_name.location)
+        W(node.header_name.location)
       end
     end
   end
@@ -347,16 +379,16 @@ module CBuiltin #:nodoc:
 
     # NOTE: W0073 may be duplicative when the same header without the
     #       include-guard is included twice or more.
-    ensure_uniqueness_of :W0073
+    mark_as_unique
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      visitor = context[:cpp_visitor]
-      visitor.enter_user_include_line += method(:enter_include_line)
-      visitor.enter_system_include_line += method(:enter_include_line)
-      visitor.enter_text_line += method(:enter_text_line)
-      visitor.enter_if_section += method(:enter_if_section)
-      @main_fpath = context[:sources].first.fpath
+      visitor = phase_ctxt[:cpp_visitor]
+      visitor.enter_user_include_line   += T(:enter_include_line)
+      visitor.enter_system_include_line += T(:enter_include_line)
+      visitor.enter_text_line           += T(:enter_text_line)
+      visitor.enter_if_section          += T(:enter_if_section)
+      @main_fpath = phase_ctxt[:sources].first.fpath
       @last_fpath = nil
       @enclosed_by_if_section = false
       @warned_files = Set.new
@@ -372,7 +404,7 @@ module CBuiltin #:nodoc:
       return if in_initial_header?(node) || in_main_file?(node)
 
       unless @enclosed_by_if_section || in_warned_file?(node)
-        W(:W0073, node.location)
+        W(node.location)
         @warned_files.add(node.location.fpath)
       end
     end
@@ -388,7 +420,7 @@ module CBuiltin #:nodoc:
       end
 
       unless @enclosed_by_if_section || in_warned_file?(node)
-        W(:W0073, node.location)
+        W(node.location)
         @warned_files.add(node.location.fpath)
       end
     end
@@ -403,23 +435,35 @@ module CBuiltin #:nodoc:
     end
 
     def in_main_file?(node)
-      File.identical?(node.location.fpath, @main_fpath)
+      node.location.fpath == @main_fpath
     end
 
     def in_initial_header?(node)
-      case
-      when pinit_fpath = Traits.instance.of_project.initial_header
-        File.identical?(node.location.fpath, pinit_fpath)
-      when cinit_fpath = Traits.instance.of_compiler.initial_header
-        File.identical?(node.location.fpath, cinit_fpath)
-      else
-        false
-      end
+      node.location.fpath.identical?(pinit_fpath) ||
+        node.location.fpath.identical?(cinit_fpath)
     end
 
     def in_warned_file?(node)
       @warned_files.include?(node.location.fpath)
     end
+
+    def pinit_fpath
+      if fpath = traits.of_project.initial_header
+        Pathname.new(fpath)
+      else
+        nil
+      end
+    end
+    memoize :pinit_fpath
+
+    def cinit_fpath
+      if fpath = traits.of_compiler.initial_header
+        Pathname.new(fpath)
+      else
+        nil
+      end
+    end
+    memoize :cinit_fpath
   end
 
   class W0442 < PassiveCodeCheck
@@ -427,29 +471,18 @@ module CBuiltin #:nodoc:
 
     # NOTE: W0442 may be duplicative when the same header which has
     #       function-like macro definitions is included twice or more.
-    ensure_uniqueness_of :W0442
+    mark_as_unique
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      interp = context[:cpp_interpreter]
-      interp.on_function_like_macro_defined += method(:check)
-      interp.on_va_function_like_macro_defined += method(:check)
+      interp = phase_ctxt[:cpp_interpreter]
+      interp.on_function_like_macro_defined    += T(:check)
+      interp.on_va_function_like_macro_defined += T(:check)
     end
 
     private
-    def check(define_line, macro)
-      W(:W0442, define_line.location) unless in_initial_header?(define_line)
-    end
-
-    def in_initial_header?(node)
-      case
-      when pinit_fpath = Traits.instance.of_project.initial_header
-        File.identical?(node.location.fpath, pinit_fpath)
-      when cinit_fpath = Traits.instance.of_compiler.initial_header
-        File.identical?(node.location.fpath, cinit_fpath)
-      else
-        false
-      end
+    def check(define_line, *)
+      W(define_line.location)
     end
   end
 
@@ -459,42 +492,30 @@ module CBuiltin #:nodoc:
     # NOTE: W0443 may be duplicative when the same header which has
     #       functionizable function-like macro definitions is included twice or
     #       more.
-    ensure_uniqueness_of :W0443
+    mark_as_unique
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      visitor = context[:cpp_visitor]
-      visitor.enter_function_like_define_line += method(:check)
-      visitor.enter_va_function_like_define_line += method(:check)
+      visitor = phase_ctxt[:cpp_visitor]
+      visitor.enter_function_like_define_line    += T(:check)
+      visitor.enter_va_function_like_define_line += T(:check)
     end
 
     private
     def check(node)
-      return if in_initial_header?(node)
       return unless node.identifier_list
 
-      if replacement_list = node.replacement_list
-        should_be_function = replacement_list.tokens.all? { |pp_token|
-          if keyword_or_punctuator?(pp_token)
+      if repl_lsit = node.replacement_list
+        should_be_function = repl_lsit.tokens.all? { |pp_tok|
+          if keyword_or_punctuator?(pp_tok)
             false
-          elsif type_specifier_or_type_qualifier?(pp_token)
+          elsif type_specifier_or_type_qualifier?(pp_tok)
             false
           else
             true
           end
         }
-        W(:W0443, node.location) if should_be_function
-      end
-    end
-
-    def in_initial_header?(node)
-      case
-      when pinit_fpath = Traits.instance.of_project.initial_header
-        File.identical?(node.location.fpath, pinit_fpath)
-      when cinit_fpath = Traits.instance.of_compiler.initial_header
-        File.identical?(node.location.fpath, cinit_fpath)
-      else
-        false
+        W(node.location) if should_be_function
       end
     end
 
@@ -508,16 +529,16 @@ module CBuiltin #:nodoc:
     ].to_set.freeze
     private_constant :KEYWORDS
 
-    def keyword_or_punctuator?(pp_token)
-      pp_token.value == "#" || pp_token.value == "##" ||
-        pp_token.value == "{" || pp_token.value == "}" ||
-        pp_token.value == ";" || KEYWORDS.include?(pp_token.value)
+    def keyword_or_punctuator?(pp_tok)
+      pp_tok.value == "#" || pp_tok.value == "##" ||
+        pp_tok.value == "{" || pp_tok.value == "}" ||
+        pp_tok.value == ";" || KEYWORDS.include?(pp_tok.value)
     end
 
-    def type_specifier_or_type_qualifier?(pp_token)
-      pp_token.value == "const" || pp_token.value == "volatile" ||
-        pp_token.value == "restrict" ||
-        @context[:c_type_table].all_type_names.include?(pp_token.value)
+    def type_specifier_or_type_qualifier?(pp_tok)
+      pp_tok.value == "const" || pp_tok.value == "volatile" ||
+        pp_tok.value == "restrict" ||
+        @phase_ctxt[:cc1_type_table].all_type_names.include?(pp_tok.value)
     end
   end
 
@@ -527,23 +548,23 @@ module CBuiltin #:nodoc:
     # NOTE: W0444 may be duplicative when the same header which has the
     #       function-like macro definition with `#' and `##' operators is
     #       included twice or more.
-    ensure_uniqueness_of :W0444
+    mark_as_unique
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      interp = context[:cpp_interpreter]
-      interp.on_function_like_macro_defined += method(:check)
-      interp.on_va_function_like_macro_defined += method(:check)
+      interp = phase_ctxt[:cpp_interpreter]
+      interp.on_function_like_macro_defined    += T(:check)
+      interp.on_va_function_like_macro_defined += T(:check)
     end
 
     private
     def check(define_line, macro)
-      if replacement_list = macro.replacement_list
+      if repl_list = macro.replacement_list
         sharp_op_num = 0
         sharpsharp_op_num = 0
 
-        replacement_list.tokens.each do |pp_token|
-          case pp_token.value
+        repl_list.tokens.each do |pp_tok|
+          case pp_tok.value
           when "#"
             sharp_op_num += 1
           when "##"
@@ -551,9 +572,7 @@ module CBuiltin #:nodoc:
           end
         end
 
-        if sharp_op_num > 0 && sharpsharp_op_num > 0
-          W(:W0444, define_line.location)
-        end
+        W(define_line.location) if sharp_op_num > 0 && sharpsharp_op_num > 0
       end
     end
   end
@@ -564,29 +583,27 @@ module CBuiltin #:nodoc:
     # NOTE: W0445 may be duplicative when the same header which has the
     #       function-like macro definition with two or more `##' operators is
     #       included twice or more.
-    ensure_uniqueness_of :W0445
+    mark_as_unique
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      interp = context[:cpp_interpreter]
-      interp.on_function_like_macro_defined += method(:check)
-      interp.on_va_function_like_macro_defined += method(:check)
+      interp = phase_ctxt[:cpp_interpreter]
+      interp.on_function_like_macro_defined    += T(:check)
+      interp.on_va_function_like_macro_defined += T(:check)
     end
 
     private
     def check(define_line, macro)
-      if replacement_list = macro.replacement_list
+      if repl_list = macro.replacement_list
         sharpsharp_op_num = 0
 
-        replacement_list.tokens.each do |pp_token|
-          if pp_token.value == "##"
+        repl_list.tokens.each do |pp_tok|
+          if pp_tok.value == "##"
             sharpsharp_op_num += 1
           end
         end
 
-        if sharpsharp_op_num > 1
-          W(:W0445, define_line.location)
-        end
+        W(define_line.location) if sharpsharp_op_num > 1
       end
     end
   end
@@ -597,24 +614,24 @@ module CBuiltin #:nodoc:
     # NOTE: W0477 may be duplicative when the same header which has the macro
     #       definition with unbalanced grouping tokens is included twice or
     #       more.
-    ensure_uniqueness_of :W0477
+    mark_as_unique
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      interp = context[:cpp_interpreter]
-      interp.on_object_like_macro_defined += method(:check)
-      interp.on_function_like_macro_defined += method(:check)
-      interp.on_va_function_like_macro_defined += method(:check)
+      interp = phase_ctxt[:cpp_interpreter]
+      interp.on_object_like_macro_defined      += T(:check)
+      interp.on_function_like_macro_defined    += T(:check)
+      interp.on_va_function_like_macro_defined += T(:check)
     end
 
     private
     def check(define_line, macro)
-      if replacement_list = macro.replacement_list
+      if repl_list = macro.replacement_list
         paren_count = 0
         brace_count = 0
         bracket_count = 0
-        replacement_list.tokens.each do |pp_token|
-          case pp_token.value
+        repl_list.tokens.each do |pp_tok|
+          case pp_tok.value
           when "("
             paren_count += 1
           when ")"
@@ -631,7 +648,7 @@ module CBuiltin #:nodoc:
         end
 
         unless paren_count == 0 && brace_count == 0 && bracket_count == 0
-          W(:W0477, define_line.location)
+          W(define_line.location)
         end
       end
     end
@@ -642,27 +659,26 @@ module CBuiltin #:nodoc:
 
     # NOTE: W0478 may be duplicative when the same header which causes this
     #       warning is included twice or more.
-    ensure_uniqueness_of :W0478
+    mark_as_unique
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      visitor = context[:cpp_visitor]
-      visitor.enter_object_like_define_line += method(:check)
-      visitor.enter_function_like_define_line += method(:check)
-      visitor.enter_va_function_like_define_line += method(:check)
+      visitor = phase_ctxt[:cpp_visitor]
+      visitor.enter_object_like_define_line      += T(:check)
+      visitor.enter_function_like_define_line    += T(:check)
+      visitor.enter_va_function_like_define_line += T(:check)
     end
 
     private
     def check(node)
-      replacement_list = node.replacement_list
-      if replacement_list && replacement_list.tokens.size > 1
-        unless replacement_list.may_represent_expression? ||
-            replacement_list.may_represent_initializer? ||
-            replacement_list.may_represent_block? ||
-            replacement_list.may_represent_do_while_zero_idiom? ||
-            replacement_list.may_represent_specifier_qualifier_list? ||
-            replacement_list.may_represent_declaration_specifiers_head?
-          W(:W0478, node.location)
+      if repl_list = node.replacement_list and repl_list.tokens.size > 1
+        unless repl_list.may_represent_expression? ||
+            repl_list.may_represent_initializer? ||
+            repl_list.may_represent_block? ||
+            repl_list.may_represent_do_while_zero_idiom? ||
+            repl_list.may_represent_specifier_qualifier_list? ||
+            repl_list.may_represent_declaration_specifiers_head?
+          W(node.location)
         end
       end
     end
@@ -673,19 +689,19 @@ module CBuiltin #:nodoc:
 
     # NOTE: W0479 may be duplicative when the same header which has
     #       typedef-able macro definition is included twice or more.
-    ensure_uniqueness_of :W0479
+    mark_as_unique
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      visitor = context[:cpp_visitor]
-      visitor.enter_object_like_define_line += method(:check)
+      visitor = phase_ctxt[:cpp_visitor]
+      visitor.enter_object_like_define_line += T(:check)
     end
 
     private
     def check(node)
-      if replacement_list = node.replacement_list
-        if replacement_list.may_represent_specifier_qualifier_list?
-          W(:W0479, node.location)
+      if repl_list = node.replacement_list
+        if repl_list.may_represent_specifier_qualifier_list?
+          W(node.location)
         end
       end
     end
@@ -696,23 +712,22 @@ module CBuiltin #:nodoc:
 
     # NOTE: W0480 may be duplicative when the same header which causes this
     #       warning is included twice or more.
-    ensure_uniqueness_of :W0480
+    mark_as_unique
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      visitor = context[:cpp_visitor]
-      visitor.enter_object_like_define_line += method(:check)
-      visitor.enter_function_like_define_line += method(:check)
-      visitor.enter_va_function_like_define_line += method(:check)
+      visitor = phase_ctxt[:cpp_visitor]
+      visitor.enter_object_like_define_line      += T(:check)
+      visitor.enter_function_like_define_line    += T(:check)
+      visitor.enter_va_function_like_define_line += T(:check)
     end
 
     private
     def check(node)
-      replacement_list = node.replacement_list
-      if replacement_list and
-          replacement_list.may_represent_punctuator? ||
-          replacement_list.may_represent_controlling_keyword?
-        W(:W0480, node.location)
+      if repl_list = node.replacement_list and
+          repl_list.may_represent_punctuator? ||
+          repl_list.may_represent_controlling_keyword?
+        W(node.location)
       end
     end
   end
@@ -722,21 +737,20 @@ module CBuiltin #:nodoc:
 
     # NOTE: W0481 may be duplicative when the same header which causes this
     #       warning is included twice or more.
-    ensure_uniqueness_of :W0481
+    mark_as_unique
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      visitor = context[:cpp_visitor]
-      visitor.enter_object_like_define_line += method(:check)
-      visitor.enter_function_like_define_line += method(:check)
-      visitor.enter_va_function_like_define_line += method(:check)
+      visitor = phase_ctxt[:cpp_visitor]
+      visitor.enter_object_like_define_line      += T(:check)
+      visitor.enter_function_like_define_line    += T(:check)
+      visitor.enter_va_function_like_define_line += T(:check)
     end
 
     private
     def check(node)
-      replacement_list = node.replacement_list
-      if replacement_list && replacement_list.may_represent_block?
-        W(:W0481, node.location)
+      if repl_list = node.replacement_list and repl_list.may_represent_block?
+        W(node.location)
       end
     end
   end
@@ -746,26 +760,26 @@ module CBuiltin #:nodoc:
 
     # NOTE: W0482 may be duplicative when the same header which causes this
     #       warning is included twice or more.
-    ensure_uniqueness_of :W0482
+    mark_as_unique
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      visitor = context[:cpp_visitor]
-      visitor.enter_object_like_define_line += method(:check)
+      visitor = phase_ctxt[:cpp_visitor]
+      visitor.enter_object_like_define_line += T(:check)
     end
 
     private
     def check(node)
-      if replacement_list = node.replacement_list
-        return unless replacement_list.tokens.size == 1
-        if type_specifier?(replacement_list.tokens.first)
-          W(:W0482, node.location)
+      if repl_list = node.replacement_list
+        return unless repl_list.tokens.size == 1
+        if type_specifier?(repl_list.tokens.first)
+          W(node.location)
         end
       end
     end
 
-    def type_specifier?(pp_token)
-      case pp_token.value
+    def type_specifier?(pp_tok)
+      case pp_tok.value
       when "void", "char", "short", "int", "long", "float", "double"
         true
       when "signed", "unsigned"
@@ -783,19 +797,19 @@ module CBuiltin #:nodoc:
 
     # NOTE: W0483 may be duplicative when the same header which causes this
     #       warning is included twice or more.
-    ensure_uniqueness_of :W0483
+    mark_as_unique
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      visitor = context[:cpp_visitor]
-      visitor.enter_object_like_define_line += method(:check)
+      visitor = phase_ctxt[:cpp_visitor]
+      visitor.enter_object_like_define_line += T(:check)
     end
 
     private
     def check(node)
-      if replacement_list = node.replacement_list
-        if replacement_list.may_represent_declaration_specifiers_head?
-          W(:W0483, node.location)
+      if repl_list = node.replacement_list
+        if repl_list.may_represent_declaration_specifiers_head?
+          W(node.location)
         end
       end
     end
@@ -806,12 +820,16 @@ module CBuiltin #:nodoc:
 
     # NOTE: W0511 may be duplicative when the same header which causes this
     #       warning is included twice or more.
-    ensure_uniqueness_of :W0511
+    mark_as_unique
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      context[:cpp_interpreter].on_line_comment_found +=
-        lambda { |comment, location| W(:W0511, location) }
+      phase_ctxt[:cpp_interpreter].on_line_comment_found += M(:check)
+    end
+
+    private
+    def check(*, loc)
+      W(loc) if loc.in_analysis_target?(traits)
     end
   end
 
@@ -820,21 +838,21 @@ module CBuiltin #:nodoc:
 
     # NOTE: W0528 may be duplicative when the same header which causes this
     #       warning is included twice or more.
-    ensure_uniqueness_of :W0528
+    mark_as_unique
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      interp = context[:cpp_interpreter]
-      interp.on_object_like_macro_defined += method(:check)
+      interp = phase_ctxt[:cpp_interpreter]
+      interp.on_object_like_macro_defined += T(:check)
     end
 
     private
-    def check(define_line, macro)
-      if replacement_list = macro.replacement_list
-        octal_token = replacement_list.tokens.find { |pp_token|
-          pp_token.value =~ /\A0[0-9]+[UL]*\z/i
+    def check(*, macro)
+      if repl_list = macro.replacement_list
+        octal_tok = repl_list.tokens.find { |pp_tok|
+          pp_tok.value =~ /\A0[0-9]+[UL]*\z/i
         }
-        W(:W0528, octal_token.location) if octal_token
+        W(octal_tok.location) if octal_tok
       end
     end
   end
@@ -844,17 +862,18 @@ module CBuiltin #:nodoc:
 
     # NOTE: W0541 may be duplicative when the same header which causes this
     #       warning is included twice or more.
-    ensure_uniqueness_of :W0541
+    mark_as_unique
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      context[:c_source].on_inline_assembly += method(:check)
+      phase_ctxt[:cc1_source].on_inline_assembly += M(:check)
     end
 
     private
-    def check(asm_tokens)
-      unless asm_tokens.any? { |token| token.replaced? }
-        W(:W0541, asm_tokens.first.location)
+    def check(asm_toks)
+      head_loc = asm_toks.first.location
+      if head_loc.in_analysis_target?(traits)
+        W(head_loc) unless asm_toks.any? { |tok| tok.replaced? }
       end
     end
   end
@@ -864,36 +883,36 @@ module CBuiltin #:nodoc:
 
     # NOTE: W0549 may be duplicative when the same header which causes this
     #       warning is included twice or more.
-    ensure_uniqueness_of :W0549
+    mark_as_unique
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      interp = context[:cpp_interpreter]
-      interp.on_function_like_macro_defined += method(:check)
-      interp.on_va_function_like_macro_defined += method(:check)
+      interp = phase_ctxt[:cpp_interpreter]
+      interp.on_function_like_macro_defined    += T(:check)
+      interp.on_va_function_like_macro_defined += T(:check)
     end
 
     private
-    def check(define_line, macro)
+    def check(*, macro)
       return unless macro.replacement_list
 
       macro.parameter_names.each do |name|
-        macro.replacement_list.tokens.each_with_index do |pp_token, index|
-          next unless pp_token.value == name
+        macro.replacement_list.tokens.each_with_index do |pp_tok, idx|
+          next unless pp_tok.value == name
 
-          prev_token = macro.replacement_list.tokens[[index - 1, 0].max]
-          next_token = macro.replacement_list.tokens[index + 1]
+          prv_tok = macro.replacement_list.tokens[[idx - 1, 0].max]
+          nxt_tok = macro.replacement_list.tokens[idx + 1]
 
-          next if prev_token && prev_token.value =~ /\A##?\z/
-          next if next_token && next_token.value == "##"
+          next if prv_tok && prv_tok.value =~ /\A##?\z/
+          next if nxt_tok && nxt_tok.value == "##"
 
-          unless prev_token && prev_token.value == "("
-            W(:W0549, pp_token.location)
+          unless prv_tok && prv_tok.value == "("
+            W(pp_tok.location)
             next
           end
 
-          unless next_token && next_token.value == ")"
-            W(:W0549, pp_token.location)
+          unless nxt_tok && nxt_tok.value == ")"
+            W(pp_tok.location)
             next
           end
         end
@@ -906,17 +925,17 @@ module CBuiltin #:nodoc:
 
     # NOTE: W0554 may be duplicative when the same header which causes this
     #       warning is included twice or more.
-    ensure_uniqueness_of :W0554
+    mark_as_unique
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      interp = context[:cpp_interpreter]
-      interp.on_unknown_pragma_evaled += method(:check)
+      interp = phase_ctxt[:cpp_interpreter]
+      interp.on_unknown_pragma_evaled += T(:check)
     end
 
     private
     def check(pragma_line)
-      W(:W0554, pragma_line.location,
+      W(pragma_line.location,
         pragma_line.pp_tokens ? pragma_line.pp_tokens.to_s : "")
     end
   end
@@ -926,29 +945,29 @@ module CBuiltin #:nodoc:
 
     # NOTE: W0574 may be duplicative when the same header which causes this
     #       warning is included twice or more.
-    ensure_uniqueness_of :W0574
+    mark_as_unique
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      interp = context[:cpp_interpreter]
-      interp.on_pp_token_extracted += method(:check_pp_token)
-      interp.on_object_like_macro_defined += method(:check_macro)
-      interp.on_function_like_macro_defined += method(:check_macro)
-      interp.on_va_function_like_macro_defined += method(:check_macro)
+      interp = phase_ctxt[:cpp_interpreter]
+      interp.on_pp_token_extracted             += T(:check_pp_token)
+      interp.on_object_like_macro_defined      += T(:check_macro)
+      interp.on_function_like_macro_defined    += T(:check_macro)
+      interp.on_va_function_like_macro_defined += T(:check_macro)
     end
 
     private
-    def check_pp_token(pp_token)
-      if pp_token.value =~ /\AL?'(.*)'\z/
+    def check_pp_token(pp_tok)
+      if pp_tok.value =~ /\AL?'(.*)'\z/
         unless Cpp::BasicSourceCharacterSet.include?($1)
-          W(:W0574, pp_token.location)
+          W(pp_tok.location)
         end
       end
     end
 
-    def check_macro(define_line, macro)
-      if replacement_list = macro.replacement_list
-        replacement_list.tokens.each { |pp_token| check_pp_token(pp_token) }
+    def check_macro(*, macro)
+      if repl_lsit = macro.replacement_list
+        repl_lsit.tokens.each { |pp_tok| check_pp_token(pp_tok) }
       end
     end
   end
@@ -958,29 +977,29 @@ module CBuiltin #:nodoc:
 
     # NOTE: W0575 may be duplicative when the same header which causes this
     #       warning is included twice or more.
-    ensure_uniqueness_of :W0575
+    mark_as_unique
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      interp = context[:cpp_interpreter]
-      interp.on_pp_token_extracted += method(:check_pp_token)
-      interp.on_object_like_macro_defined += method(:check_macro)
-      interp.on_function_like_macro_defined += method(:check_macro)
-      interp.on_va_function_like_macro_defined += method(:check_macro)
+      interp = phase_ctxt[:cpp_interpreter]
+      interp.on_pp_token_extracted             += T(:check_pp_token)
+      interp.on_object_like_macro_defined      += T(:check_macro)
+      interp.on_function_like_macro_defined    += T(:check_macro)
+      interp.on_va_function_like_macro_defined += T(:check_macro)
     end
 
     private
-    def check_pp_token(pp_token)
-      if pp_token.value =~ /\AL?"(.*)"\z/
+    def check_pp_token(pp_tok)
+      if pp_tok.value =~ /\AL?"(.*)"\z/
         unless Cpp::BasicSourceCharacterSet.include?($1)
-          W(:W0575, pp_token.location)
+          W(pp_tok.location)
         end
       end
     end
 
-    def check_macro(define_line, macro)
-      if replacement_list = macro.replacement_list
-        replacement_list.tokens.each { |pp_token| check_pp_token(pp_token) }
+    def check_macro(*, macro)
+      if repl_list = macro.replacement_list
+        repl_list.tokens.each { |pp_tok| check_pp_token(pp_tok) }
       end
     end
   end
@@ -990,25 +1009,25 @@ module CBuiltin #:nodoc:
 
     # NOTE: W0576 may be duplicative when the same header which causes this
     #       warning is included twice or more.
-    ensure_uniqueness_of :W0576
+    mark_as_unique
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      interp = context[:cpp_interpreter]
-      interp.on_block_comment_found += method(:check)
-      interp.on_line_comment_found += method(:check)
+      interp = phase_ctxt[:cpp_interpreter]
+      interp.on_block_comment_found += M(:check)
+      interp.on_line_comment_found  += M(:check)
       @warned_chars = Set.new
     end
 
     private
-    def check(comment, location)
-      not_adapted = Cpp::BasicSourceCharacterSet.select_not_adapted(comment)
-
-      new_chars = not_adapted.to_set - @warned_chars
-
-      unless new_chars.empty?
-        W(:W0576, location, location.fpath)
-        @warned_chars.merge(new_chars)
+    def check(comment, loc)
+      if loc.in_analysis_target?(traits)
+        not_adapted = Cpp::BasicSourceCharacterSet.select_not_adapted(comment)
+        new_chars = not_adapted.to_set - @warned_chars
+        unless new_chars.empty?
+          W(loc, loc.fpath)
+          @warned_chars.merge(new_chars)
+        end
       end
     end
   end
@@ -1018,20 +1037,22 @@ module CBuiltin #:nodoc:
 
     # NOTE: W0577 may be duplicative when the same header which causes this
     #       warning is included twice or more.
-    ensure_uniqueness_of :W0577
+    mark_as_unique
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      interp = context[:cpp_interpreter]
-      interp.on_unlexable_char_found += method(:check)
+      interp = phase_ctxt[:cpp_interpreter]
+      interp.on_unlexable_char_found += M(:check)
       @warned = false
     end
 
     private
-    def check(char, location)
-      unless @warned
-        W(:W0577, location, location.fpath)
-        @warned = true
+    def check(*, loc)
+      if loc.in_analysis_target?(traits)
+        unless @warned
+          W(loc, loc.fpath)
+          @warned = true
+        end
       end
     end
   end
@@ -1041,19 +1062,19 @@ module CBuiltin #:nodoc:
 
     # NOTE: W0632 may be duplicative when the same header which has references
     #       to the undefined macro is included twice or more.
-    ensure_uniqueness_of :W0632
+    mark_as_unique
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      visitor = context[:cpp_visitor]
-      visitor.enter_system_include_line += method(:check)
-      visitor.enter_system_include_next_line += method(:check)
+      visitor = phase_ctxt[:cpp_visitor]
+      visitor.enter_system_include_line      += T(:check)
+      visitor.enter_system_include_next_line += T(:check)
     end
 
     private
     def check(include_line)
       if include_line.header_name.value =~ /['"]/
-        W(:W0632, include_line.location, include_line.header_name.value)
+        W(include_line.location, include_line.header_name.value)
       end
     end
   end
@@ -1063,19 +1084,19 @@ module CBuiltin #:nodoc:
 
     # NOTE: W0633 may be duplicative when the same header which has references
     #       to the undefined macro is included twice or more.
-    ensure_uniqueness_of :W0633
+    mark_as_unique
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      visitor = context[:cpp_visitor]
-      visitor.enter_user_include_line += method(:check)
-      visitor.enter_user_include_next_line += method(:check)
+      visitor = phase_ctxt[:cpp_visitor]
+      visitor.enter_user_include_line      += T(:check)
+      visitor.enter_user_include_next_line += T(:check)
     end
 
     private
     def check(include_line)
       if include_line.header_name.value =~ /'/
-        W(:W0633, include_line.location, include_line.header_name.value)
+        W(include_line.location, include_line.header_name.value)
       end
     end
   end
@@ -1085,21 +1106,21 @@ module CBuiltin #:nodoc:
 
     # NOTE: W0634 may be duplicative when the same header which has references
     #       to the undefined macro is included twice or more.
-    ensure_uniqueness_of :W0634
+    mark_as_unique
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      visitor = context[:cpp_visitor]
-      visitor.enter_user_include_line += method(:check)
-      visitor.enter_user_include_next_line += method(:check)
-      visitor.enter_system_include_line += method(:check)
-      visitor.enter_system_include_next_line += method(:check)
+      visitor = phase_ctxt[:cpp_visitor]
+      visitor.enter_user_include_line        += T(:check)
+      visitor.enter_user_include_next_line   += T(:check)
+      visitor.enter_system_include_line      += T(:check)
+      visitor.enter_system_include_next_line += T(:check)
     end
 
     private
     def check(include_line)
       if include_line.header_name.value.include?("\\")
-        W(:W0634, include_line.location)
+        W(include_line.location)
       end
     end
   end
@@ -1109,13 +1130,17 @@ module CBuiltin #:nodoc:
 
     # NOTE: W0643 may be duplicative when the same header which has references
     #       to the undefined macro is included twice or more.
-    ensure_uniqueness_of :W0643
+    mark_as_unique
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      macro_table = context[:cpp_macro_table]
-      macro_table.on_last_backslash_ignored +=
-        lambda { |token| W(:W0643, token.location) }
+      macro_table = phase_ctxt[:cpp_macro_table]
+      macro_table.on_last_backslash_ignored += T(:check)
+    end
+
+    private
+    def check(tok)
+      W(tok.location)
     end
   end
 
@@ -1124,17 +1149,17 @@ module CBuiltin #:nodoc:
 
     # NOTE: W0691 may be duplicative when the same header which has references
     #       to the undefined macro is included twice or more.
-    ensure_uniqueness_of :W0691
+    mark_as_unique
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      macro_table = context[:cpp_macro_table]
-      macro_table.on_sharpsharp_operator_evaled += method(:check)
+      macro_table = phase_ctxt[:cpp_macro_table]
+      macro_table.on_sharpsharp_operator_evaled += T(:check)
     end
 
     private
-    def check(lhs_token, rhs_token, new_tokens)
-      W(:W0691, new_tokens.first.location) if new_tokens.size > 1
+    def check(*, new_toks)
+      W(new_toks.first.location) if new_toks.size > 1
     end
   end
 
@@ -1143,19 +1168,19 @@ module CBuiltin #:nodoc:
 
     # NOTE: W0692 may be duplicative when the same header which has references
     #       to the undefined macro is included twice or more.
-    ensure_uniqueness_of :W0692
+    mark_as_unique
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      macro_table = context[:cpp_macro_table]
-      macro_table.on_function_like_macro_replacement += method(:check)
+      macro_table = phase_ctxt[:cpp_macro_table]
+      macro_table.on_function_like_macro_replacement += T(:check)
     end
 
     private
-    def check(macro, replacing_tokens, args, *)
+    def check(macro, repl_toks, args, *)
       unless macro.parameter_names.empty?
         if args.any? { |arg| arg.empty? }
-          W(:W0692, replacing_tokens.first.location, macro.name.value)
+          W(repl_toks.first.location, macro.name.value)
         end
       end
     end
@@ -1166,13 +1191,17 @@ module CBuiltin #:nodoc:
 
     # NOTE: W0696 may be duplicative when the same header which has references
     #       to the undefined macro is included twice or more.
-    ensure_uniqueness_of :W0696
+    mark_as_unique
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      interp = context[:cpp_interpreter]
-      interp.on_undefined_macro_referred +=
-        lambda { |token| W(:W0696, token.location, token.value) }
+      interp = phase_ctxt[:cpp_interpreter]
+      interp.on_undefined_macro_referred += T(:check)
+    end
+
+    private
+    def check(tok)
+      W(tok.location, tok.value)
     end
   end
 
@@ -1181,16 +1210,16 @@ module CBuiltin #:nodoc:
 
     # NOTE: W0804 may be duplicative when the same header which causes this
     #       warning is included twice or more.
-    ensure_uniqueness_of :W0804
+    mark_as_unique
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      context[:cpp_interpreter].on_illformed_defined_op_found += method(:check)
+      phase_ctxt[:cpp_interpreter].on_illformed_defined_op_found += M(:check)
     end
 
     private
-    def check(location, *)
-      W(:W0804, location)
+    def check(loc, *)
+      W(loc) if loc.in_analysis_target?(traits)
     end
   end
 
@@ -1199,11 +1228,13 @@ module CBuiltin #:nodoc:
 
     # NOTE: W0805 may be duplicative when the same header which causes this
     #       warning is included twice or more.
-    ensure_uniqueness_of :W0805
+    mark_as_unique
 
     private
-    def check(location, no_args)
-      W(:W0805, location) unless no_args
+    def check(loc, no_args)
+      if loc.in_analysis_target?(traits)
+        W(loc) unless no_args
+      end
     end
   end
 
@@ -1212,19 +1243,19 @@ module CBuiltin #:nodoc:
 
     # NOTE: W0811 may be duplicative when the same header which causes this
     #       warning is included twice or more.
-    ensure_uniqueness_of :W0811
+    mark_as_unique
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      macro_table = context[:cpp_macro_table]
-      macro_table.on_object_like_macro_replacement += method(:check)
-      macro_table.on_function_like_macro_replacement += method(:check)
+      macro_table = phase_ctxt[:cpp_macro_table]
+      macro_table.on_object_like_macro_replacement   += T(:check)
+      macro_table.on_function_like_macro_replacement += T(:check)
     end
 
     private
-    def check(*, result_tokens)
-      if defined_token = result_tokens.find { |t| t.value == "defined" }
-        W(:W0811, defined_token.location)
+    def check(*, res_toks)
+      if defined_tok = res_toks.find { |tok| tok.value == "defined" }
+        W(defined_tok.location)
       end
     end
   end
@@ -1234,17 +1265,17 @@ module CBuiltin #:nodoc:
 
     # NOTE: W0831 may be duplicative when the same header which causes this
     #       warning is included twice or more.
-    ensure_uniqueness_of :W0831
+    mark_as_unique
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      interp = context[:cpp_interpreter]
-      interp.on_asm_section_evaled += method(:check)
+      interp = phase_ctxt[:cpp_interpreter]
+      interp.on_asm_section_evaled += T(:check)
     end
 
     private
     def check(asm_section)
-      W(:W0831, asm_section.location)
+      W(asm_section.location)
     end
   end
 
@@ -1253,16 +1284,17 @@ module CBuiltin #:nodoc:
 
     # NOTE: W0832 may be duplicative when the same header which causes this
     #       warning is included twice or more.
-    ensure_uniqueness_of :W0832
+    mark_as_unique
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      context[:c_source].on_inline_assembly += method(:check)
+      phase_ctxt[:cc1_source].on_inline_assembly += M(:check)
     end
 
     private
-    def check(asm_tokens)
-      W(:W0832, asm_tokens.first.location)
+    def check(asm_toks)
+      head_loc = asm_toks.first.location
+      W(head_loc) if head_loc.in_analysis_target?(traits)
     end
   end
 
@@ -1271,17 +1303,18 @@ module CBuiltin #:nodoc:
 
     # NOTE: W1040 may be duplicative when the same header which causes this
     #       warning is included twice or more.
-    ensure_uniqueness_of :W1040
+    mark_as_unique
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      interp = context[:cpp_interpreter]
-      interp.on_extra_tokens_found += method(:check)
+      interp = phase_ctxt[:cpp_interpreter]
+      interp.on_extra_tokens_found += M(:check)
     end
 
     private
-    def check(extra_tokens)
-      W(:W1040, extra_tokens.first.location)
+    def check(extra_toks)
+      head_loc = extra_toks.first.location
+      W(head_loc) if head_loc.in_analysis_target?(traits)
     end
   end
 
@@ -1290,17 +1323,17 @@ module CBuiltin #:nodoc:
 
     # NOTE: W1041 may be duplicative when the same header which causes this
     #       warning is included twice or more.
-    ensure_uniqueness_of :W1041
+    mark_as_unique
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      visitor = context[:cpp_visitor]
-      visitor.enter_unknown_directive += method(:check)
+      visitor = phase_ctxt[:cpp_visitor]
+      visitor.enter_unknown_directive += T(:check)
     end
 
     private
     def check(node)
-      W(:W1041, node.location, node.token.value.chomp.strip)
+      W(node.location, node.token.value.chomp.strip)
     end
   end
 
@@ -1309,13 +1342,17 @@ module CBuiltin #:nodoc:
 
     # NOTE: W1046 may be duplicative when the same header which causes this
     #       warning is included twice or more.
-    ensure_uniqueness_of :W1046
+    mark_as_unique
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      interp = context[:cpp_interpreter]
-      interp.on_illformed_newline_escape_found +=
-        lambda { |location| W(:W1046, location) }
+      interp = phase_ctxt[:cpp_interpreter]
+      interp.on_illformed_newline_escape_found += M(:check)
+    end
+
+    private
+    def check(loc)
+      W(loc) if loc.in_analysis_target?(traits)
     end
   end
 
@@ -1324,12 +1361,20 @@ module CBuiltin #:nodoc:
 
     # NOTE: W9002 may be duplicative when the same header which has no newline
     #       at end of the file is included twice or more.
-    ensure_uniqueness_of :W9002
+    mark_as_unique
 
-    def initialize(context)
+    # NOTE: W9002 may be detected before evaluating the annotation for message
+    #       suppression.
+    mark_as_deferred
+
+    def initialize(phase_ctxt)
       super
-      context[:cpp_interpreter].on_eof_newline_not_found +=
-        lambda { |location| W(:W9002, location) }
+      phase_ctxt[:cpp_interpreter].on_eof_newline_not_found += M(:check)
+    end
+
+    private
+    def check(loc)
+      W(loc) if loc.in_analysis_target?(traits)
     end
   end