adlint 2.6.14 → 3.0.0

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

@@ -1,7 +1,7 @@
 # Code checkings (cpp-phase) of adlint-exam-c_builtin package.
 #
 # Author::    Rie Shima <mailto:rkakuuchi@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::     Rie Shima <mailto:rkakuuchi@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.
 #
@@ -43,18 +43,18 @@ module CBuiltin #:nodoc:
 
     # NOTE: W0687 may be duplicative when the same header which causes this
     #       warning is included twice or more.
-    ensure_uniqueness_of :W0687
+    mark_as_unique
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      interp = context[:cpp_interpreter]
-      interp.on_macro_undefined += method(:check)
+      interp = phase_ctxt[:cpp_interpreter]
+      interp.on_macro_undefined += T(:check)
     end
 
     private
-    def check(undef_line, macro)
+    def check(undef_line, *)
       if undef_line.identifier.value == "defined"
-        W(:W0687, undef_line.identifier.location)
+        W(undef_line.identifier.location)
       end
     end
   end
@@ -64,12 +64,12 @@ module CBuiltin #:nodoc:
 
     # NOTE: W0688 may be duplicative when the same header which causes this
     #       warning is included twice or more.
-    ensure_uniqueness_of :W0688
+    mark_as_unique
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      visitor = context[:cpp_visitor]
-      visitor.enter_line_line += method(:check)
+      visitor = phase_ctxt[:cpp_visitor]
+      visitor.enter_line_line += T(:check)
     end
 
     private
@@ -77,7 +77,7 @@ module CBuiltin #:nodoc:
       if line_no_arg = line_no_argument(line_line)
         line_no = Integer(line_no_arg.value)
         unless line_no > 0 && line_no < 32768
-          W(:W0688, line_no_arg.location)
+          W(line_no_arg.location)
         end
       end
     rescue
@@ -93,13 +93,13 @@ module CBuiltin #:nodoc:
 
     # NOTE: W0689 may be duplicative when the same header which causes this
     #       warning is included twice or more.
-    ensure_uniqueness_of :W0689
+    mark_as_unique
 
     private
     def check(line_line)
       if fname_arg = file_name_argument(line_line)
         unless fname_arg.value =~ /\A".*"\z/
-          W(:W0689, fname_arg.location)
+          W(fname_arg.location)
         end
       end
     end
@@ -114,7 +114,7 @@ module CBuiltin #:nodoc:
 
     # NOTE: W0690 may be duplicative when the same header which causes this
     #       warning is included twice or more.
-    ensure_uniqueness_of :W0690
+    mark_as_unique
 
     private
     def check(line_line)
@@ -122,7 +122,7 @@ module CBuiltin #:nodoc:
         Integer(line_no_arg.value)
       end
     rescue
-      W(:W0690, line_no_arg.location)
+      W(line_no_arg.location)
     end
   end
 
@@ -131,12 +131,12 @@ module CBuiltin #:nodoc:
 
     # NOTE: W0695 may be duplicative when the same header which causes this
     #       warning is included twice or more.
-    ensure_uniqueness_of :W0695
+    mark_as_unique
 
     private
-    def check(undef_line, macro)
+    def check(undef_line, *)
       if undef_line.identifier.value == "assert"
-        W(:W0695, undef_line.identifier.location)
+        W(undef_line.identifier.location)
       end
     end
   end
@@ -146,18 +146,18 @@ module CBuiltin #:nodoc:
 
     # NOTE: W0806 may be duplicative when the same header which causes this
     #       warning is included twice or more.
-    ensure_uniqueness_of :W0806
+    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)
+    def check(define_line, *)
       if define_line.identifier.value == "defined"
-        W(:W0806, define_line.identifier.location)
+        W(define_line.identifier.location)
       end
     end
   end
@@ -167,13 +167,13 @@ module CBuiltin #:nodoc:
 
     # NOTE: W0807 may be duplicative when the same header which causes this
     #       warning is included twice or more.
