adlint 1.16.0 → 1.18.0

data/lib/adlint/c/interp.rb

@@ -71,6 +71,7 @@ module C #:nodoc:
     include InterpreterMediator
     include Conversion
     include InterpreterOptions
+    include BranchOptions
 
     def initialize(type_table)
       type_table = type_table
@@ -426,7 +427,17 @@ module C #:nodoc:
 
     def execute(node, *options)
       @options_stack.push(current_options + options)
-      node.accept(interpreter_for(node))
+      if quiet_without_side_effect?
+        result = nil
+        branched_eval(nil, FINAL) do
+          result = node.accept(interpreter_for(node))
+          # NOTE: To rollback latest variable value versions.
+          BreakEvent.of_return.throw
+        end
+      else
+        result = node.accept(interpreter_for(node))
+      end
+      result
     ensure
       @options_stack.pop
     end
@@ -456,7 +467,8 @@ module C #:nodoc:
     end
 
     def quiet?
-      current_options.include?(QUIET)
+      current_options.include?(QUIET) ||
+        current_options.include?(QUIET_WITHOUT_SIDE_EFFECT)
     end
 
     def _quiet=(quiet)
@@ -468,6 +480,10 @@ module C #:nodoc:
       end
     end
 
+    def quiet_without_side_effect?
+      current_options.include?(QUIET_WITHOUT_SIDE_EFFECT)
+    end
+
     def _active_function
       # NOTE: This method is called only from
       #       StatementInterpreter#visit_return_statement.
@@ -726,11 +742,36 @@ module C #:nodoc:
     end
 
     def evaluate_initializers(initializers, variable_type)
+      # NOTE: The ISO C99 standard saids;
+      #
+      # 6.7.8 Initialization
+      #
+      # Semantics
+      #
+      # 10 If an object that has automatic storage duration is not initialized
+      #    explicitly, its value is indeterminate.  If an object that has
+      #    static storage duration is not initialized explicitly, then:
+      #    -- if it has pointer type, it is initialized to a null pointer;
+      #    -- if it has arithmetic type, it is initialized to (positive or
+      #       unsigned) zero;
+      #    -- if it is an aggregate, every member is initialized (recursively)
+      #       according to these rules;
+      #    -- if it is a union, the first named member is initialized
+      #       (recursively) according to these rules.
+      if variable_type.union?
+        if first_member = variable_type.members.first
+          first_object = evaluate_initializers(initializers, first_member.type)
+          return temporary_variable(variable_type, value_of(first_object))
+        else
+          return temporary_variable(variable_type)
+        end
+      end
+
       case
       when variable_type.array?
         deduct_array_length_from_initializers(variable_type, initializers)
         member_types = [variable_type.base_type] * variable_type.impl_length
-      when variable_type.composite?
+      when variable_type.struct?
         member_types = variable_type.members.map { |member| member.type }
       else
         member_types = [variable_type]

data/lib/adlint/c/message.rb

@@ -31,9 +31,11 @@
 
 require "adlint/report"
 require "adlint/message"
+require "adlint/token"
 require "adlint/traits"
 require "adlint/monitor"
 require "adlint/c/syntax"
+require "adlint/c/type"
 require "adlint/c/format"
 require "adlint/c/option"
 require "adlint/c/util"
@@ -1832,7 +1834,7 @@ module C #:nodoc:
     end
 
     def write_variable(expression, variable)
-      variable = variable.owner while variable.kind_of?(InnerVariable)
+      variable = variable.owner while variable.inner?
       return unless variable.named?
 
       @variable_stack.reverse_each do |variables|
@@ -6933,6 +6935,7 @@ module C #:nodoc:
       return if variable.scope.global? || variable.binding.memory.static?
 
       if variable.named? && variable.value.must_be_undefined?
+        variable = variable.owner while variable.inner?
         W(:W0459, expression.location, variable.name)
       end
     end
@@ -11539,6 +11542,29 @@ module C #:nodoc:
     end
   end
 
+  class W0641 < PassiveMessageDetection
+    def initialize(context)
+      super
+      interp = context[:c_interpreter]
+      interp.on_explicit_conv_performed += method(:check)
+    end
+
+    private
+    def check(expression, original_variable, result_variable)
+      lhs_type = original_variable.type.unqualify
+      rhs_type = result_variable.type.unqualify
+
+      case
+      when lhs_type.floating? &&
+           rhs_type.pointer? && !rhs_type.base_type.function?
+        W(:W0641, expression.location)
+      when rhs_type.floating? &&
+           lhs_type.pointer? && !lhs_type.base_type.function?
+        W(:W0641, expression.location)
+      end
+    end
+  end
+
   class W0642 < PassiveMessageDetection
     def initialize(context)
       super
@@ -11561,6 +11587,27 @@ module C #:nodoc:
     end
   end
 
+  class W0644 < PassiveMessageDetection
+    # NOTE: W0644 may be duplicative when both hand side of a binary-expression
+    #       refer a value of `void' expression.
+    ensure_uniqueness_of :W0644
+
+    def initialize(context)
+      super
+      interp = context[:c_interpreter]
+
+      interp.on_variable_value_referred += method(:check)
+      interp.on_explicit_conv_performed += lambda { |expr, from, to|
+        check(expr, from)
+      }
+    end
+
+    private
+    def check(expression, variable)
+      W(:W0644, expression.location) if variable.type.void?
+    end
+  end
+
   class W0646 < PassiveMessageDetection
     def initialize(context)
       super
@@ -11577,6 +11624,45 @@ module C #:nodoc:
     end
   end
 
+  class W0649 < PassiveMessageDetection
+    def initialize(context)
+      super
+      interp = context[:c_interpreter]
+      interp.on_shift_expr_evaled += method(:check)
+      @enum_tbl = interp.environment.enumerator_table
+    end
+
+    private
+    def check(expr, lhs_variable, rhs_variable, result_variable)
+      if expr.rhs_operand.constant?(@enum_tbl)
+        if rhs_variable.value.must_be_less_than?(ScalarValue.of(0))
+          W(:W0649, expr.location)
+        end
+      end
+    end
+  end
+
+  class W0650 < PassiveMessageDetection
+    def initialize(context)
+      super
+      interp = context[:c_interpreter]
+      interp.on_shift_expr_evaled += method(:check)
+      @enum_tbl = interp.environment.enumerator_table
+    end
+
+    private
+    def check(expr, lhs_variable, rhs_variable, result_variable)
+      if expr.rhs_operand.constant?(@enum_tbl)
+        promoted_type = lhs_variable.type.integer_promoted_type
+        promoted_bit_size = ScalarValue.of(promoted_type.bit_size)
+        if rhs_variable.value.must_be_equal_to?(promoted_bit_size) ||
+            rhs_variable.value.must_be_greater_than?(promoted_bit_size)
+          W(:W0650, expr.location)
+        end
+      end
+    end
+  end
+
   class W0653 < PassiveMessageDetection
     def initialize(context)
       super
