adlint 1.12.0 → 1.14.0

data/features/message_detection/W1069.feature

@@ -0,0 +1,120 @@
+Feature: W1069
+
+  W1069 detects that no trailing `else' clause is found in this `if-else-if'
+  statements chain.
+
+  Scenario: no trailing `else' in `if-else-if' statements chain
+    Given a target source named "W1069.c" with:
+      """
+      static int func(int i)
+      {
+          if (i == 2) { /* W1069 */
+              return 0;
+          }
+          else if (i == 4) {
+              return 1;
+          }
+          return 2;
+      }
+      """
+    When I successfully run `adlint W1069.c` on noarch
+    Then the output should exactly match with:
+      | mesg  | line | column |
+      | W0104 | 1    | 21     |
+      | W0629 | 1    | 12     |
+      | W1069 | 3    | 5      |
+      | W0628 | 1    | 12     |
+
+  Scenario: no trailing `else' in `if-else-if-else-if' statements chain
+    Given a target source named "W1069.c" with:
+      """
+      static int func(int i)
+      {
+          if (i == 2) { /* W1069 */
+              return 0;
+          }
+          else if (i == 4) {
+              return 1;
+          }
+          else if (i == 6) {
+              return 2;
+          }
+          return 4;
+      }
+      """
+    When I successfully run `adlint W1069.c` on noarch
+    Then the output should exactly match with:
+      | mesg  | line | column |
+      | W0104 | 1    | 21     |
+      | W0629 | 1    | 12     |
+      | W1069 | 3    | 5      |
+      | W0628 | 1    | 12     |
+
+  Scenario: `else' clause at the last of `if-else-if-else-if' statements chain
+    Given a target source named "W1069.c" with:
+      """
+      static int func(int i)
+      {
+          if (i == 2) { /* OK */
+              return 0;
+          }
+          else if (i == 4) {
+              return 1;
+          }
+          else if (i == 6) {
+              return 2;
+          }
+          else {
+              return 3;
+          }
+      }
+      """
+    When I successfully run `adlint W1069.c` on noarch
+    Then the output should exactly match with:
+      | mesg  | line | column |
+      | W0104 | 1    | 21     |
+      | W0629 | 1    | 12     |
+      | W0628 | 1    | 12     |
+
+  Scenario: standalone `if' statement
+    Given a target source named "W1069.c" with:
+      """
+      static int func(int i)
+      {
+          if (i == 2) { /* OK */
+              return 0;
+          }
+          return 10;
+      }
+      """
+    When I successfully run `adlint W1069.c` on noarch
+    Then the output should exactly match with:
+      | mesg  | line | column |
+      | W0104 | 1    | 21     |
+      | W0629 | 1    | 12     |
+      | W0628 | 1    | 12     |
+
+  Scenario: `else' clause at the last of `if-else-if' statements chain
+    Given a target source named "W1069.c" with:
+      """
+      static int func(int i)
+      {
+          if (i == 2) { /* OK */
+              return 0;
+          }
+          else if (i == 4) {
+              return 1;
+          }
+          else {
+              return 2;
+          }
+      }
+      """
+    When I successfully run `adlint W1069.c` on noarch
+    Then the output should exactly match with:
+      | mesg  | line | column |
+      | W0104 | 1    | 21     |
+      | W0629 | 1    | 12     |
+      | W0628 | 1    | 12     |
+
+# vim:ts=2:sw=2:sts=2:et:

data/features/message_detection/W1070.feature