-    ensure_uniqueness_of :W0807
+    mark_as_unique
 
     private
     def check(undef_line, macro)
       if macro.kind_of?(Cpp::SpecialMacro)
         identifier = undef_line.identifier
-        W(:W0807, identifier.location, identifier.value)
+        W(identifier.location, identifier.value)
       end
     end
   end
@@ -183,22 +183,19 @@ module CBuiltin #:nodoc:
 
     # NOTE: W0808 may be duplicative when the same header which causes this
     #       warning is included twice or more.
-    ensure_uniqueness_of :W0808
+    mark_as_unique
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      interp = context[:cpp_interpreter]
-      interp.on_object_like_macro_defined += method(:check)
-      @macro_table = context[:cpp_macro_table]
+      interp = phase_ctxt[:cpp_interpreter]
+      interp.on_object_like_macro_defined += T(:check)
+      @macro_tbl = phase_ctxt[:cpp_macro_table]
     end
 
     private
-    def check(define_line, macro)
-      identifier = define_line.identifier
-
-      if @macro_table.lookup(identifier.value)
-        W(:W0808, identifier.location, identifier.value)
-      end
+    def check(define_line, *)
+      id = define_line.identifier
+      W(id.location, id.value) if @macro_tbl.lookup(id.value)
     end
   end
 

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

@@ -1,7 +1,7 @@
 # Code structure extractions (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.
 #
@@ -40,15 +40,15 @@ module CBuiltin #:nodoc:
   class ObjectLikeMacroExtraction < CodeExtraction
     def_registrant_phase Cpp::Prepare2Phase
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      interp = context[:cpp_interpreter]
-      interp.on_object_like_macro_defined += method(:extract)
+      interp = phase_ctxt[:cpp_interpreter]
+      interp.on_object_like_macro_defined += T(:extract)
     end
 
     private
-    def do_prepare(context) end
-    def do_execute(context) end
+    def do_prepare(*) end
+    def do_execute(*) end
 
     def extract(define_line, macro)
       MACRODEF(define_line.location, macro.name.value, "O")
@@ -58,16 +58,16 @@ module CBuiltin #:nodoc:
   class FuncLikeMacroExtraction < CodeExtraction
     def_registrant_phase Cpp::Prepare2Phase
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      interp = context[:cpp_interpreter]
-      interp.on_function_like_macro_defined += method(:extract)
-      interp.on_va_function_like_macro_defined += method(:extract)
+      interp = phase_ctxt[:cpp_interpreter]
+      interp.on_function_like_macro_defined    += T(:extract)
+      interp.on_va_function_like_macro_defined += T(:extract)
     end
 
     private
-    def do_prepare(context) end
-    def do_execute(context) end
+    def do_prepare(*) end
+    def do_execute(*) end
 
     def extract(define_line, macro)
       MACRODEF(define_line.location, macro.name.value, "F")
@@ -77,91 +77,90 @@ module CBuiltin #:nodoc:
   class IncludeDirectiveExtraction < CodeExtraction
     def_registrant_phase Cpp::Prepare2Phase
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      interp = context[:cpp_interpreter]
-      interp.on_system_header_included += method(:extract_system_include)
-      interp.on_user_header_included += method(:extract_user_include)
+      interp = phase_ctxt[:cpp_interpreter]
+      interp.on_system_header_included += T(:extract_system_include)
+      interp.on_user_header_included   += T(:extract_user_include)
     end
 
     private
-    def do_prepare(context) end
-    def do_execute(context) end
+    def do_prepare(*) end
+    def do_execute(*) end
 
-    def extract_system_include(system_include_line, system_header)
-      INCLUDE(system_include_line.location, "<#{system_header.fpath}>")
+    def extract_system_include(sys_include_line, sys_header)
+      INCLUDE(sys_include_line.location, "<#{sys_header.fpath}>")
     end
 