@@ -12314,30 +12400,624 @@ module C #:nodoc:
   end
 
   class W0705 < PassiveMessageDetection
+    include SyntaxNodeCollector
+    include InterpreterOptions
+
     def initialize(context)
       super
-      interp = context[:c_interpreter]
-      interp.on_array_subscript_expr_evaled += method(:check)
+      @interp = context[:c_interpreter]
+      @interp.on_array_subscript_expr_evaled += method(:check_array_subscript)
+      @interp.on_indirection_expr_evaled += method(:check_indirection)
+      @enum_tbl = @interp.environment.enumerator_table
     end
 
     private
-    def check(array_subscript_expression,
-              array_or_pointer_variable, subscript_variable,
-              array_variable, result_variable)
-      return unless array_variable && array_variable.type.length
-      return unless subscript_variable.value.scalar?
+    def check_array_subscript(expression, *, subscript, array, result)
+      return unless array
 
-      lower_bound = ScalarValue.of(0)
-      upper_bound = ScalarValue.of(array_variable.type.length - 1)
+      unless expression.array_subscript.constant?(@enum_tbl)
+        warn_array_oob_access(expression.array_subscript, array, subscript)
+      end
+    end
 
-      lower_test = subscript_variable.value < lower_bound
-      upper_test = subscript_variable.value > upper_bound
+    def check_indirection(expression, *)
+      array, subscript_expr = extract_array_and_subscript(expression.operand)
+      return unless array
 
-      if !lower_test.must_be_true? && lower_test.may_be_true? or
-          !upper_test.must_be_true? && upper_test.may_be_true?
-        W(:W0705, array_subscript_expression.array_subscript.location)
+      unless subscript_expr.constant?(@enum_tbl)
+        subscript = @interp.interpret(subscript_expr,
+                                      QUIET_WITHOUT_SIDE_EFFECT)
+        warn_array_oob_access(expression.operand, array, subscript)
+      end
+    end
+
+    def warn_array_oob_access(expression, array, subscript)
+      if array_length = array.type.length
+        lower_bound = ScalarValue.of(0)
+        upper_bound = ScalarValue.of(array_length - 1)
+
+        lower_test = subscript.value < lower_bound
+        upper_test = subscript.value > upper_bound
+
+        if !lower_test.must_be_true? && lower_test.may_be_true? or
+            !upper_test.must_be_true? && upper_test.may_be_true?
+          W(:W0705, expression.location)
+        end
+      end
+    end
+
+    def extract_array_and_subscript(expression)
+      array, array_name = extract_array(expression)
+      subscript_expr = create_subscript_expr(expression, array_name)
+      return array, subscript_expr
+    end
+
+    def extract_array(expression)
+      collect_object_specifiers(expression).each do |os|
+        if object = @interp.variable_named(os.identifier.value)
+          case
+          when object.type.array?
+            return object, os.identifier.value
+          when object.type.pointer?
+            if object = @interp.pointee_of(object) and object.type.array?
+              return object, os.identifier.value
+            end
+          end
+        end
+      end
+      nil
+    end
+
+    def create_subscript_expr(expression, array_name)
+      expression.accept(ExpressionTransformer.new(array_name))
+    end
+
+    class ExpressionTransformer < SyntaxTreeVisitor
+      def initialize(array_name)
+        @array_name = array_name
+      end
+
+      def visit_error_expression(node)
+        node
+      end
+
+      def visit_object_specifier(node)
+        if node.identifier.value == @array_name
+          ConstantSpecifier.new(Token.new(:CONSTANT, "0", node.location))
+        else
+          node
+        end
+      end
+
+      def visit_constant_specifier(node)
+        node
+      end
+
+      def visit_string_literal_specifier(node)
+        node
+      end
+
+      def visit_null_constant_specifier(node)
+        node
+      end
+
+      def visit_grouped_expression(node)
+        GroupedExpression.new(node.expression.accept(self))
+      end
+
+      def visit_array_subscript_expression(node)
+        ArraySubscriptExpression.new(node.expression.accept(self),
+                                     node.array_subscript.accept(self),
+                                     node.operator)
+      end
+
+      def visit_function_call_expression(node)
+        FunctionCallExpression.new(
+          node.expression.accept(self),
+          node.argument_expressions.map { |expr| expr.accept(self) },
+          node.operator)
+      end
+
+      def visit_member_access_by_value_expression(node)
+        MemberAccessByValueExpression.new(node.expression.accept(self),
+                                          node.identifier, node.operator)
+      end
+
+      def visit_member_access_by_pointer_expression(node)
+        MemberAccessByPointerExpression.new(node.expression.accept(self),
+                                            node.identifier, node.operator)
+      end
+
+      def visit_bit_access_by_value_expression(node)
+        BitAccessByValueExpression.new(node.expression.accept(self),
+                                       node.constant, node.operator)
+      end
+
+      def visit_bit_access_by_pointer_expression(node)
+        BitAccessByPointerExpression.new(node.expression.accept(self),
+                                         node.constant, node.operator)
+      end
+
+      def visit_postfix_increment_expression(node)
+        # NOTE: The postfix-increment-expression is already evaluated with
+        #       side-effect.
+        #       To rollback the side-effect, create an inverted expression.
+        PrefixDecrementExpression.new(
+          Token.new("--", "--", node.operator.location),
+          node.operand.accept(self))
+      end
+
+      def visit_postfix_decrement_expression(node)
+        # NOTE: The postfix-decrement-expression is already evaluated with
+        #       side-effect.
+        #       To rollback the side-effect, create an inverted expression.
+        PrefixIncrementExpression.new(
+          Token.new("++", "++", node.operator.location),
+          node.operand.accept(self))
+      end
+
+      def visit_compound_literal_expression(node)
+        CompoundLiteralExpression.new(
+          node.type_name, node.initializers.map { |ini| ini.accept(self) },
+          node.operator)
+      end
+
+      def visit_prefix_increment_expression(node)
+        # NOTE: The prefix-increment-expression is already evaluated with
+        #       side-effect.
+        #       To rollback the side-effect, create an inverted expression.
+        PostfixDecrementExpression.new(
+          Token.new("--", "--", node.operator.location),
+          node.operand.accept(self))
+      end
+
+      def visit_prefix_decrement_expression(node)
+        # NOTE: The prefix-decrement-expression is already evaluated with
+        #       side-effect.
+        #       To rollback the side-effect, create an inverted expression.
+        PostfixIncrementExpression.new(
+          Token.new("++", "++", node.operator.location),
+          node.operand.accept(self))
+      end
+
+      def visit_address_expression(node)
+        AddressExpression.new(node.operator, node.operand.accept(self))
+      end
+
+      def visit_indirection_expression(node)
+        IndirectionExpression.new(node.operator, node.operand.accept(self))
+      end
+
+      def visit_unary_arithmetic_expression(node)
+        UnaryArithmeticExpression.new(node.operator, node.operand.accept(self))
+      end
+
+      def visit_sizeof_expression(node)
+        SizeofExpression.new(node.operator, node.operand.accept(self))
+      end
+
+      def visit_sizeof_type_expression(node)
+        node
+      end
+
+      def visit_alignof_expression(node)
+        AlignofExpression.new(node.operator, node.operand.accept(self))
+      end
+
+      def visit_alignof_type_expression(node)
+        node
+      end
+
+      def visit_cast_expression(node)
+        CastExpression.new(node.type_name, node.operand.accept(self))
+      end
+
+      def visit_multiplicative_expression(node)
+        MultiplicativeExpression.new(node.operator,
+                                     node.lhs_operand.accept(self),
+                                     node.rhs_operand.accept(self))
+      end
+
+      def visit_additive_expression(node)
+        AdditiveExpression.new(node.operator,
+                               node.lhs_operand.accept(self),
+                               node.rhs_operand.accept(self))
+      end
+
+      def visit_shift_expression(node)
+        ShiftExpression.new(node.operator,
+                            node.lhs_operand.accept(self),
+                            node.rhs_operand.accept(self))
+      end
+
+      def visit_relational_expression(node)
+        RelationalExpression.new(node.operator,
+                                 node.lhs_operand.accept(self),
+                                 node.rhs_operand.accept(self))
+      end
+
+      def visit_equality_expression(node)
+        EqualityExpression.new(node.operator,
+                               node.lhs_operand.accept(self),
+                               node.rhs_operand.accept(self))
+      end
+
+      def visit_and_expression(node)
+        AndExpression.new(node.operator,
+                          node.lhs_operand.accept(self),
+                          node.rhs_operand.accept(self))
+      end
+
+      def visit_exclusive_or_expression(node)
+        ExclusiveOrExpression.new(node.operator,
+                                  node.lhs_operand.accept(self),
+                                  node.rhs_operand.accept(self))
+      end
+
+      def visit_inclusive_or_expression(node)
+        InclusiveOrExpression.new(node.operator,
+                                  node.lhs_operand.accept(self),
+                                  node.rhs_operand.accept(self))
+      end
+
+      def visit_logical_and_expression(node)
+        LogicalAndExpression.new(node.operator,
+                                 node.lhs_operand.accept(self),
+                                 node.rhs_operand.accept(self))
+      end
+
+      def visit_logical_or_expression(node)
+        LogicalOrExpression.new(node.operator,
+                                node.lhs_operand.accept(self),
+                                node.rhs_operand.accept(self))
+      end
+
+      def visit_conditional_expression(node)
+        ConditionalExpression.new(node.condition.accept(self),
+                                  node.then_expression.accept(self),
+                                  node.else_expression.accept(self),
+                                  Token.new("?", "?", node.location))
+      end
+
+      def visit_simple_assignment_expression(node)
+        SimpleAssignmentExpression.new(node.operator,
+                                       node.lhs_operand.accept(self),
+                                       node.rhs_operand.accept(self))
+      end
+
+      def visit_compound_assignment_expression(node)
+        CompoundAssignmentExpression.new(node.operator,
+                                         node.lhs_operand.accept(self),
+                                         node.rhs_operand.accept(self))
+      end
+
+      def visit_comma_separated_expression(node)
+        expressions = node.expressions.map { |expr| expr.accept(self) }
+        result = CommaSeparatedExpression.new(expressions.shift)
+        expressions.each { |expr| result.expressions.push(expr) }
+        result
+      end
+
+      def visit_initializer(node)
+        case
+        when node.expression
+          Initializer.new(node.expression.accept(self), nil)
+        when node.initializers
+          Initializer.new(nil, node.initializers.map { |i| i.accept(self) })
+        end
       end
     end