@@ -0,0 +1,145 @@
+Feature: W1070
+
+  W1070 detects that a `switch' statement can be translated into if-else
+  statement because there are only two execution paths.
+
+  Scenario: `switch' statement which has only two execution paths
+    Given a target source named "W1070.c" with:
+      """
+      static int func(const int i)
+      {
+          switch (i) { /* W1070 */
+          case 0:
+              return 4;
+          default:
+              return 8;
+          }
+      }
+      """
+    When I successfully run `adlint W1070.c` on noarch
+    Then the output should exactly match with:
+      | mesg  | line | column |
+      | W0629 | 1    | 12     |
+      | W1070 | 3    | 5      |
+      | W0628 | 1    | 12     |
+
+  Scenario: `switch' statement which has only two execution paths and doesn't
+            have `default' clause
+    Given a target source named "W1070.c" with:
+      """
+      static int func(const int i)
+      {
+          switch (i) { /* W1070 */
+          case 0:
+              return 4;
+          case 1:
+              return 6;
+          }
+          return 10;
+      }
+      """
+    When I successfully run `adlint W1070.c` on noarch
+    Then the output should exactly match with:
+      | mesg  | line | column |
+      | W0629 | 1    | 12     |
+      | W0003 | 3    | 5      |
+      | W1070 | 3    | 5      |
+      | W0628 | 1    | 12     |
+
+  Scenario: `switch' statement which has only two execution paths and the
+            control never reaches to one of that paths
+    Given a target source named "W1070.c" with:
+      """
+      static int func(const int i)
+      {
+          if (i > 5) {
+              switch (i) { /* W1070, W0781 */
+              case 5:
+                  return 2;
+              default:
+                  return 3;
+              }
+          }
+          return 10;
+      }
+      """
+    When I successfully run `adlint W1070.c` on noarch
+    Then the output should exactly match with:
+      | mesg  | line | column |
+      | W0629 | 1    | 12     |
+      | W9001 | 5    | 9      |
+      | W9001 | 6    | 13     |
+      | W0781 | 4    | 9      |
+      | W1070 | 4    | 9      |
+      | W0628 | 1    | 12     |
+
+  Scenario: `switch' statement which has only one execution path
+    Given a target source named "W1070.c" with:
+      """
+      static int func(const int i)
+      {
+          switch (i) { /* W0781 */
+          default:
+              return 8;
+          }
+      }
+      """
+    When I successfully run `adlint W1070.c` on noarch
+    Then the output should exactly match with:
+      | mesg  | line | column |
+      | W0629 | 1    | 12     |
+      | W0781 | 3    | 5      |
+      | W0628 | 1    | 12     |
+
+  Scenario: `switch' statement which has three execution paths, but the control
+            never reaches to only one of that paths
+    Given a target source named "W1070.c" with:
+      """
+      static int func(const int i)
+      {
+          if (i > 5) {
+              switch (i) { /* W0781 */
+              case 0:
+                  return 1;
+              case 5:
+                  return 2;
+              default:
+                  return 3;
+              }
+          }
+          return 10;
+      }
+      """
+    When I successfully run `adlint W1070.c` on noarch
+    Then the output should exactly match with:
+      | mesg  | line | column |
+      | W0629 | 1    | 12     |
+      | W9001 | 5    | 9      |
+      | W9001 | 6    | 13     |
+      | W9001 | 7    | 9      |
+      | W9001 | 8    | 13     |
+      | W0781 | 4    | 9      |
+      | W0628 | 1    | 12     |
+
+  Scenario: `switch' statement which has three execution paths
+    Given a target source named "W1070.c" with:
+      """
+      static int func(const int i)
+      {
+          switch (i) { /* OK */
+          case 0:
+              return 4;
+          case 1:
+              return 6;
+          default:
+              return 8;
+          }
+      }
+      """
+    When I successfully run `adlint W1070.c` on noarch
+    Then the output should exactly match with:
+      | mesg  | line | column |
+      | W0629 | 1    | 12     |
+      | W0628 | 1    | 12     |
+
+# vim:ts=2:sw=2:sts=2:et:

data/features/message_detection/W1072.feature

@@ -0,0 +1,32 @@
+Feature: W1072
+
+  W1072 detects that a `goto' statement is found.
+
+  Scenario: `goto' statement is found
+    Given a target source named "W1072.c" with:
+      """
+      static int func(int i)
+      {
+          if (i == 1) {
+              goto Label1; /* W1072 */
+          }
+
+          goto Label2; /* W1072 */
+
+      Label1:
+          i = 10;
+      Label2:
+          i = 20;
+
+          return i;
+      }
+      """
+    When I successfully run `adlint W1072.c` on noarch
+    Then the output should exactly match with:
+      | mesg  | line | column |
+      | W0629 | 1    | 12     |
+      | W1072 | 4    | 9      |
+      | W1072 | 7    | 5      |
+      | W0628 | 1    | 12     |
+
+# vim:ts=2:sw=2:sts=2:et:

data/lib/adlint/c/interp.rb

@@ -354,6 +354,9 @@ module C #:nodoc:
     def_plugin_and_notifier :return_stmt_evaled,
                             :return_statement, :result_variable
 
+    # NOTE: Notified when the interpreter evaluates an implicit return.
+    def_plugin_and_notifier :implicit_return_evaled
+
     # NOTE: Notified when the interpreter evaluates a controlling expression of
     #       the if-statement.
     def_plugin_and_notifier :if_ctrlexpr_evaled, :if_statement, :ctrlexpr_value
@@ -816,16 +819,7 @@ module C #:nodoc:
 
       reset_environment
       resolve_unresolved_type(node)
-
-      if function = function_named(node.identifier.value)
-        function.declarations_and_definitions.each do |decl_or_def|
-          decl_or_def.mark_as_referred_by(node.identifier)
-        end
-        function.declarations_and_definitions.push(node)
-      else
-        function = define_explicit_function(node)
-      end
-
+      function = lookup_or_define_function(node)
       notify_function_defined(node, function)
 
       begin
@@ -838,6 +832,7 @@ module C #:nodoc:
 
           BreakEvent.catch do
             node.function_body.block_items.each { |item| interpret(item) }
+            notify_implicit_return_evaled
           end
 
           notify_block_ended(node.function_body)
@@ -847,6 +842,18 @@ module C #:nodoc:
         interpreter._leave_function(node)
       end
     end
+
+    def lookup_or_define_function(function_definition)
+      if function = function_named(function_definition.identifier.value)
+        function.declarations_and_definitions.each do |decl_or_def|
+          decl_or_def.mark_as_referred_by(function_definition.identifier)
+        end
+        function.declarations_and_definitions.push(function_definition)
+      else
+        function = define_explicit_function(function_definition)
+      end
+      function
+    end
   end
 
   class StatementInterpreter < SubInterpreter

data/lib/adlint/c/mediator.rb

@@ -234,6 +234,7 @@ module C #:nodoc:
     def_delegator :interpreter, :notify_c99_for_stmt_ended
     def_delegator :interpreter, :notify_goto_stmt_evaled
     def_delegator :interpreter, :notify_return_stmt_evaled
+    def_delegator :interpreter, :notify_implicit_return_evaled
     def_delegator :interpreter, :notify_if_ctrlexpr_evaled
     def_delegator :interpreter, :notify_if_else_ctrlexpr_evaled
     def_delegator :interpreter, :notify_switch_ctrlexpr_evaled

data/lib/adlint/c/message_shima.rb

@@ -102,6 +102,20 @@ module C #:nodoc:
     end
   end
 
+  class W0645 < PassiveMessageDetection
+    def initialize(context)
+      super
+      visitor = context[:c_visitor]
+      visitor.enter_kandr_function_definition += method(:check)
+    end
+
+    def check(node)
+      if node.type.parameter_types.any? { |type| type.void? }
+        W(:W0645, node.location)
+      end
+    end
+  end
+
   class W0685 < W0573
     def check(function_call_expression, function, arg_variables,
               result_variable)
@@ -142,6 +156,35 @@ module C #:nodoc:
     end
   end
 
+  class W0697 < PassiveMessageDetection
+    def initialize(context)
+      super
+      interp = context[:c_interpreter]
+      interp.on_function_started += method(:start_function)
+      interp.on_function_ended += method(:end_function)
+      interp.on_implicit_return_evaled += method(:check_implicit_return)
+      @current_function = nil
+    end
+
+    private
+    def start_function(function_definition, function)
+      @current_function = function_definition
+    end
+
+    def end_function(function_definition, function)
+      @current_function = nil
+    end
+
+    def check_implicit_return
+      return unless @current_function
+
+      unless @current_function.type.return_type.void?
+        W(:W0697,
+          @current_function.location, @current_function.identifier.value)
+      end
+    end
+  end
+
   class W0698 < PassiveMessageDetection
     def initialize(context)
       super