-    def extract_user_include(user_include_line, user_header)
-      INCLUDE(user_include_line.location, "\"#{user_header.fpath}\"")
+    def extract_user_include(usr_include_line, usr_header)
+      INCLUDE(usr_include_line.location, "\"#{usr_header.fpath}\"")
     end
   end
 
   class DirectiveExtraction < CodeExtraction
     def_registrant_phase Cpp::Prepare2Phase
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      visitor = context[:cpp_visitor]
-      visitor.enter_if_statement += method(:extract_if)
-      visitor.enter_ifdef_statement += method(:extract_ifdef)
-      visitor.enter_ifndef_statement += method(:extract_ifndef)
-      visitor.enter_elif_statement += method(:extract_elif)
-      visitor.enter_else_statement += method(:extract_else)
-      visitor.enter_endif_line += method(:extract_endif)
-      visitor.enter_user_include_line += method(:extract_user_include)
-      visitor.enter_system_include_line += method(:extract_system_include)
-      visitor.enter_object_like_define_line += method(:extract_define)
-      visitor.enter_function_like_define_line += method(:extract_define)
-      visitor.enter_va_function_like_define_line += method(:extract_define)
-      visitor.enter_undef_line += method(:extract_undef)
-      visitor.enter_line_line += method(:extract_line)
-      visitor.enter_error_line += method(:extract_error)
-      visitor.enter_pragma_line += method(:extract_pragma)
-      visitor.enter_null_directive += method(:extract_null)
+      visitor = phase_ctxt[:cpp_visitor]
+      visitor.enter_if_statement                 += T(:extract_if)
+      visitor.enter_ifdef_statement              += T(:extract_ifdef)
+      visitor.enter_ifndef_statement             += T(:extract_ifndef)
+      visitor.enter_elif_statement               += T(:extract_elif)
+      visitor.enter_else_statement               += T(:extract_else)
+      visitor.enter_endif_line                   += T(:extract_endif)
+      visitor.enter_user_include_line            += T(:extract_user_include)
+      visitor.enter_system_include_line          += T(:extract_system_include)
+      visitor.enter_object_like_define_line      += T(:extract_define)
+      visitor.enter_function_like_define_line    += T(:extract_define)
+      visitor.enter_va_function_like_define_line += T(:extract_define)
+      visitor.enter_undef_line                   += T(:extract_undef)
+      visitor.enter_line_line                    += T(:extract_line)
+      visitor.enter_error_line                   += T(:extract_error)
+      visitor.enter_pragma_line                  += T(:extract_pragma)
+      visitor.enter_null_directive               += T(:extract_null)
     end
 
     private
-    def do_prepare(context) end
-    def do_execute(context) end
+    def do_prepare(*) end
+    def do_execute(*) end
 
-    def extract_if(if_statement)
-      PP_DIRECTIVE(if_statement.location, if_statement.keyword.value,
-                   if_statement.expression.to_s)
+    def extract_if(if_stmt)
+      PP_DIRECTIVE(if_stmt.location, if_stmt.keyword.value,
+                   if_stmt.expression.to_s)
     end
 
-    def extract_ifdef(ifdef_statement)
-      PP_DIRECTIVE(ifdef_statement.location, ifdef_statement.keyword.value,
-                   ifdef_statement.identifier.value)
+    def extract_ifdef(ifdef_stmt)
+      PP_DIRECTIVE(ifdef_stmt.location, ifdef_stmt.keyword.value,
+                   ifdef_stmt.identifier.value)
     end
 
-    def extract_ifndef(ifndef_statement)
-      PP_DIRECTIVE(ifndef_statement.location, ifndef_statement.keyword.value,
-                   ifndef_statement.identifier.value)
+    def extract_ifndef(ifndef_stmt)
+      PP_DIRECTIVE(ifndef_stmt.location, ifndef_stmt.keyword.value,
+                   ifndef_stmt.identifier.value)
     end
 
-    def extract_elif(elif_statement)
-      PP_DIRECTIVE(elif_statement.location, elif_statement.keyword.value,
-                   elif_statement.expression.to_s)
+    def extract_elif(elif_stmt)
+      PP_DIRECTIVE(elif_stmt.location, elif_stmt.keyword.value,
+                   elif_stmt.expression.to_s)
     end
 