+    private_constant :ExpressionTransformer
+  end
+
+  class W0707 < PassiveMessageDetection
+    include SyntaxNodeCollector
+    include InterpreterOptions
+
+    def initialize(context)
+      super
+      @interp = context[:c_interpreter]
+      @interp.on_array_subscript_expr_evaled += method(:check_array_subscript)
+      @interp.on_indirection_expr_evaled += method(:check_indirection)
+      @enum_tbl = @interp.environment.enumerator_table
+    end
+
+    private
+    def check_array_subscript(expression, *, subscript, array, result)
+      return unless array
+
+      if expression.array_subscript.constant?(@enum_tbl)
+        warn_array_oob_access(expression.array_subscript, array, subscript)
+      end
+    end
+
+    def check_indirection(expression, *)
+      array, subscript_expr = extract_array_and_subscript(expression.operand)
+      return unless array
+
+      if subscript_expr.constant?(@enum_tbl)
+        # NOTE: A constant-expression has no side-effects.
+        subscript = @interp.interpret(subscript_expr, QUIET)
+        warn_array_oob_access(expression.operand, array, subscript)
+      end
+    end
+
+    def warn_array_oob_access(expression, array, subscript)
+      if array_length = array.type.length
+        lower_bound = ScalarValue.of(0)
+        upper_bound = ScalarValue.of(array_length - 1)
+
+        lower_test = subscript.value < lower_bound
+        upper_test = subscript.value > upper_bound
+
+        if lower_test.must_be_true? || upper_test.must_be_true?
+          W(:W0707, expression.location)
+        end
+      end
+    end
+
+    def extract_array_and_subscript(expression)
+      array, array_name = extract_array(expression)
+      subscript_expr = create_subscript_expr(expression, array_name)
+      return array, subscript_expr
+    end
+
+    def extract_array(expression)
+      collect_object_specifiers(expression).each do |os|
+        if object = @interp.variable_named(os.identifier.value)
+          case
+          when object.type.array?
+            return object, os.identifier.value
+          when object.type.pointer?
+            if object = @interp.pointee_of(object) and object.type.array?
+              return object, os.identifier.value
+            end
+          end
+        end
+      end
+      nil
+    end
+
+    def create_subscript_expr(expression, array_name)
+      expression.accept(ExpressionTransformer.new(array_name))
+    end
+
+    class ExpressionTransformer < SyntaxTreeVisitor
+      def initialize(array_name)
+        @array_name = array_name
+      end
+
+      def visit_error_expression(node)
+        node
+      end
+
+      def visit_object_specifier(node)
+        if node.identifier.value == @array_name
+          ConstantSpecifier.new(Token.new(:CONSTANT, "0", node.location))
+        else
+          node
+        end
+      end
+
+      def visit_constant_specifier(node)
+        node
+      end
+
+      def visit_string_literal_specifier(node)
+        node
+      end
+
+      def visit_null_constant_specifier(node)
+        node
+      end
+
+      def visit_grouped_expression(node)
+        GroupedExpression.new(node.expression.accept(self))
+      end
+
+      def visit_array_subscript_expression(node)
+        ArraySubscriptExpression.new(node.expression.accept(self),
+                                     node.array_subscript.accept(self),
+                                     node.operator)
+      end
+
+      def visit_function_call_expression(node)
+        FunctionCallExpression.new(
+          node.expression.accept(self),
+          node.argument_expressions.map { |expr| expr.accept(self) },
+          node.operator)
+      end
+
+      def visit_member_access_by_value_expression(node)
+        MemberAccessByValueExpression.new(node.expression.accept(self),
+                                          node.identifier, node.operator)
+      end
+
+      def visit_member_access_by_pointer_expression(node)
+        MemberAccessByPointerExpression.new(node.expression.accept(self),
+                                            node.identifier, node.operator)
+      end
+
+      def visit_bit_access_by_value_expression(node)
+        BitAccessByValueExpression.new(node.expression.accept(self),
+                                       node.constant, node.operator)
+      end
+
+      def visit_bit_access_by_pointer_expression(node)
+        BitAccessByPointerExpression.new(node.expression.accept(self),
+                                         node.constant, node.operator)
+      end
+
+      def visit_postfix_increment_expression(node)
+        # NOTE: The postfix-increment-expression is already evaluated with
+        #       side-effect.
+        #       To rollback the side-effect, create an inverted expression.
+        PrefixDecrementExpression.new(
+          Token.new("--", "--", node.operator.location),
+          node.operand.accept(self))
+      end
+
+      def visit_postfix_decrement_expression(node)
+        # NOTE: The postfix-decrement-expression is already evaluated with
+        #       side-effect.
+        #       To rollback the side-effect, create an inverted expression.
+        PrefixIncrementExpression.new(
+          Token.new("++", "++", node.operator.location),
+          node.operand.accept(self))
+      end
+
+      def visit_compound_literal_expression(node)
+        CompoundLiteralExpression.new(
+          node.type_name, node.initializers.map { |ini| ini.accept(self) },
+          node.operator)
+      end
+
+      def visit_prefix_increment_expression(node)
+        # NOTE: The prefix-increment-expression is already evaluated with
+        #       side-effect.
+        #       To rollback the side-effect, create an inverted expression.
+        PostfixDecrementExpression.new(
+          Token.new("--", "--", node.operator.location),
+          node.operand.accept(self))
+      end
+
+      def visit_prefix_decrement_expression(node)
+        # NOTE: The prefix-decrement-expression is already evaluated with
+        #       side-effect.
+        #       To rollback the side-effect, create an inverted expression.
+        PostfixIncrementExpression.new(
+          Token.new("++", "++", node.operator.location),
+          node.operand.accept(self))
+      end
+
+      def visit_address_expression(node)
+        AddressExpression.new(node.operator, node.operand.accept(self))
+      end
+
+      def visit_indirection_expression(node)
+        IndirectionExpression.new(node.operator, node.operand.accept(self))
+      end
+
+      def visit_unary_arithmetic_expression(node)
+        UnaryArithmeticExpression.new(node.operator, node.operand.accept(self))
+      end
+
+      def visit_sizeof_expression(node)
+        SizeofExpression.new(node.operator, node.operand.accept(self))
+      end
+
+      def visit_sizeof_type_expression(node)
+        node
+      end
+
+      def visit_alignof_expression(node)
+        AlignofExpression.new(node.operator, node.operand.accept(self))
+      end
+
+      def visit_alignof_type_expression(node)
+        node
+      end
+
+      def visit_cast_expression(node)
+        CastExpression.new(node.type_name, node.operand.accept(self))
+      end
+
+      def visit_multiplicative_expression(node)
+        MultiplicativeExpression.new(node.operator,
+                                     node.lhs_operand.accept(self),
+                                     node.rhs_operand.accept(self))
+      end
+
+      def visit_additive_expression(node)
+        AdditiveExpression.new(node.operator,
+                               node.lhs_operand.accept(self),
+                               node.rhs_operand.accept(self))
+      end
+
+      def visit_shift_expression(node)
+        ShiftExpression.new(node.operator,
+                            node.lhs_operand.accept(self),
+                            node.rhs_operand.accept(self))
+      end
+
+      def visit_relational_expression(node)
+        RelationalExpression.new(node.operator,
+                                 node.lhs_operand.accept(self),
+                                 node.rhs_operand.accept(self))
+      end
+
+      def visit_equality_expression(node)
+        EqualityExpression.new(node.operator,
+                               node.lhs_operand.accept(self),
+                               node.rhs_operand.accept(self))
+      end
+
+      def visit_and_expression(node)
+        AndExpression.new(node.operator,
+                          node.lhs_operand.accept(self),
+                          node.rhs_operand.accept(self))
+      end
+
+      def visit_exclusive_or_expression(node)
+        ExclusiveOrExpression.new(node.operator,
+                                  node.lhs_operand.accept(self),
+                                  node.rhs_operand.accept(self))
+      end
+
+      def visit_inclusive_or_expression(node)
+        InclusiveOrExpression.new(node.operator,
+                                  node.lhs_operand.accept(self),
+                                  node.rhs_operand.accept(self))
+      end
+
+      def visit_logical_and_expression(node)
+        LogicalAndExpression.new(node.operator,
+                                 node.lhs_operand.accept(self),
+                                 node.rhs_operand.accept(self))
+      end
+
+      def visit_logical_or_expression(node)
+        LogicalOrExpression.new(node.operator,
+                                node.lhs_operand.accept(self),
+                                node.rhs_operand.accept(self))
+      end
+
+      def visit_conditional_expression(node)
+        ConditionalExpression.new(node.condition.accept(self),
+                                  node.then_expression.accept(self),
+                                  node.else_expression.accept(self),
+                                  Token.new("?", "?", node.location))
+      end
+
+      def visit_simple_assignment_expression(node)
+        SimpleAssignmentExpression.new(node.operator,
+                                       node.lhs_operand.accept(self),
+                                       node.rhs_operand.accept(self))
+      end
+
+      def visit_compound_assignment_expression(node)
+        CompoundAssignmentExpression.new(node.operator,
+                                         node.lhs_operand.accept(self),
+                                         node.rhs_operand.accept(self))
+      end
+
+      def visit_comma_separated_expression(node)
+        expressions = node.expressions.map { |expr| expr.accept(self) }
+        result = CommaSeparatedExpression.new(expressions.shift)
+        expressions.each { |expr| result.expressions.push(expr) }
+        result
+      end
+
+      def visit_initializer(node)
+        case
+        when node.expression
+          Initializer.new(node.expression.accept(self), nil)
+        when node.initializers
+          Initializer.new(nil, node.initializers.map { |i| i.accept(self) })
+        end
+      end
+    end
+    private_constant :ExpressionTransformer
   end
 
   class W0708 < PassiveMessageDetection