@@ -187,6 +230,45 @@ module C #:nodoc:
     end
   end
 
+  class W0700 < PassiveMessageDetection
+    def initialize(context)
+      super
+      interp = context[:c_interpreter]
+      interp.on_function_started += method(:start_function)
+      interp.on_function_ended += method(:end_function)
+      interp.on_return_stmt_evaled += method(:check_explicit_return)
+      interp.on_implicit_return_evaled += method(:check_implicit_return)
+      @current_function = nil
+    end
+
+    private
+    def start_function(function_definition, function)
+      @current_function = function_definition
+    end
+
+    def end_function(function_definition, function)
+      @current_function = nil
+    end
+
+    def check_explicit_return(return_stmt, result_variable)
+      return unless @current_function
+
+      if @current_function.implicitly_typed? && return_stmt.expression.nil?
+        W(:W0700,
+          @current_function.location, @current_function.identifier.value)
+      end
+    end
+
+    def check_implicit_return
+      return unless @current_function
+
+      if @current_function.implicitly_typed?
+        W(:W0700,
+          @current_function.location, @current_function.identifier.value)
+      end
+    end
+  end
+
   class W0711 < PassiveMessageDetection
     def initialize(context)
       super
@@ -552,5 +634,145 @@ module C #:nodoc:
     end
   end
 
+  class W1066 < PassiveMessageDetection
+    def initialize(context)
+      super
+      @interp = context[:c_interpreter]
+      @interp.on_explicit_conv_performed += method(:check)
+      @interp.on_function_started += method(:clear_rvalues)
+      @interp.on_additive_expr_evaled += method(:handle_additive)
+      @interp.on_multiplicative_expr_evaled += method(:handle_multiplicative)
+      @rvalues = nil
+    end
+
+    private
+    def check(cast_expression, original_variable, result_variable)
+      return unless @rvalues
+      return unless original_variable.type.floating?
+
+      case expression = @rvalues[original_variable]
+      when AdditiveExpression, MultiplicativeExpression
+        if original_variable.type.same_as?(from_type) &&
+            result_variable.type.same_as?(to_type)
+          W(message_id, expression.location)
+        end
+      end
+    end
+
+    def clear_rvalues(function_definition, function)
+      @rvalues = {}
+    end
+
+    def handle_additive(additive_expression,
+                        lhs_variable, rhs_variable, result_variable)
+      memorize_rvalue_derivation(result_variable, additive_expression)
+    end
+
+    def handle_multiplicative(multiplicative_expression,
+                              lhs_variable, rhs_variable, result_variable)
+      return if multiplicative_expression.operator.type == "%"
+      memorize_rvalue_derivation(result_variable, multiplicative_expression)
+    end
+
+    def memorize_rvalue_derivation(rvalue_holder, expression)
+      @rvalues[rvalue_holder] = expression if @rvalues
+    end
+
+    def from_type
+      @interp.float_type
+    end
+
+    def to_type
+      @interp.double_type
+    end
+
+    def message_id
+      self.class.name.sub(/\A.*::/, "").intern
+    end
+  end
+
+  class W1067 < W1066
+    private
+    def from_type
+      @interp.float_type
+    end
+
+    def to_type
+      @interp.long_double_type
+    end
+  end
+
+  class W1068 < W1066
+    private
+    def from_type
+      @interp.double_type
+    end
+
+    def to_type
+      @interp.long_double_type
+    end
+  end
+
+  class W1069 < PassiveMessageDetection
+    def initialize(context)
+      super
+      visitor = context[:c_visitor]
+      visitor.enter_ansi_function_definition += method(:enter_function)
+      visitor.leave_ansi_function_definition += method(:leave_function)
+      visitor.enter_kandr_function_definition += method(:enter_function)
+      visitor.leave_kandr_function_definition += method(:leave_function)
+      visitor.enter_if_else_statement += method(:enter_if_else_statement)
+      visitor.leave_if_else_statement += method(:leave_if_else_statement)
+      @if_else_statement_chain = []
+    end
+
+    private
+    def enter_function(function_definition)
+      @if_else_statement_chain = []
+    end
+
+    def leave_function(function_definition)
+      @if_else_statement_chain = []
+    end
+
+    def enter_if_else_statement(node)
+      @if_else_statement_chain.push(node)
+      if node.else_statement.kind_of?(IfStatement)
+        W(:W1069, @if_else_statement_chain.first.location)
+      end
+    end
+
+    def leave_if_else_statement(node)
+      @if_else_statement_chain.pop
+    end
+  end
+
+  class W1070 < W0781
+    private
+    def check(node)
+      if exec_path_num = @exec_path_nums.last and exec_path_num == 2
+        W(:W1070, node.location)
+      end
+      @exec_path_nums.pop
+    end
+
+    def add_exec_path(node)
+      @exec_path_nums[-1] += 1
+    end
+  end
+
+  class W1072 < PassiveMessageDetection
+    def initialize(context)
+      super
+      visitor = context[:c_visitor]
+      visitor.enter_goto_statement += method(:warn_goto)
+    end
+
+    private
+    def warn_goto(node)
+       W(:W1072, node.location)
+    end
+  end
+
 end
 end