-    def extract_else(else_statement)
-      PP_DIRECTIVE(else_statement.location, else_statement.keyword.value, nil)
+    def extract_else(else_stmt)
+      PP_DIRECTIVE(else_stmt.location, else_stmt.keyword.value, nil)
     end
 
     def extract_endif(endif_line)
       PP_DIRECTIVE(endif_line.location, endif_line.keyword.value, nil)
     end
 
-    def extract_user_include(user_include_line)
-      PP_DIRECTIVE(user_include_line.location, user_include_line.keyword.value,
-                   user_include_line.header_name.value)
+    def extract_user_include(usr_include_line)
+      PP_DIRECTIVE(usr_include_line.location, usr_include_line.keyword.value,
+                   usr_include_line.header_name.value)
     end
 
-    def extract_system_include(system_include_line)
-      PP_DIRECTIVE(system_include_line.location,
-                   system_include_line.keyword.value,
-                   system_include_line.header_name.value)
+    def extract_system_include(sys_include_line)
+      PP_DIRECTIVE(sys_include_line.location, sys_include_line.keyword.value,
+                   sys_include_line.header_name.value)
     end
 
     def extract_define(define_line)
@@ -194,7 +193,6 @@ module CBuiltin #:nodoc:
     end
   end
 
-
 end
 end
 end

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

@@ -1,7 +1,7 @@
 # Code checkings (ld-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.
 #
@@ -39,16 +39,16 @@ module CBuiltin #:nodoc:
   class W0555 < PassiveCodeCheck
     def_registrant_phase Ld::PreparePhase
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      context[:ld_function_traversal].on_definition += method(:check)
+      phase_ctxt[:ld_function_traversal].on_definition += T(:check)
     end
 
     private
-    def check(function)
-      call_graph = @context[:ld_function_call_graph]
-      if call_graph.indirect_callers_of(function).include?(function)
-        W(:W0555, function.location)
+    def check(fun)
+      call_graph = @phase_ctxt[:ld_function_call_graph]
+      if call_graph.indirect_callers_of(fun).include?(fun)
+        W(fun.location)
       end
     end
   end
@@ -56,16 +56,16 @@ module CBuiltin #:nodoc:
   class W0586 < PassiveCodeCheck
     def_registrant_phase Ld::PreparePhase
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      context[:ld_typedef_traversal].listeners += method(:check)
+      phase_ctxt[:ld_typedef_traversal].on_declaration += T(:check)
     end
 
     private
     def check(typedef)
-      mapping = @context[:ld_typedef_mapping]
+      mapping = @phase_ctxt[:ld_typedef_mapping]
       if mapping.lookup(typedef.name).any? { |td| td != typedef }
-        W(:W0586, typedef.location, typedef.name)
+        W(typedef.location, typedef.name)
       end
     end
   end
@@ -73,32 +73,30 @@ module CBuiltin #:nodoc:
   class W0589 < PassiveCodeCheck
     def_registrant_phase Ld::PreparePhase
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      context[:ld_function_traversal].on_definition += method(:check_function)
-      context[:ld_variable_traversal].on_definition += method(:check_variable)
+      phase_ctxt[:ld_function_traversal].on_definition += T(:check_function)
+      phase_ctxt[:ld_variable_traversal].on_definition += T(:check_variable)
     end
 
     private
-    def check_function(function)
-      return unless function.extern?
-      call_graph = @context[:ld_function_call_graph]
-      direct_callers = call_graph.direct_callers_of(function)
+    def check_function(fun)
+      return unless fun.extern?
+      call_graph = @phase_ctxt[:ld_function_call_graph]
+      direct_callers = call_graph.direct_callers_of(fun)
       if direct_callers.size == 1 &&
-          direct_callers.first.location.fpath == function.location.fpath
-        W(:W0589, function.location,
-          function.signature, direct_callers.first.signature)
+          direct_callers.first.location.fpath == fun.location.fpath
+        W(fun.location, fun.signature, direct_callers.first.signature)
       end
     end
 