@@ -12469,6 +13149,31 @@ module C #:nodoc:
     private_constant :Visitor
   end
 
+  class W0719 < PassiveMessageDetection
+    def initialize(context)
+      super
+      interp = context[:c_interpreter]
+      interp.on_shift_expr_evaled += method(:check)
+      @enum_tbl = interp.environment.enumerator_table
+    end
+
+    private
+    def check(expr, lhs_variable, rhs_variable, result_variable)
+      if expr.rhs_operand.constant?(@enum_tbl)
+        underlying_type = lhs_variable.type
+        underlying_bit_size = ScalarValue.of(underlying_type.bit_size)
+        promoted_type = lhs_variable.type.integer_promoted_type
+        promoted_bit_size = ScalarValue.of(promoted_type.bit_size)
+
+        if rhs_variable.value.must_be_equal_to?(underlying_bit_size) ||
+            rhs_variable.value.must_be_greater_than?(underlying_bit_size) and
+            rhs_variable.value.must_be_less_than?(promoted_bit_size)
+          W(:W0719, expr.location)
+        end
+      end
+    end
+  end
+
   class W0720 < PassiveMessageDetection
     def initialize(context)
       super
@@ -13042,29 +13747,314 @@ module C #:nodoc:
   end
 
   class W0745 < PassiveMessageDetection
