adlint 2.6.14 → 3.0.0

data/lib/adlint/cpp/subst.rb

@@ -1,7 +1,7 @@
 # Pre-analysis code substitution mechanism.
 #
 # 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.
 #
@@ -37,47 +37,47 @@ module AdLint #:nodoc:
 module Cpp #:nodoc:
 
   class CodeSubstitution
-    def initialize(pattern_str, replacement_str)
-      @pattern = StringToPPTokensLexer.new(pattern_str).execute.to_a
-      @replacement = StringToPPTokensLexer.new(replacement_str).execute.to_a
+    def initialize(ptn_str, repl_str)
+      @pattern     = StringToPPTokensLexer.new(ptn_str).execute.to_a
+      @replacement = StringToPPTokensLexer.new(repl_str).execute.to_a
     end
 
     extend Pluggable
 
     def_plugin :on_substitution
 
-    def execute(tokens)
-      result = []
-      index = 0
-      while first_token = tokens[index]
+    def execute(toks)
+      res_toks = []
+      idx = 0
+      while first_tok = toks[idx]
         matcher = Matcher.new(@pattern)
-        matched_length = matcher.match(tokens, index)
-        if matcher.accepted? || index + matched_length == tokens.size
-          notify_substitution(tokens, index, matched_length)
-          result.concat(@replacement.map { |t|
-            Token.new(t.type, t.value, first_token.location, t.type_hint)
+        matched_len = matcher.match(toks, idx)
+        if matcher.accepted? || idx + matched_len == toks.size
+          notify_substitution(toks, idx, matched_len)
+          res_toks.concat(@replacement.map { |tok|
+            Token.new(tok.type, tok.value, first_tok.location, tok.type_hint)
           })
-          index += matched_length
+          idx += matched_len
         else
-          result.push(first_token)
-          index += 1
+          res_toks.push(first_tok)
+          idx += 1
         end
       end
-      result
+      res_toks
     end
 
     private
-    def notify_substitution(tokens, index, length)
-      matched_tokens = tokens[index, length]
-      on_substitution.invoke(matched_tokens) unless matched_tokens.empty?
+    def notify_substitution(toks, idx, len)
+      matched_toks = toks[idx, len]
+      on_substitution.invoke(matched_toks) unless matched_toks.empty?
     end
   end
 
   class Matcher
-    def initialize(pattern_tokens)
+    def initialize(ptn_toks)
       @state = OuterTokenMatching.new(self)
-      @pattern_tokens = pattern_tokens
-      @pattern_index = 0
+      @pattern_tokens = ptn_toks
+      @pattern_index  = 0
     end
 
     def rest_pattern_tokens
@@ -85,24 +85,24 @@ module Cpp #:nodoc:
     end
 
     def next_pattern_token
-      pattern_token = @pattern_tokens[@pattern_index]
+      ptn_tok = @pattern_tokens[@pattern_index]
       @pattern_index += 1
-      pattern_token
+      ptn_tok
     end
 
-    def match(tokens, index)
-      return 0 if head = tokens[index] and head.type == :NEW_LINE
+    def match(toks, idx)
+      return 0 if head = toks[idx] and head.type == :NEW_LINE
 
-      match_length = 0
-      while token = tokens[index]
-        unless token.type == :NEW_LINE
-          @state = @state.process(token)
+      match_len = 0
+      while tok = toks[idx]
+        unless tok.type == :NEW_LINE
+          @state = @state.process(tok)
           break unless @state.matching?
         end
-        match_length += 1
-        index += 1
+        match_len += 1
+        idx += 1
       end
-      match_length
+      match_len
     end
 
     def accepted?
@@ -124,7 +124,7 @@ module Cpp #:nodoc:
 
       attr_reader :matcher
 
-      def process(token)
+      def process(tok)
         subclass_responsibility
       end
 
@@ -185,22 +185,22 @@ module Cpp #:nodoc:
     private_constant :Matching
 
     class OuterTokenMatching < Matching
-      def process(token)
-        if pattern_token = next_pattern_token
-          if token.value == pattern_token.value
-            case token.value
+      def process(tok)
+        if ptn_tok = next_pattern_token
+          if tok.value == ptn_tok.value
+            case tok.value
             when "(", "[", "{"
               InnerTokenMatching.new(matcher, self)
             else
               self
             end
           else
-            if pattern_token.value == "__adlint__any"
-              if sentry_token = rest_pattern_tokens.first and
-                  token.value == sentry_token.value
-                case token.value
+            if ptn_tok.value == "__adlint__any"
+              if sentry_tok = rest_pattern_tokens.first and
+                  tok.value == sentry_tok.value
+                case tok.value
                 when "(", "[", "{"
-                  InnerTokenMatching.new(matcher, self).process(token)
+                  InnerTokenMatching.new(matcher, self).process(tok)
                 else
                   self
                 end
@@ -219,10 +219,10 @@ module Cpp #:nodoc:
     private_constant :OuterTokenMatching
 
     class OuterAnyMatching < Matching
-      def process(token)
-        if sentry_token = rest_pattern_tokens.first
-          if token.value == sentry_token.value
-            return OuterTokenMatching.new(@matcher).process(token)
+      def process(tok)
+        if sentry_tok = rest_pattern_tokens.first
+          if tok.value == sentry_tok.value
+            return OuterTokenMatching.new(@matcher).process(tok)
           end
         end
         self
@@ -231,25 +231,25 @@ module Cpp #:nodoc:
     private_constant :OuterAnyMatching
 
     class InnerTokenMatching < Matching
-      def initialize(matcher, prev_state)
+      def initialize(matcher, prv_state)
         super(matcher)
-        @prev_state = prev_state
+        @prv_state = prv_state
       end
 
-      def process(token)
-        if pattern_token = next_pattern_token
-          if token.value == pattern_token.value
-            case token.value
+      def process(tok)
+        if ptn_tok = next_pattern_token
+          if tok.value == ptn_tok.value
+            case tok.value
             when "(", "[", "{"
               InnerTokenMatching.new(matcher, self)
             when ")", "]", "}"
-              @prev_state
+              @prv_state
             else
               self
             end
           else
-            if pattern_token.value == "__adlint__any"
-              case token.value
+            if ptn_tok.value == "__adlint__any"
+              case tok.value
               when "(", "[", "{"
                 InnerAnyMatching.new(matcher, self, 1)
               else
@@ -267,24 +267,24 @@ module Cpp #:nodoc:
     private_constant :InnerTokenMatching
 
     class InnerAnyMatching < Matching
-      def initialize(matcher, prev_state, depth)
+      def initialize(matcher, prv_state, depth)
         super(matcher)
-        @prev_state = prev_state
+        @prv_state = prv_state
         @depth = depth
       end
 
-      def process(token)
-        case token.value
+      def process(tok)
+        case tok.value
         when "(", "[", "{"
           @depth += 1
         when ")", "]", "}"
           @depth -= 1
         end
 
-        if sentry_token = rest_pattern_tokens.first
-          if token.value == sentry_token.value
+        if sentry_tok = rest_pattern_tokens.first
+          if tok.value == sentry_tok.value
             if @depth < 0
-              return @prev_state.process(token)
+              return @prv_state.process(tok)
             end
           end
         end

data/lib/adlint/cpp/syntax.rb

@@ -1,7 +1,7 @@
 # AST of C preprocessor language.
 #
 # 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.
 #
@@ -30,6 +30,8 @@
 #++
 
 require "adlint/symbol"
+require "adlint/location"
+require "adlint/exam"
 require "adlint/util"
 
 module AdLint #:nodoc:
@@ -37,6 +39,7 @@ module Cpp #:nodoc:
 
   class SyntaxNode
     include Visitable
+    include LocationHolder
 
     def location
       subclass_responsibility
@@ -52,14 +55,14 @@ module Cpp #:nodoc:
   end
 
   class IdentifierList < SyntaxNode
-    def initialize(identifiers = [])
-      @identifiers = identifiers
+    def initialize(ids = [])
+      @identifiers = ids
     end
 
     attr_reader :identifiers
 
-    def push(identifier)
-      @identifiers.push(identifier)
+    def push(id)
+      @identifiers.push(id)
       self
     end
 
@@ -86,8 +89,8 @@ module Cpp #:nodoc:
       @group.location
     end
 
-    def concat(preprocessing_file)
-      @group.group_parts.concat(preprocessing_file.group.group_parts)
+    def concat(pp_file)
+      @group.group_parts.concat(pp_file.group.group_parts)
     end
 
     def inspect(indent = 0)
@@ -123,10 +126,10 @@ module Cpp #:nodoc:
 
   class IfSection < GroupPart
     def initialize(if_group, elif_groups, else_group, endif_line)
-      @if_group = if_group
+      @if_group    = if_group
       @elif_groups = elif_groups
-      @else_group = else_group
-      @endif_line = endif_line
+      @else_group  = else_group
+      @endif_line  = endif_line
     end
 
     attr_reader :if_group
@@ -161,9 +164,9 @@ module Cpp #:nodoc:
   end
 
   class IfStatement < IfGroup
-    def initialize(keyword, expression, group)
+    def initialize(keyword, expr, group)
       super(keyword)
-      @expression = expression
+      @expression = expr
       @group = group
     end
 
@@ -178,9 +181,9 @@ module Cpp #:nodoc:
   end
 
   class IfdefStatement < IfGroup
-    def initialize(keyword, identifier, group)
+    def initialize(keyword, id, group)
       super(keyword)
-      @identifier = identifier
+      @identifier = id
       @group = group
     end
 
@@ -194,9 +197,9 @@ module Cpp #:nodoc:
   end
 
   class IfndefStatement < IfGroup
-    def initialize(keyword, identifier, group)
+    def initialize(keyword, id, group)
       super(keyword)
-      @identifier = identifier
+      @identifier = id
       @group = group
     end
 
@@ -217,8 +220,8 @@ module Cpp #:nodoc:
 
     attr_reader :elif_statements
 
-    def push(elif_statement)
-      @elif_statements.push(elif_statement)
+    def push(elif_stmt)
+      @elif_statements.push(elif_stmt)
       self
     end
 
@@ -241,9 +244,9 @@ module Cpp #:nodoc:
   end
 
   class ElifStatement < ElifGroup
-    def initialize(keyword, expression, group)
+    def initialize(keyword, expr, group)
       super(keyword)
-      @expression = expression
+      @expression = expr
       @group = group
     end
 
@@ -313,7 +316,7 @@ module Cpp #:nodoc:
   class IncludeLine < ControlLine
     def initialize(keyword, header_name, include_depth)
       super(keyword)
-      @header_name = header_name
+      @header_name   = header_name
       @include_depth = include_depth
     end
 
@@ -323,8 +326,8 @@ module Cpp #:nodoc:
   end
 
   class UserIncludeLine < IncludeLine
-    def initialize(keyword, user_header_name, include_depth)
-      super(keyword, user_header_name, include_depth)
+    def initialize(keyword, usr_header_name, include_depth)
+      super(keyword, usr_header_name, include_depth)
     end
 
     def inspect(indent = 0)
@@ -335,8 +338,8 @@ module Cpp #:nodoc:
   class UserIncludeNextLine < UserIncludeLine; end
 
   class SystemIncludeLine < IncludeLine
-    def initialize(keyword, system_header_name, include_depth)
-      super(keyword, system_header_name, include_depth)
+    def initialize(keyword, sys_header_name, include_depth)
+      super(keyword, sys_header_name, include_depth)
     end
 
     def inspect(indent = 0)
@@ -349,11 +352,11 @@ module Cpp #:nodoc:
   class DefineLine < ControlLine
     include SymbolicElement
 
-    def initialize(keyword, identifier, replacement_list, symbol)
+    def initialize(keyword, id, repl_list, sym)
       super(keyword)
-      @identifier = identifier
-      @replacement_list = replacement_list
-      @symbol = symbol
+      @identifier = id
+      @replacement_list = repl_list
+      @symbol = sym
     end
 
     attr_reader :identifier
@@ -369,17 +372,17 @@ module Cpp #:nodoc:
 
   class PseudoObjectLikeDefineLine < DefineLine
     def initialize(name_str)
-      super(nil, Token.new(:PP_TOKEN, name_str, Location.new), nil, nil)
+      super(Token.new(:DEFINE, "#define", Location.new),
+            Token.new(:PP_TOKEN, name_str, Location.new), nil, nil)
     end
 
-    def mark_as_referred_by(token) end
+    def mark_as_referred_by(tok) end
   end
 
   class FunctionLikeDefineLine < DefineLine
-    def initialize(keyword, identifier, identifier_list, replacement_list,
-                   symbol)
-      super(keyword, identifier, replacement_list, symbol)
-      @identifier_list = identifier_list
+    def initialize(keyword, id, id_list, repl_list, sym)
+      super(keyword, id, repl_list, sym)
+      @identifier_list = id_list
     end
 
     attr_reader :identifier_list
@@ -395,14 +398,14 @@ module Cpp #:nodoc:
 
   class PseudoFunctionLikeDefineLine < FunctionLikeDefineLine
     def initialize(name_str, param_names)
-      identifier_list = IdentifierList.new(
+      id_list = IdentifierList.new(
         param_names.map { |str| Token.new(:PP_TOKEN, str, Location.new) })
 
-      super(nil, Token.new(:PP_TOKEN, name_str, Location.new), identifier_list,
-            nil, nil)
+      super(Token.new(:DEFINE, "#define", Location.new),
+            Token.new(:PP_TOKEN, name_str, Location.new), id_list, nil, nil)
     end
 
-    def mark_as_referred_by(token) end
+    def mark_as_referred_by(tok) end
   end
 
   class VaFunctionLikeDefineLine < FunctionLikeDefineLine
@@ -412,9 +415,9 @@ module Cpp #:nodoc:
   end
 
   class UndefLine < ControlLine
-    def initialize(keyword, identifier)
+    def initialize(keyword, id)
       super(keyword)
-      @identifier = identifier
+      @identifier = id
     end
 
     attr_reader :identifier
@@ -425,9 +428,9 @@ module Cpp #:nodoc:
   end
 
   class LineLine < ControlLine
-    def initialize(keyword, pp_tokens)
+    def initialize(keyword, pp_toks)
       super(keyword)
-      @pp_tokens = pp_tokens
+      @pp_tokens = pp_toks
     end
 
     attr_reader :pp_tokens
@@ -438,9 +441,9 @@ module Cpp #:nodoc:
   end
 
   class ErrorLine < ControlLine
-    def initialize(keyword, pp_tokens)
+    def initialize(keyword, pp_toks)
       super(keyword)
-      @pp_tokens = pp_tokens
+      @pp_tokens = pp_toks
     end
 
     attr_reader :pp_tokens
@@ -452,9 +455,9 @@ module Cpp #:nodoc:
   end
 
   class PragmaLine < ControlLine
-    def initialize(keyword, pp_tokens)
+    def initialize(keyword, pp_toks)
       super(keyword)
-      @pp_tokens = pp_tokens
+      @pp_tokens = pp_toks
     end
 
     attr_reader :pp_tokens
@@ -466,8 +469,8 @@ module Cpp #:nodoc:
   end
 
   class TextLine < GroupPart
-    def initialize(token)
-      @token = token
+    def initialize(tok)
+      @token = tok
     end
 
     attr_reader :token
@@ -482,8 +485,8 @@ module Cpp #:nodoc:
   end
 
   class NullDirective < GroupPart
-    def initialize(token)
-      @token = token
+    def initialize(tok)
+      @token = tok
     end
 
     attr_reader :token
@@ -498,8 +501,8 @@ module Cpp #:nodoc:
   end
 
   class UnknownDirective < GroupPart
-    def initialize(token)
-      @token = token
+    def initialize(tok)
+      @token = tok
     end
 
     attr_reader :token
@@ -573,8 +576,8 @@ module Cpp #:nodoc:
 
     attr_reader :tokens
 
-    def push(token)
-      @tokens.push(token)
+    def push(tok)
+      @tokens.push(tok)
       self
     end
 
@@ -585,8 +588,8 @@ module Cpp #:nodoc:
     def may_represent_expression?
       return false if @tokens.size < 2
 
-      @tokens.all? do |pp_token|
-        case pp_token.value
+      @tokens.all? do |pp_tok|
+        case pp_tok.value
         when "{", "}"
           false
         when ";"
@@ -606,8 +609,8 @@ module Cpp #:nodoc:
       return false if @tokens.size < 2
 
       if @tokens.first.value == "{" && @tokens.last.value == "}"
-        @tokens.all? do |pp_token|
-          case pp_token.value
+        @tokens.all? do |pp_tok|
+          case pp_tok.value
           when "while", "do", "for", "if", "else", "switch", "case", "default",
                "goto", "return", "break", "continue"
             false
@@ -626,7 +629,7 @@ module Cpp #:nodoc:
       return false if @tokens.size < 2
 
       if @tokens.first.value == "{" && @tokens.last.value == "}"
-        @tokens.any? { |pp_token| pp_token.value == ";" }
+        @tokens.any? { |pp_tok| pp_tok.value == ";" }
       else
         false
       end
@@ -641,8 +644,8 @@ module Cpp #:nodoc:
     end
 
     def may_represent_specifier_qualifier_list?
-      @tokens.select { |pp_token|
-        case pp_token.value
+      @tokens.select { |pp_tok|
+        case pp_tok.value
         when "const", "volatile", "restrict"
           true
         when "*"
@@ -657,8 +660,8 @@ module Cpp #:nodoc:
     end
 
     def may_represent_declaration_specifiers_head?
-      @tokens.all? do |pp_token|
-        case pp_token.value
+      @tokens.all? do |pp_tok|
+        case pp_tok.value
         when "typedef", "extern", "static", "auto", "register"
           true
         when "const", "volatile", "restrict"
@@ -695,7 +698,7 @@ module Cpp #:nodoc:
     end
 
     def to_s
-      @tokens.map { |t| t.value }.join(" ")
+      @tokens.map { |tok| tok.value }.join(" ")
     end
 
     def inspect(indent = 0)
@@ -704,8 +707,8 @@ module Cpp #:nodoc:
   end
 
   class Expression < SyntaxNode
-    def initialize(value)
-      @value = value
+    def initialize(val)
+      @value = val
     end
 
     attr_reader :value
@@ -716,9 +719,9 @@ module Cpp #:nodoc:
   end
 
   class ErrorExpression < Expression
-    def initialize(error_token)
+    def initialize(err_tok)
       super(0)
-      @error_token = error_token
+      @error_token = err_tok
     end
 
     attr_reader :error_token
@@ -739,9 +742,9 @@ module Cpp #:nodoc:
   class PrimaryExpression < Expression; end
 
   class ConstantSpecifier < PrimaryExpression
-    def initialize(value, constant)
-      super(value)
-      @constant = constant
+    def initialize(val, const)
+      super(val)
+      @constant = const
     end
 
     attr_reader :constant
@@ -760,9 +763,9 @@ module Cpp #:nodoc:
   end
 
   class GroupedExpression < PrimaryExpression
-    def initialize(value, expression)
-      super(value)
-      @expression = expression
+    def initialize(val, expr)
+      super(val)
+      @expression = expr
     end
 
     attr_reader :expression
@@ -782,9 +785,9 @@ module Cpp #:nodoc:
   end
 
   class UnaryExpression < Expression
-    def initialize(value, operator)
-      super(value)
-      @operator = operator
+    def initialize(val, op)
+      super(val)
+      @operator = op
     end
 
     attr_reader :operator
@@ -795,9 +798,9 @@ module Cpp #:nodoc:
   end
 
   class UnaryArithmeticExpression < UnaryExpression
-    def initialize(value, operator, expression)
-      super(value, operator)
-      @expression = expression
+    def initialize(val, op, expr)
+      super(val, op)
+      @expression = expr
     end
 
     attr_reader :expression
@@ -813,9 +816,9 @@ module Cpp #:nodoc:
   end
 
   class DefinedExpression < UnaryExpression
-    def initialize(value, operator, identifier)
-      super(value, operator)
-      @identifier = identifier
+    def initialize(val, op, id)
+      super(val, op)
+      @identifier = id
     end
 
     attr_reader :identifier
@@ -831,11 +834,11 @@ module Cpp #:nodoc:
   end
 
   class BinaryExpression < Expression
-    def initialize(value, operator, lhs_expression, rhs_expression)
-      super(value)
-      @operator = operator
-      @lhs_expression = lhs_expression
-      @rhs_expression = rhs_expression
+    def initialize(val, op, lhs_expr, rhs_expr)
+      super(val)
+      @operator = op
+      @lhs_expression = lhs_expr
+      @rhs_expression = rhs_expr
     end
 
     attr_reader :operator
@@ -878,11 +881,11 @@ module Cpp #:nodoc:
   class LogicalOrExpression < BinaryExpression; end
 
   class ConditionalExpression < Expression
-    def initialize(value, condition, first_expression, second_expression)
-      super(value)
-      @condition = condition
-      @first_expression = first_expression
-      @second_expression = second_expression
+    def initialize(val, cond, fst_expr, snd_expr)
+      super(val)
+      @condition = cond
+      @first_expression  = fst_expr
+      @second_expression = snd_expr
     end
 
     attr_reader :condition
@@ -906,8 +909,8 @@ module Cpp #:nodoc:
   end
 
   class CommaSeparatedExpression < Expression
-    def initialize(value)
-      super(value)
+    def initialize(val)
+      super(val)
       @expressions = []
     end
 
@@ -1102,7 +1105,7 @@ module Cpp #:nodoc:
     end
 
     def visit_comma_separated_expression(node)
-      node.expressions.each { |expression| expression.accept(self) }
+      node.expressions.each { |expr| expr.accept(self) }
     end
   end
 
@@ -1196,177 +1199,58 @@ module Cpp #:nodoc:
     def_plugin :enter_comma_separated_expression
     def_plugin :leave_comma_separated_expression
 
-    def visit_identifier_list(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_preprocessing_file(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_group(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_if_section(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_if_statement(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_ifdef_statement(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_ifndef_statement(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_elif_groups(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_elif_statement(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_else_statement(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_endif_line(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_user_include_line(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_system_include_line(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_user_include_next_line(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_system_include_next_line(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_object_like_define_line(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_function_like_define_line(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_va_function_like_define_line(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_undef_line(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_line_line(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_error_line(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_pragma_line(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_text_line(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_null_directive(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_unknown_directive(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_pp_tokens(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_error_expression(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_constant_specifier(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_grouped_expression(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_unary_arithmetic_expression(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_defined_expression(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_multiplicative_expression(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_additive_expression(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_shift_expression(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_relational_expression(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_equality_expression(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_and_expression(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_exclusive_or_expression(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_inclusive_or_expression(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_logical_and_expression(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_logical_or_expression(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_conditional_expression(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_comma_separated_expression(node)
-      visit_with_notifying(__method__, node) { super }
-    end
+    def self.def_visitor_method(node_name)
+      class_eval <<-EOS
+        define_method("visit_#{node_name}") do |*args|
+          visit_with_notifying(__method__, args.first) { super(args.first) }
+        end
+      EOS
+    end
+    private_class_method :def_visitor_method
+
+    def_visitor_method :identifier_list
+    def_visitor_method :preprocessing_file
+    def_visitor_method :group
+    def_visitor_method :if_section
+    def_visitor_method :if_statement
+    def_visitor_method :ifdef_statement
+    def_visitor_method :ifndef_statement
+    def_visitor_method :elif_groups
+    def_visitor_method :elif_statement
+    def_visitor_method :else_statement
+    def_visitor_method :endif_line
+    def_visitor_method :user_include_line
+    def_visitor_method :system_include_line
+    def_visitor_method :user_include_next_line
+    def_visitor_method :system_include_next_line
+    def_visitor_method :object_like_define_line
+    def_visitor_method :function_like_define_line
+    def_visitor_method :va_function_like_define_line
+    def_visitor_method :undef_line
+    def_visitor_method :line_line
+    def_visitor_method :error_line
+    def_visitor_method :pragma_line
+    def_visitor_method :text_line
+    def_visitor_method :null_directive
+    def_visitor_method :unknown_directive
+    def_visitor_method :pp_tokens
+    def_visitor_method :error_expression
+    def_visitor_method :constant_specifier
+    def_visitor_method :grouped_expression
+    def_visitor_method :unary_arithmetic_expression
+    def_visitor_method :defined_expression
+    def_visitor_method :multiplicative_expression
+    def_visitor_method :additive_expression
+    def_visitor_method :shift_expression
+    def_visitor_method :relational_expression
+    def_visitor_method :equality_expression
+    def_visitor_method :and_expression
+    def_visitor_method :exclusive_or_expression
+    def_visitor_method :inclusive_or_expression
+    def_visitor_method :logical_and_expression
+    def_visitor_method :logical_or_expression
+    def_visitor_method :conditional_expression
+    def_visitor_method :comma_separated_expression
 
     private
     def visit_with_notifying(caller_method, node, &block)
@@ -1380,9 +1264,7 @@ module Cpp #:nodoc:
   module SyntaxNodeCollector
     def collect_define_lines(node)
       if node
-        DefineLineCollector.new.tap { |collector|
-          node.accept(collector)
-        }.define_lines
+        DefineLineCollector.new.tap { |col| node.accept(col) }.define_lines
       else
         []
       end
@@ -1391,9 +1273,7 @@ module Cpp #:nodoc:
 
     def collect_undef_lines(node)
       if node
-        UndefLineCollector.new.tap { |collector|
-          node.accept(collector)
-        }.undef_lines
+        UndefLineCollector.new.tap { |col| node.accept(col) }.undef_lines
       else
         []
       end