-    def check_variable(variable)
-      return unless variable.extern?
-      reference_graph = @context[:ld_variable_reference_graph]
-      direct_referrers = reference_graph.direct_referrers_of(variable)
+    def check_variable(var)
+      return unless var.extern?
+      ref_graph = @phase_ctxt[:ld_variable_reference_graph]
+      direct_referrers = ref_graph.direct_referrers_of(var)
       if direct_referrers.size == 1 &&
-          direct_referrers.first.location.fpath == variable.location.fpath
-        W(:W0589, variable.location,
-          variable.name, direct_referrers.first.signature)
+          direct_referrers.first.location.fpath == var.location.fpath
+        W(var.location, var.name, direct_referrers.first.signature)
       end
     end
   end
@@ -106,20 +104,19 @@ module CBuiltin #:nodoc:
   class W0591 < PassiveCodeCheck
     def_registrant_phase Ld::PreparePhase
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      context[:ld_function_traversal].on_definition += method(:check)
+      phase_ctxt[:ld_function_traversal].on_definition += T(:check)
     end
 
     private
-    def check(function)
-      return unless function.extern?
-      call_graph = @context[:ld_function_call_graph]
-      direct_callers = call_graph.direct_callers_of(function)
+    def check(fun)
+      return unless fun.extern?
+      call_graph = @phase_ctxt[:ld_function_call_graph]
+      direct_callers = call_graph.direct_callers_of(fun)
       if !direct_callers.empty? &&
-          direct_callers.all? { |f|
-            f.location.fpath == function.location.fpath }
-        W(:W0591, function.location, function.signature)
+          direct_callers.all? { |f| f.location.fpath == fun.location.fpath }
+        W(fun.location, fun.signature)
       end
     end
   end
@@ -127,20 +124,19 @@ module CBuiltin #:nodoc:
   class W0593 < PassiveCodeCheck
     def_registrant_phase Ld::PreparePhase
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      context[:ld_variable_traversal].on_definition += method(:check)
+      phase_ctxt[:ld_variable_traversal].on_definition += T(:check)
     end
 
     private
-    def check(variable)
-      return unless variable.extern?
-      reference_graph = @context[:ld_variable_reference_graph]
-      direct_referrers = reference_graph.direct_referrers_of(variable)
+    def check(var)
+      return unless var.extern?
+      ref_graph = @phase_ctxt[:ld_variable_reference_graph]
+      direct_referrers = ref_graph.direct_referrers_of(var)
       if !direct_referrers.empty? &&
-          direct_referrers.all? { |f|
-            f.location.fpath == variable.location.fpath }
-        W(:W0593, variable.location, variable.name)
+          direct_referrers.all? { |f| f.location.fpath == var.location.fpath }
+        W(var.location, var.name)
       end
     end
   end
@@ -148,17 +144,17 @@ module CBuiltin #:nodoc:
   class W0628 < PassiveCodeCheck
     def_registrant_phase Ld::PreparePhase
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      context[:ld_function_traversal].on_definition += method(:check)
+      phase_ctxt[:ld_function_traversal].on_definition += T(:check)
     end
 
     private
-    def check(function)
-      call_graph = @context[:ld_function_call_graph]
-      unless function.name == "main"
-        if call_graph.direct_callers_of(function).empty?
-          W(:W0628, function.location, function.signature)
+    def check(fun)
+      call_graph = @phase_ctxt[:ld_function_call_graph]
+      unless fun.name == "main"
+        if call_graph.direct_callers_of(fun).empty?
+          W(fun.location, fun.signature)
         end
       end
     end
@@ -169,48 +165,57 @@ module CBuiltin #:nodoc:
 
     # NOTE: W0770 may be duplicative when function declarations of the same
     #       name appears twice or more in the project.