+    include SyntaxNodeCollector
+    include InterpreterOptions
+
     def initialize(context)
       super
-      interp = context[:c_interpreter]
-      interp.on_array_subscript_expr_evaled += method(:check)
+      @interp = context[:c_interpreter]
+      @interp.on_array_subscript_expr_evaled += method(:check_array_subscript)
+      @interp.on_indirection_expr_evaled += method(:check_indirection)
+      @enum_tbl = @interp.environment.enumerator_table
     end
 
-    private
-    def check(array_subscript_expression,
-              array_or_pointer_variable, subscript_variable,
-              array_variable, result_variable)
-      return unless array_variable && array_variable.type.length
-      return unless subscript_variable.value.scalar?
+    private
+    def check_array_subscript(expression, *, subscript, array, result)
+      return unless array
+
+      unless expression.array_subscript.constant?(@enum_tbl)
+        warn_array_oob_access(expression.array_subscript, array, subscript)
+      end
+    end
+
+    def check_indirection(expression, *)
+      array, subscript_expr = extract_array_and_subscript(expression.operand)
+      return unless array
+
+      unless subscript_expr.constant?(@enum_tbl)
+        subscript = @interp.interpret(subscript_expr,
+                                      QUIET_WITHOUT_SIDE_EFFECT)
+        warn_array_oob_access(expression.operand, array, subscript)
+      end
+    end
+
+    def warn_array_oob_access(expression, array, subscript)
+      if array_length = array.type.length
+        lower_bound = ScalarValue.of(0)
+        upper_bound = ScalarValue.of(array_length - 1)
+
+        lower_test = subscript.value < lower_bound
+        upper_test = subscript.value > upper_bound
+
+        if lower_test.must_be_true? || upper_test.must_be_true?
+          W(:W0745, expression.location)
+        end
+      end
+    end
+
+    def extract_array_and_subscript(expression)
+      array, array_name = extract_array(expression)
+      subscript_expr = create_subscript_expr(expression, array_name)
+      return array, subscript_expr
+    end
+
+    def extract_array(expression)
+      collect_object_specifiers(expression).each do |os|
+        if object = @interp.variable_named(os.identifier.value)
+          case
+          when object.type.array?
+            return object, os.identifier.value
+          when object.type.pointer?
+            if object = @interp.pointee_of(object) and object.type.array?
+              return object, os.identifier.value
+            end
+          end
+        end
+      end
+      nil
+    end
+
+    def create_subscript_expr(expression, array_name)
+      expression.accept(ExpressionTransformer.new(array_name))
+    end
+
+    class ExpressionTransformer < SyntaxTreeVisitor
+      def initialize(array_name)
+        @array_name = array_name
+      end
+
+      def visit_error_expression(node)
+        node
+      end
+
+      def visit_object_specifier(node)
+        if node.identifier.value == @array_name
+          ConstantSpecifier.new(Token.new(:CONSTANT, "0", node.location))
+        else
+          node
+        end
+      end
+
+      def visit_constant_specifier(node)
+        node
+      end
+
+      def visit_string_literal_specifier(node)
+        node
+      end
+
+      def visit_null_constant_specifier(node)
+        node
+      end
+
+      def visit_grouped_expression(node)
+        GroupedExpression.new(node.expression.accept(self))
+      end
+
+      def visit_array_subscript_expression(node)
+        ArraySubscriptExpression.new(node.expression.accept(self),
+                                     node.array_subscript.accept(self),
+                                     node.operator)
+      end
+
+      def visit_function_call_expression(node)
+        FunctionCallExpression.new(
+          node.expression.accept(self),
+          node.argument_expressions.map { |expr| expr.accept(self) },
+          node.operator)
+      end
+
+      def visit_member_access_by_value_expression(node)
+        MemberAccessByValueExpression.new(node.expression.accept(self),
+                                          node.identifier, node.operator)
+      end
+
+      def visit_member_access_by_pointer_expression(node)
+        MemberAccessByPointerExpression.new(node.expression.accept(self),
+                                            node.identifier, node.operator)
+      end
+
+      def visit_bit_access_by_value_expression(node)
+        BitAccessByValueExpression.new(node.expression.accept(self),
+                                       node.constant, node.operator)
+      end
+
+      def visit_bit_access_by_pointer_expression(node)
+        BitAccessByPointerExpression.new(node.expression.accept(self),
+                                         node.constant, node.operator)
+      end
+
+      def visit_postfix_increment_expression(node)
+        # NOTE: The postfix-increment-expression is already evaluated with
+        #       side-effect.
+        #       To rollback the side-effect, create an inverted expression.
+        PrefixDecrementExpression.new(
+          Token.new("--", "--", node.operator.location),
+          node.operand.accept(self))
+      end
+
+      def visit_postfix_decrement_expression(node)
+        # NOTE: The postfix-decrement-expression is already evaluated with
+        #       side-effect.
+        #       To rollback the side-effect, create an inverted expression.
+        PrefixIncrementExpression.new(
+          Token.new("++", "++", node.operator.location),
+          node.operand.accept(self))
+      end
+
+      def visit_compound_literal_expression(node)
+        CompoundLiteralExpression.new(
+          node.type_name, node.initializers.map { |ini| ini.accept(self) },
+          node.operator)
+      end
+
+      def visit_prefix_increment_expression(node)
+        # NOTE: The prefix-increment-expression is already evaluated with
+        #       side-effect.
+        #       To rollback the side-effect, create an inverted expression.
+        PostfixDecrementExpression.new(
+          Token.new("--", "--", node.operator.location),
+          node.operand.accept(self))
+      end
+
+      def visit_prefix_decrement_expression(node)
+        # NOTE: The prefix-decrement-expression is already evaluated with
+        #       side-effect.
+        #       To rollback the side-effect, create an inverted expression.
+        PostfixIncrementExpression.new(
+          Token.new("++", "++", node.operator.location),
+          node.operand.accept(self))
+      end
+
+      def visit_address_expression(node)
+        AddressExpression.new(node.operator, node.operand.accept(self))
+      end
+
+      def visit_indirection_expression(node)
+        IndirectionExpression.new(node.operator, node.operand.accept(self))
+      end
+
+      def visit_unary_arithmetic_expression(node)
+        UnaryArithmeticExpression.new(node.operator, node.operand.accept(self))
+      end
+
+      def visit_sizeof_expression(node)
+        SizeofExpression.new(node.operator, node.operand.accept(self))
+      end
+
+      def visit_sizeof_type_expression(node)
+        node
+      end
+
+      def visit_alignof_expression(node)
+        AlignofExpression.new(node.operator, node.operand.accept(self))
+      end
+
+      def visit_alignof_type_expression(node)
+        node
+      end
+
+      def visit_cast_expression(node)
+        CastExpression.new(node.type_name, node.operand.accept(self))
+      end
+
+      def visit_multiplicative_expression(node)
+        MultiplicativeExpression.new(node.operator,
+                                     node.lhs_operand.accept(self),
+                                     node.rhs_operand.accept(self))
+      end
+
+      def visit_additive_expression(node)
+        AdditiveExpression.new(node.operator,
+                               node.lhs_operand.accept(self),
+                               node.rhs_operand.accept(self))
+      end
+
+      def visit_shift_expression(node)
+        ShiftExpression.new(node.operator,
+                            node.lhs_operand.accept(self),
+                            node.rhs_operand.accept(self))
+      end
+
+      def visit_relational_expression(node)
+        RelationalExpression.new(node.operator,
+                                 node.lhs_operand.accept(self),
+                                 node.rhs_operand.accept(self))
+      end
+
+      def visit_equality_expression(node)
+        EqualityExpression.new(node.operator,
+                               node.lhs_operand.accept(self),
+                               node.rhs_operand.accept(self))
+      end
+
+      def visit_and_expression(node)
+        AndExpression.new(node.operator,
+                          node.lhs_operand.accept(self),
+                          node.rhs_operand.accept(self))
+      end
+
+      def visit_exclusive_or_expression(node)
+        ExclusiveOrExpression.new(node.operator,
+                                  node.lhs_operand.accept(self),
+                                  node.rhs_operand.accept(self))
+      end
+
+      def visit_inclusive_or_expression(node)
+        InclusiveOrExpression.new(node.operator,
+                                  node.lhs_operand.accept(self),
+                                  node.rhs_operand.accept(self))
+      end
+
+      def visit_logical_and_expression(node)
+        LogicalAndExpression.new(node.operator,
+                                 node.lhs_operand.accept(self),
+                                 node.rhs_operand.accept(self))
+      end
+
+      def visit_logical_or_expression(node)
+        LogicalOrExpression.new(node.operator,
+                                node.lhs_operand.accept(self),
+                                node.rhs_operand.accept(self))
+      end
+
+      def visit_conditional_expression(node)
+        ConditionalExpression.new(node.condition.accept(self),
+                                  node.then_expression.accept(self),
+                                  node.else_expression.accept(self),
+                                  Token.new("?", "?", node.location))
+
+      end
+
+      def visit_simple_assignment_expression(node)
+        SimpleAssignmentExpression.new(node.operator,
+                                       node.lhs_operand.accept(self),
+                                       node.rhs_operand.accept(self))
+      end
 