data/lib/adlint/c/phase.rb

@@ -596,6 +596,7 @@ module C #:nodoc:
         W0639.new(context),
         W0640.new(context),
         W0642.new(context),
+        W0645.new(context),
         W0653.new(context),
         W0654.new(context),
         W0655.new(context),
@@ -630,8 +631,10 @@ module C #:nodoc:
         W0684.new(context),
         W0685.new(context),
         W0686.new(context),
+        W0697.new(context),
         W0698.new(context),
         W0699.new(context),
+        W0700.new(context),
         W0703.new(context),
         W0704.new(context),
         W0705.new(context),
@@ -745,6 +748,12 @@ module C #:nodoc:
         W1063.new(context),
         W1064.new(context),
         W1065.new(context),
+        W1066.new(context),
+        W1067.new(context),
+        W1068.new(context),
+        W1069.new(context),
+        W1070.new(context),
+        W1072.new(context),
         W9001.new(context),
         W9003.new(context)
       ]

data/lib/adlint/c/type.rb

@@ -7562,21 +7562,22 @@ module C #:nodoc:
     end
 
     def qualify_type(type, type_qualifiers, declarator, interpreter = nil)
-      type_qualifiers.each do |token|
+      cvr_qualifiers = type_qualifiers.map { |token|
         case token.type
-        when :CONST
-          type = qualified_type(type, :const)
-        when :VOLATILE
-          type = qualified_type(type, :volatile)
-        when :RESTRICT
-          # TODO: Should support C99 features.
+        when :CONST then :const
+        when :VOLATILE then :volatile
+        else
+          # TODO: Should support C99 `restrict' qualifier.
         end
-      end
-
-      return type unless declarator
+      }.compact
+      type = qualified_type(type, *cvr_qualifiers) unless cvr_qualifiers.empty?
 
-      decl_interp = DeclaratorInterpreter.new(self, interpreter, type)
-      declarator.accept(decl_interp)
+      if declarator
+        decl_interp = DeclaratorInterpreter.new(self, interpreter, type)
+        declarator.accept(decl_interp)
+      else
+        type
+      end
     end
 
     def create_members(struct_declarations)

data/lib/adlint/version.rb

@@ -32,9 +32,9 @@
 module AdLint #:nodoc:
 
   MAJOR_VERSION = 1
-  MINOR_VERSION = 12
+  MINOR_VERSION = 14
   PATCH_VERSION = 0
-  RELEASE_DATE  = "2012-06-20"
+  RELEASE_DATE  = "2012-07-04"
 
   TRAITS_SCHEMA_VERSION = "1.0.0"