-    ensure_uniqueness_of :W0770
+    mark_as_unique
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      func_traversal = context[:ld_function_traversal]
-      func_traversal.on_declaration += method(:check_function)
-      func_traversal.on_definition += method(:check_function)
-      var_traversal = context[:ld_variable_traversal]
-      var_traversal.on_declaration += method(:check_variable)
-      var_traversal.on_definition += method(:check_variable)
+      fun_traversal = phase_ctxt[:ld_function_traversal]
+      var_traversal = phase_ctxt[:ld_variable_traversal]
+      fun_traversal.on_declaration += T(:check_function_declaration)
+      fun_traversal.on_definition  += T(:check_function_definition)
+      var_traversal.on_declaration  += T(:check_variable)
+      var_traversal.on_definition   += T(:check_variable)
     end
 
     private
-    def check_function(func)
-      return unless func.extern?
+    def check_function_declaration(fun_dcl)
+      if fun_dcl.extern? && fun_dcl.explicit?
+        check_function(fun_dcl)
+      end
+    end
 
-      mapping = @context[:ld_function_mapping]
-      similar_dcls = mapping.lookup_function_declarations(func.name)
+    def check_function_definition(fun_def)
+      if fun_def.extern?
+        check_function(fun_def)
+      end
+    end
+
+    def check_function(fun)
+      mapping = @phase_ctxt[:ld_function_mapping]
+      similar_dcls =
+        mapping.lookup_function_declarations(fun.name).select { |fun_dcl|
+          fun_dcl.explicit?
+        }
 
       if similar_dcls.size > 1
-        W(:W0770, func.location, func.signature)
-        similar_dcls.each do |pair_dcl|
-          unless pair_dcl == func
-            C(:C0001, pair_dcl.location, pair_dcl.signature)
-          end
-        end
+        W(fun.location, fun.signature, *similar_dcls.map { |pair_dcl|
+          next if pair_dcl == fun
+          C(:C0001, pair_dcl.location, pair_dcl.signature)
+        }.compact)
       end
     end
 
     def check_variable(var)
       return unless var.extern?
 
-      mapping = @context[:ld_variable_mapping]
+      mapping = @phase_ctxt[:ld_variable_mapping]
       similar_dcls = mapping.lookup_variable_declarations(var.name)
 
       if similar_dcls.size > 1
-        W(:W0770, var.location, var.name)
-        similar_dcls.each do |pair_dcl|
-          unless pair_dcl == var
-            C(:C0001, pair_dcl.location, pair_dcl.name)
-          end
-        end
+        W(var.location, var.name, *similar_dcls.map { |pair_dcl|
+          next if pair_dcl == var
+          C(:C0001, pair_dcl.location, pair_dcl.name)
+        }.compact)
       end
     end
   end
@@ -220,44 +225,40 @@ module CBuiltin #:nodoc:
 
     # NOTE: W0791 may be duplicative when definitions of the same name appears
     #       twice or more in the project.
-    ensure_uniqueness_of :W0791
+    mark_as_unique
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      context[:ld_function_traversal].on_definition += method(:check_function)
-      context[:ld_variable_traversal].on_definition += method(:check_variable)
+      phase_ctxt[:ld_function_traversal].on_definition += T(:check_function)
+      phase_ctxt[:ld_variable_traversal].on_definition += T(:check_variable)
     end
 
     private
-    def check_function(func)
-      return unless func.extern?
-
-      mapping = @context[:ld_function_mapping]
-      similar_funcs = mapping.lookup_functions(func.name)
-
-      if similar_funcs.size > 1
-        W(:W0791, func.location, func.signature)
-        similar_funcs.each do |pair_func|
-          unless pair_func == func
-            C(:C0001, pair_func.location, pair_func.signature)
-          end
-        end
+    def check_function(fun)
+      return unless fun.extern?
+
+      mapping = @phase_ctxt[:ld_function_mapping]
+      similar_funs = mapping.lookup_functions(fun.name)
+
+      if similar_funs.size > 1
+        W(fun.location, fun.signature, *similar_funs.map { |pair_fun|
+          next if pair_fun == fun
+          C(:C0001, pair_fun.location, pair_fun.signature)
+        }.compact)
       end
     end
 
     def check_variable(var)
       return unless var.extern?
 