-      lower_bound = ScalarValue.of(0)
-      upper_bound = ScalarValue.of(array_variable.type.length - 1)
+      def visit_compound_assignment_expression(node)
+        CompoundAssignmentExpression.new(node.operator,
+                                         node.lhs_operand.accept(self),
+                                         node.rhs_operand.accept(self))
+      end
 
-      lower_test = subscript_variable.value < lower_bound
-      upper_test = subscript_variable.value > upper_bound
+      def visit_comma_separated_expression(node)
+        expressions = node.expressions.map { |expr| expr.accept(self) }
+        result = CommaSeparatedExpression.new(expressions.shift)
+        expressions.each { |expr| result.expressions.push(expr) }
+        result
+      end
 
-      if lower_test.must_be_true? || upper_test.must_be_true?
-        W(:W0745, array_subscript_expression.array_subscript.location)
+      def visit_initializer(node)
+        case
+        when node.expression
+          Initializer.new(node.expression.accept(self), nil)
+        when node.initializers
+          Initializer.new(nil, node.initializers.map { |i| i.accept(self) })
+        end
       end
     end
+    private_constant :ExpressionTransformer
   end
 
   class W0747 < W0119
@@ -13481,6 +14471,54 @@ module C #:nodoc:
     end
   end
 
+  class W0780 < PassiveMessageDetection
+    def initialize(context)
+      super
+      interp = context[:c_interpreter]
+      interp.on_shift_expr_evaled += method(:check)
+      @enum_tbl = interp.environment.enumerator_table
+    end
+
+    private
+    def check(expression, lhs_variable, rhs_variable, result_variable)
+      operator = expression.operator.type
+      return unless operator == "<<" || operator == "<<="
+
+      if lhs_variable.type.unsigned? && expression.constant?(@enum_tbl)
+        if must_overflow?(lhs_variable, rhs_variable)
+          W(:W0780, expression.location)
+        end
+      end
+    end
+
+    def must_overflow?(lhs_variable, rhs_variable)
+      result = lhs_variable.value << rhs_variable.value
+      result.must_be_greater_than?(ScalarValue.of(lhs_variable.type.max_value))
+    end
+  end
+
+  class W0783 < PassiveMessageDetection
+    def initialize(context)
+      super
+      interp = context[:c_interpreter]
+      interp.on_explicit_conv_performed += method(:check)
+    end
+
+    private
+    def check(expression, original_variable, result_variable)
+      from_type = original_variable.type.unqualify
+      to_type = result_variable.type.unqualify
+
+      return unless from_type.pointer? && to_type.pointer?
+
+      unless from_type.base_type.void? || to_type.base_type.void?
+        if from_type.base_type.incomplete? || to_type.base_type.incomplete?
+          W(:W0783, expression.location)
+        end
+      end
+    end
+  end
+
   class W0785 < PassiveMessageDetection
     def initialize(context)
       super
@@ -14010,6 +15048,73 @@ module C #:nodoc:
     end
   end
 
+  class W0792 < PassiveMessageDetection
+    def initialize(context)
+      super
+      interp = context[:c_interpreter]
+      interp.on_explicit_conv_performed += method(:check)
+    end
+
+    private
+    def check(expression, original_variable, result_variable)
+      lhs_type = original_variable.type.unqualify
+      rhs_type = result_variable.type.unqualify
+
+      case
+      when lhs_type.floating? &&
+           rhs_type.pointer? && rhs_type.base_type.function?
+        W(:W0792, expression.location)
+      when rhs_type.floating? &&
+           lhs_type.pointer? && lhs_type.base_type.function?
+        W(:W0792, expression.location)
+      end
+    end
+  end
+
+  class W0793 < PassiveMessageDetection
+    def initialize(context)
+      super
+      interp = context[:c_interpreter]
+      interp.on_explicit_conv_performed += method(:check)
+    end
+
+    private
+    def check(expression, original_variable, result_variable)
+      lhs_type = original_variable.type.unqualify
+      rhs_type = result_variable.type.unqualify
+
+      if lhs_type.pointer? && rhs_type.pointer?
+        case
+        when lhs_type.base_type.void? || rhs_type.base_type.void?
+          # NOTE: Nothing to be done with conversion between `void *' and any
+          #       pointer and between `void *' and `void *'.
+        when lhs_type.base_type.function? && !rhs_type.base_type.function?,
+             rhs_type.base_type.function? && !lhs_type.base_type.function?
+          W(:W0793, expression.location)
+        end
+      end
+    end
+  end
+
+  class W0794 < PassiveMessageDetection
+    def initialize(context)
+      super
+      interp = context[:c_interpreter]
+      interp.on_shift_expr_evaled += method(:check)
+      @enum_tbl = interp.environment.enumerator_table
+    end
+
+    private
+    def check(expression, lhs_variable, *)
+      case expression.operator.type
+      when "<<", "<<="
+        unless expression.lhs_operand.constant?(@enum_tbl)
+          W(:W0794, expression.location) if lhs_variable.type.signed?
+        end
+      end
+    end
+  end
+
   class W0795 < PassiveMessageDetection
     def initialize(context)
       super
@@ -14312,6 +15417,133 @@ module C #:nodoc:
     end
   end
 
+  class W0830 < PassiveMessageDetection
+    def initialize(context)
+      super
+      visitor = context[:c_visitor]
+      visitor.enter_enum_specifier += method(:check)
+    end
+
+    private
+    def check(enum_specifier)
+      if extra_comma = enum_specifier.trailing_comma
+        W(:W0830, extra_comma.location)
+      end
+    end
+  end
+
+  class W0833 < PassiveMessageDetection
+    def initialize(context)
+      super
+      interp = context[:c_interpreter]
+      interp.on_constant_referred += method(:check)
+    end
+
+    private
+    def check(constant_specifier, *)
+      if constant_specifier.constant.value =~ /LL/i
+        W(:W0833, constant_specifier.location)
+      end
+    end
+  end
+
+  class W0834 < PassiveMessageDetection
+    # NOTE: W0834 may be duplicative on a function-definition because
+    #       function-definition has both parameter-declarations and
+    #       parameter-definitions.
+    ensure_uniqueness_of :W0834
+
+    def initialize(context)
+      super
+      visitor = context[:c_visitor]
+      visitor.enter_member_declaration += method(:check_member_decl)
+      visitor.enter_typedef_declaration += method(:check_declspec_holder)
+      visitor.enter_function_declaration += method(:check_declspec_holder)
+      visitor.enter_parameter_declaration += method(:check_declspec_holder)
+      visitor.enter_variable_declaration += method(:check_declspec_holder)
+      visitor.enter_variable_definition += method(:check_declspec_holder)
+      visitor.enter_ansi_function_definition += method(:check_declspec_holder)
+      visitor.enter_kandr_function_definition += method(:check_declspec_holder)
+      visitor.enter_parameter_definition += method(:check_declspec_holder)
+      visitor.enter_type_name += method(:check_type_name)
+    end
+
+    private
+    def check_member_decl(node)
+      type_specifiers = node.specifier_qualifier_list.type_specifiers
+      if first_ts = type_specifiers.first
+        node.type.accept(Visitor.new(@context, first_ts.location))
+      end
+    end
+
+    def check_type_name(node)
+      type_specifiers = node.specifier_qualifier_list.type_specifiers
+      if first_ts = type_specifiers.first
+        node.type.accept(Visitor.new(@context, first_ts.location))
+      end
+    end
+
+    def check_declspec_holder(declspec_holder)
+      type_specifiers = declspec_holder.type_specifiers
+      if first_ts = type_specifiers.first
+        declspec_holder.type.accept(Visitor.new(@context, first_ts.location))
+      end
+    end
+
+    class Visitor < TypeVisitor
+      include ReportUtil
+
+      def initialize(context, location)
+        @context = context
+        @location = location
+      end
+
+      def visit_long_long_type(type)
+        warn
+      end
+
+      def visit_signed_long_long_type(type)
+        warn
+      end
+
+      def visit_unsigned_long_long_type(type)
+        warn
+      end
+
+      def visit_long_long_int_type(type)
+        warn
+      end
+
+      def visit_signed_long_long_int_type(type)
+        warn
+      end
+
+      def visit_unsigned_long_long_int_type(type)
+        warn
+      end
+
+      def visit_function_type(type)
+        type.return_type.accept(self)
+      end
+
+      def visit_struct_type(type)
+      end
+
+      def visit_union_type(type)
+      end
+
+      private
+      def warn
+        W(:W0834, @location)
+      end
+
+      def report
+        @context.report
+      end
+    end
+    private_constant :Visitor
+  end
+
   class W0947 < PassiveMessageDetection
     def initialize(context)
       super