-      mapping = @context[:ld_variable_mapping]
+      mapping = @phase_ctxt[:ld_variable_mapping]
       similar_vars = mapping.lookup_variables(var.name)
 
       if similar_vars.size > 1
-        W(:W0791, var.location, var.name)
-        similar_vars.each do |pair_var|
-          unless pair_var == var
-            C(:C0001, pair_var.location, pair_var.name)
-          end
-        end
+        W(var.location, var.name, *similar_vars.map { |pair_var|
+          next if pair_var == var
+          C(:C0001, pair_var.location, pair_var.name)
+        }.compact)
       end
     end
   end
@@ -267,41 +268,48 @@ module CBuiltin #:nodoc:
 
     # NOTE: W1037 may be duplicative when declarations or definitions of the
     #       same name appears twice or more in the project.
-    ensure_uniqueness_of :W1037
+    mark_as_unique
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      func_traversal = context[:ld_function_traversal]
-      func_traversal.on_declaration += method(:check_function)
-      func_traversal.on_definition += method(:check_function)
-      var_traversal = context[:ld_variable_traversal]
-      var_traversal.on_declaration += method(:check_variable)
-      var_traversal.on_definition += method(:check_variable)
+      fun_traversal = phase_ctxt[:ld_function_traversal]
+      var_traversal = phase_ctxt[:ld_variable_traversal]
+      fun_traversal.on_declaration += T(:check_function_declaration)
+      fun_traversal.on_definition  += T(:check_function_definition)
+      var_traversal.on_declaration += T(:check_variable)
+      var_traversal.on_definition  += T(:check_variable)
     end
 
     private
-    def check_function(func)
-      return unless func.extern?
-
-      mapping = @context[:ld_function_mapping]
-      similar_dcls_or_funcs =
-        (mapping.lookup_function_declarations(func.name) +
-         mapping.lookup_functions(func.name)).select { |dcl_or_func|
-           dcl_or_func.extern? && dcl_or_func.signature != func.signature
-         }
+    def check_function_declaration(fun)
+      check_function(fun) if fun.extern? && fun.explicit?
+    end
 
-      unless similar_dcls_or_funcs.empty?
-        W(:W1037, func.location, func.signature)
-        similar_dcls_or_funcs.each do |pair_dcl_or_func|
-          C(:C0001, pair_dcl_or_func.location, pair_dcl_or_func.signature)
-        end
+    def check_function_definition(fun)
+      check_function(fun) if fun.extern?
+    end
+
+    def check_function(fun)
+      mapping = @phase_ctxt[:ld_function_mapping]
+      similar_dcls_or_funs =
+        mapping.lookup_function_declarations(fun.name).select { |dcl|
+          dcl.explicit? && dcl.extern? && dcl.signature != fun.signature
+        } + mapping.lookup_functions(fun.name).select { |mapped_fun|
+          mapped_fun.extern? && mapped_fun.signature != fun.signature
+        }
+
+      unless similar_dcls_or_funs.empty?
+        W(fun.location, fun.signature,
+          *similar_dcls_or_funs.map { |pair_dcl_or_fun|
+            C(:C0001, pair_dcl_or_fun.location, pair_dcl_or_fun.signature)
+          })
       end
     end
 
     def check_variable(var)
       return unless var.extern?
 
-      mapping = @context[:ld_variable_mapping]
+      mapping = @phase_ctxt[:ld_variable_mapping]
       similar_dcls_or_vars =
         (mapping.lookup_variable_declarations(var.name) +
          mapping.lookup_variables(var.name)).select { |dcl_or_var|
@@ -309,10 +317,9 @@ module CBuiltin #:nodoc:
          }
 
       unless similar_dcls_or_vars.empty?
-        W(:W1037, var.location, var.name)
-        similar_dcls_or_vars.each do |pair_dcl_or_var|
+        W(var.location, var.name, *similar_dcls_or_vars.map { |pair_dcl_or_var|
           C(:C0001, pair_dcl_or_var.location, pair_dcl_or_var.name)
-        end
+        })
       end
     end
   end