@@ -14401,6 +15633,24 @@ module C #:nodoc:
     end
   end
 
+  class W1026 < PassiveMessageDetection
+    def initialize(context)
+      super
+      interp = context[:c_interpreter]
+      interp.on_function_call_expr_evaled += method(:check)
+    end
+
+    private
+    def check(expression, function, arg_variables, *)
+      arg_exprs = expression.argument_expressions
+      arg_exprs.zip(arg_variables).each_with_index do |(expr, var), index|
+        if var.type.incomplete?
+          W(:W1026, expr.location, index + 1)
+        end
+      end
+    end
+  end
+
   class W1027 < PassiveMessageDetection
     def initialize(context)
       super
@@ -14584,6 +15834,103 @@ module C #:nodoc:
     end
   end
 
+  class W1039 < PassiveMessageDetection
+    def initialize(context)
+      super
+      interp = context[:c_interpreter]
+      interp.on_function_call_expr_evaled += method(:check)
+      @environ = interp.environment
+    end
+
+    private
+    def check(expression, function, arg_variables, *)
+      if function.named?
+        case function.name
+        when /\A.*printf\z/
+          check_printf_format(expression, arg_variables)
+        when /\A.*scanf\z/
+          check_scanf_format(expression, arg_variables)
+        end
+      end
+    end
+
+    def check_printf_format(expression, arg_variables)
+      if format = create_printf_format(expression, arg_variables)
+        css = format.conversion_specifiers
+        css.each_with_index do |cs, index|
+          if cs.length_modifier == "ll"
+            W(:W1039, format.location, index + 1)
+          end
+        end
+      end
+    end
+
+    def check_scanf_format(expression, arg_variables)
+      if format = create_scanf_format(expression, arg_variables)
+        css = format.conversion_specifiers
+        css.each_with_index do |cs, index|
+          if cs.length_modifier == "ll"
+            W(:W1039, format.location, index + 1)
+          end
+        end
+      end
+    end
+
+    def create_printf_format(expression, arg_variables)
+      if format_index = format_arg_index_of(expression)
+        format_arg = expression.argument_expressions[format_index]
+        if format_arg && format_arg.literal.value =~ /\AL?"(.*)"\z/i
+          location = format_arg.location
+          trailing_args = arg_variables[(format_index + 1)..-1] || []
+          return PrintfFormat.new($1, location, trailing_args, @environ)
+        end
+      end
+      nil
+    end
+
+    def create_scanf_format(expression, arg_variables)
+      if format_index = format_arg_index_of(expression)
+        format_arg = expression.argument_expressions[format_index]
+        if format_arg && format_arg.literal.value =~ /\AL?"(.*)"\z/i
+          location = format_arg.location
+          trailing_args = arg_variables[(format_index + 1)..-1] || []
+          return ScanfFormat.new($1, location, trailing_args, @environ)
+        end
+      end
+      nil
+    end
+
+    def format_arg_index_of(function_call_expression)
+      function_call_expression.argument_expressions.index do |arg_expr|
+        arg_expr.kind_of?(StringLiteralSpecifier)
+      end
+    end
+  end
+
+  class W1047 < PassiveMessageDetection
+    include SyntaxNodeCollector
+
+    def initialize(context)
+      super
+      interp = context[:c_interpreter]
+      interp.on_variable_initialized += method(:check)
+      @enum_tbl = interp.environment.enumerator_table
+    end
+
+    private
+    def check(variable_definition, *)
+      type = variable_definition.type
+      if type.struct? || type.union? || type.array?
+        if initializer = variable_definition.initializer
+          obj_specs = collect_object_specifiers(initializer)
+          if obj_specs.any? { |os| !@enum_tbl.lookup(os.identifier.value) }
+            W(:W1047, variable_definition.location)
+          end
+        end
+      end
+    end
+  end
+
   class W1049 < PassiveMessageDetection
     def initialize(context)
       super
@@ -15025,6 +16372,36 @@ module C #:nodoc:
     end
   end
 
+  class W1071 < PassiveMessageDetection
+    def initialize(context)
+      super
+      interp = context[:c_interpreter]
+      interp.on_function_started += method(:enter_function)
+      interp.on_function_ended += method(:leave_function)
+      interp.on_implicit_return_evaled += method(:memorize_termination)
+      interp.on_return_stmt_evaled += lambda { |*| memorize_termination }
+      @current_function = nil
+    end
+
+    private
+    def enter_function(function_definition, *)
+      @current_function = function_definition
+      @termination_points = 0
+    end
+
+    def leave_function(*)
+      if @current_function && @termination_points > 1
+        W(:W1071,
+          @current_function.location, @current_function.identifier.value)
+      end
+      @current_function = nil
+    end
+
+    def memorize_termination
+      @termination_points += 1 if @current_function
+    end
+  end
+
   class W1073 < PassiveMessageDetection
     def initialize(context)
       super
@@ -15228,6 +16605,11 @@ module C #:nodoc:
       from_type = original_variable.type
       to_type = result_variable.type
 
+      if from_type.undeclared? || from_type.unresolved? ||
+          to_type.undeclared? || to_type.unresolved?
+        return
+      end
+
       unless from_type.standard? && to_type.standard?
         unless from_type.convertible?(to_type)
           W(:W9003, initializer_or_expression.location, from_type.brief_image)