adlint 1.2.0 → 1.4.0

data/lib/adlint/c/interp.rb

@@ -61,6 +61,10 @@ module C #:nodoc:
       ]
 
       @suppress_notification = false
+
+      # NOTE: Active (executing) function may be nested if the nested
+      #       function-definition of the GCC extension is used.
+      @active_function_stack = []
     end
 
     attr_reader :environment
@@ -276,6 +280,13 @@ module C #:nodoc:
                             :assignment_expression, :lhs_variable,
                             :rhs_variable
 
+    # NOTE: Notified when the interpreter starts execution of a
+    #       switch-statement.
+    def_plugin_and_notifier :switch_stmt_started, :switch_statement
+
+    # NOTE: Notified when the interpreter ends execution of a switch-statement.
+    def_plugin_and_notifier :switch_stmt_ended, :switch_statement
+
     # NOTE: Notified when the interpreter starts execution of a
     #       while-statement.
     def_plugin_and_notifier :while_stmt_started, :while_statement
@@ -319,6 +330,16 @@ module C #:nodoc:
     def_plugin_and_notifier :if_else_ctrlexpr_evaled,
                             :if_else_statement, :ctrlexpr_value
 
+    # NOTE: Notified when the interpreter evaluates a controlling expression of
+    #       the switch-statement.
+    def_plugin_and_notifier :switch_ctrlexpr_evaled,
+                            :switch_statement, :ctrlexpr_result
+
+    # NOTE: Notified when the interpreter evaluates a controlling expression of
+    #       the case-labeled-statement.
+    def_plugin_and_notifier :case_ctrlexpr_evaled,
+                            :case_labeled_statement, :ctrlexpr_result
+
     # NOTE: Notified when the interpreter evaluates a controlling expression of
     #       the while-statement.
     def_plugin_and_notifier :while_ctrlexpr_evaled,
@@ -409,6 +430,24 @@ module C #:nodoc:
       @suppress_notification = suppress_notification
     end
 
+    def _active_function
+      # NOTE: This method is called only from
+      #       StatementInterpreter#visit_return_statement.
+      # NOTE: To convert returning object, StatementInterpreter must have
+      #       knowledge about conversion destination type.
+      @active_function_stack.last
+    end
+
+    def _enter_function(function_definition)
+      # NOTE: This method is called only from FunctionInterpreter.
+      @active_function_stack.push(function_definition)
+    end
+
+    def _leave_function(function_definition)
+      # NOTE: This method is called only from FunctionInterpreter.
+      @active_function_stack.pop
+    end
+
     private
     def interpreter_for(node)
       @sub_interpreters.find do |interp|
@@ -519,25 +558,14 @@ module C #:nodoc:
       end
 
       if initializer = node.initializer
-        init_variable = evaluate_initializer(initializer, node.type)
-
-        if node.type.same_as?(init_variable.type)
-          converted = init_variable
-        else
-          converted =
-            do_conversion(init_variable, node.type) ||
-            temporary_variable(node.type)
-          notify_implicit_conv_performed(initializer, init_variable, converted)
-        end
+        init_variable, converted = evaluate_initializer(initializer, node.type)
+        variable = define_variable(node, converted.value.to_defined_value)
 
         notify_variable_value_referred(node, init_variable)
-
-        variable = define_variable(node, converted.value.to_defined_value)
         notify_variable_defined(node, variable)
         notify_variable_initialized(node, variable, init_variable)
       else
-        variable = define_variable(node)
-        notify_variable_defined(node, variable)
+        notify_variable_defined(node, define_variable(node))
       end
 
       evaluate_sequence_point(node.init_declarator.declarator)
@@ -600,29 +628,21 @@ module C #:nodoc:
     private
     def evaluate_initializer(initializer, variable_type)
       init_interp = InitializerInterpreter.new(interpreter)
-      object = init_interp.execute(initializer, variable_type)
+      variable, converted = init_interp.execute(initializer, variable_type)
 
-      case
-      when variable_type.pointer? && object.type.array?
-        init_variable = temporary_variable(variable_type,
-                                           pointer_value_of(object))
-        notify_implicit_conv_performed(initializer, object, init_variable)
-      when variable_type.pointer? && object.type.function?
-        init_variable = temporary_variable(variable_type,
-                                           pointer_value_of(object))
-        notify_implicit_conv_performed(initializer, object, init_variable)
-      when variable_type.array? && object.type.pointer?
-        unless init_variable = pointee_of(object) and init_variable.type.array?
-          init_variable = temporary_variable(variable_type)
+      # NOTE: An implicit conversion has been done by InitializerInterpreter.
+
+      # NOTE: For the case of array variable definition with a
+      #       string-literal-specifier as the initializer.
+      if variable_type.array? && variable.type.pointer?
+        unless array = pointee_of(variable) and array.type.array?
+          array = temporary_variable(variable_type)
         end
-        deduct_array_length_from_array_variable(variable_type, init_variable)
-      when object.function?
-        init_variable = temporary_variable(variable_type)
-      else
-        init_variable = object
+        deduct_array_length_from_array_variable(variable_type, array)
+        variable = converted = array
       end
 
-      init_variable
+      return variable, converted
     end
 
     def deduct_array_length_from_array_variable(variable_type, array_variable)
@@ -638,6 +658,8 @@ module C #:nodoc:
 
   class InitializerInterpreter
     include InterpreterMediator
+    include NotifierMediator
+    include Conversion
     include MonitorUtil
 
     def initialize(interpreter)
@@ -649,19 +671,46 @@ module C #:nodoc:
 
       case
       when expression = initializer.expression
-        evaluate_expression(expression)
+        # NOTE: An implicit conversion is already notified in
+        #       #evaluate_expression.
+        return evaluate_expression(expression, variable_type)
       when initializers = initializer.initializers
-        evaluate_initializers(initializers, variable_type)
+        variable = evaluate_initializers(initializers, variable_type)
+
+        if variable.type.same_as?(variable_type)
+          converted = variable
+        else
+          converted =
+            do_conversion(variable, variable_type) ||
+            temporary_variable(variable_type)
+          notify_implicit_conv_performed(initializer, variable, converted)
+        end
       else
-        temporary_variable(variable_type)
+        variable = converted = temporary_variable(variable_type)
       end
+
+      return variable, converted
     end
 
     private
-    def evaluate_expression(expression)
+    def evaluate_expression(expression, type)
       checkpoint(expression.location)
 
-      object_to_variable(interpret(expression))
+      object = interpret(expression)
+
+      variable = object_to_variable(object)
+      unless variable == object
+        notify_implicit_conv_performed(expression, object, variable)
+      end
+
+      if variable.type.same_as?(type)
+        converted = variable
+      else
+        converted = do_conversion(variable, type) || temporary_variable(type)
+        notify_implicit_conv_performed(expression, variable, converted)
+      end
+
+      return variable, converted
     end
 
     def evaluate_initializers(initializers, variable_type)
@@ -680,7 +729,7 @@ module C #:nodoc:
           checkpoint(initializer.location)
           case
           when expression = initializer.expression
-            value_of(evaluate_expression(expression))
+            value_of(evaluate_expression(expression, type).last)
           when initializers = initializer.initializers
             value_of(evaluate_initializers(initializers, type))
           else
@@ -756,6 +805,8 @@ module C #:nodoc:
     def interpret_function(node)
       checkpoint(node.location)
 
+      interpreter._enter_function(node)
+
       reset_environment
       resolve_unresolved_type(node)
 
@@ -781,6 +832,8 @@ module C #:nodoc:
         notify_block_ended(node.function_body)
         notify_function_ended(node)
       end
+    ensure
+      interpreter._leave_function(node)
     end
   end
 
@@ -807,6 +860,11 @@ module C #:nodoc:
       checkpoint(node.location)
 
       node.executed = true
+      ctrlexpr = node.expression
+      ctrlexpr_result = object_to_variable(interpret(ctrlexpr,
+                                                     :suppress_notification))
+      notify_case_ctrlexpr_evaled(node, ctrlexpr_result)
+
       interpret(node.statement)
     end
 
@@ -1025,7 +1083,7 @@ module C #:nodoc:
               interpret(node.body_statement)
               interpret(node.expression) if node.expression
               # NOTE: To avoid that value of the controlling variable is marked
-              #       as updated at end of the for-statement.  Value of the
+              #       as updated at end of the c99-for-statement.  Value of the
               #       controlling variable is referred by the controlling
               #       expression at the last iteration.
               # FIXME: This re-interpretation of the controlling expression may
@@ -1038,7 +1096,7 @@ module C #:nodoc:
               interpret(node.body_statement)
               interpret(node.expression) if node.expression
               # NOTE: To avoid that value of the controlling variable is marked
-              #       as updated at end of the for-statement.  Value of the
+              #       as updated at end of the c99-for-statement.  Value of the
               #       controlling variable is referred by the controlling
               #       expression at the last iteration.
               # FIXME: This re-interpretation of the controlling expression may
@@ -1084,8 +1142,35 @@ module C #:nodoc:
       checkpoint(node.location)
 
       node.executed = true
-      return_object = node.expression ? interpret(node.expression) : nil
-      notify_return_stmt_evaled(node, return_object)
+
+      unless node.expression
+        notify_return_stmt_evaled(node, nil)
+        BreakEvent.of_return.throw
+      end
+
+      object = interpret(node.expression)
+      variable = object_to_variable(object)
+      unless variable == object
+        notify_implicit_conv_performed(node.expression, object, variable)
+      end
+
+      notify_variable_value_referred(node.expression, variable)
+
+      if active_function = interpreter._active_function and
+          return_type = active_function.type.return_type
+        if variable.type.same_as?(return_type)
+          converted = variable
+        else
+          converted =
+            do_conversion(variable, return_type) ||
+            temporary_variable(return_type)
+          notify_implicit_conv_performed(node.expression, variable, converted)
+        end
+      else
+        converted = variable
+      end
+
+      notify_return_stmt_evaled(node, variable)
       BreakEvent.of_return.throw
     end
 
@@ -1225,8 +1310,15 @@ module C #:nodoc:
       checkpoint(node.location)
 
       node.executed = true
-      object = interpret(node.expression)
-      execute_switch_body(object, node.statement) if object.variable?
+      notify_switch_stmt_started(node)
+
+      ctrlexpr = node.expression
+      ctrlexpr_result = object_to_variable(interpret(ctrlexpr))
+      notify_switch_ctrlexpr_evaled(node, ctrlexpr_result)
+
+      execute_switch_body(ctrlexpr_result, node.statement)
+
+      notify_switch_stmt_ended(node)
     end
 
     private

data/lib/adlint/c/mediator.rb

@@ -217,6 +217,8 @@ module C #:nodoc:
     def_delegator :interpreter, :notify_prefix_decrement_expr_evaled
     def_delegator :interpreter, :notify_postfix_decrement_expr_evaled
     def_delegator :interpreter, :notify_assignment_expr_evaled
+    def_delegator :interpreter, :notify_switch_stmt_started
+    def_delegator :interpreter, :notify_switch_stmt_ended
     def_delegator :interpreter, :notify_while_stmt_started
     def_delegator :interpreter, :notify_while_stmt_ended
     def_delegator :interpreter, :notify_do_stmt_started
@@ -229,6 +231,8 @@ module C #:nodoc:
     def_delegator :interpreter, :notify_return_stmt_evaled
     def_delegator :interpreter, :notify_if_ctrlexpr_evaled
     def_delegator :interpreter, :notify_if_else_ctrlexpr_evaled
+    def_delegator :interpreter, :notify_switch_ctrlexpr_evaled
+    def_delegator :interpreter, :notify_case_ctrlexpr_evaled
     def_delegator :interpreter, :notify_while_ctrlexpr_evaled
     def_delegator :interpreter, :notify_do_ctrlexpr_evaled
     def_delegator :interpreter, :notify_for_ctrlexpr_evaled

data/lib/adlint/c/message.rb

@@ -6957,13 +6957,7 @@ module C #:nodoc:
 
     private
     def check_function(node)
-      if declaration_specifiers = node.declaration_specifiers
-        if declaration_specifiers.type_specifiers.empty?
-          W(:W0457, node.location)
-        end
-      else
-        W(:W0457, node.location)
-      end
+      W(:W0457, node.location) if node.implicitly_typed?
     end
   end
 
@@ -6978,13 +6972,7 @@ module C #:nodoc:
 
     private
     def check_variable(node)
-      if declaration_specifiers = node.declaration_specifiers
-        if declaration_specifiers.type_specifiers.empty?
-          W(:W0458, node.location)
-        end
-      else
-        W(:W0458, node.location)
-      end
+      W(:W0458, node.location) if node.implicitly_typed?
     end
   end
 
@@ -12279,6 +12267,260 @@ module C #:nodoc:
     private_constant :Visitor
   end
 
+  class W0720 < 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)
+      orig_type = original_variable.type
+      conv_type = result_variable.type
+
+      unless orig_type.scalar? && orig_type.floating? &&
+          conv_type.scalar? && conv_type.integer?
+        return
+      end
+
+      orig_value = original_variable.value
+      return unless orig_value.scalar?
+
+      lower_test = orig_value < ScalarValue.of(conv_type.min_value - 1)
+      upper_test = orig_value > ScalarValue.of(conv_type.max_value + 1)
+
+      if lower_test.must_be_true? || upper_test.must_be_true?
+        W(:W0720, expression.location)
+      end
+    end
+  end
+
+  class W0721 < 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)
+      orig_type = original_variable.type
+      conv_type = result_variable.type
+
+      unless orig_type.pointer? && conv_type.scalar? && conv_type.integer?
+        return
+      end
+
+      if orig_type.min_value < conv_type.min_value ||
+          orig_type.max_value > conv_type.max_value
+        W(:W0721, expression.location)
+      end
+    end
+  end
+
+  class W0722 < PassiveMessageDetection
+    def initialize(context)
+      super
+      interp = context[:c_interpreter]
+      interp.on_multiplicative_expr_evaled += method(:check)
+      interp.on_additive_expr_evaled += method(:check)
+    end
+
+    private
+    def check(binary_expression, lhs_variable, rhs_variable, result_variable)
+      return unless lhs_variable.type.scalar? && lhs_variable.type.signed?
+      return unless rhs_variable.type.scalar? && rhs_variable.type.signed?
+
+      return unless lhs_variable.value.scalar? && rhs_variable.value.scalar?
+
+      case binary_expression.operator.type
+      when "+"
+        unbound_value = lhs_variable.value + rhs_variable.value
+      when "-"
+        unbound_value = lhs_variable.value - rhs_variable.value
+      when "*"
+        unbound_value = lhs_variable.value * rhs_variable.value
+      else
+        return
+      end
+
+      result_type = result_variable.type
+      lower_test = unbound_value < ScalarValue.of(result_type.min_value)
+      upper_test = unbound_value > ScalarValue.of(result_type.max_value)
+
+      if lower_test.must_be_true? || upper_test.must_be_true?
+        W(:W0722, binary_expression.location)
+      end
+    end
+  end
+
+  class W0723 < PassiveMessageDetection
+    def initialize(context)
+      super
+      interp = context[:c_interpreter]
+      interp.on_multiplicative_expr_evaled += method(:check)
+      interp.on_additive_expr_evaled += method(:check)
+    end
+
+    private
+    def check(binary_expression, lhs_variable, rhs_variable, result_variable)
+      return unless lhs_variable.type.scalar? && lhs_variable.type.signed?
+      return unless rhs_variable.type.scalar? && rhs_variable.type.signed?
+
+      return unless lhs_variable.value.scalar? && rhs_variable.value.scalar?
+
+      case binary_expression.operator.type
+      when "+"
+        unbound_value = lhs_variable.value + rhs_variable.value
+      when "-"
+        unbound_value = lhs_variable.value + rhs_variable.value
+      when "*"
+        unbound_value = lhs_variable.value * rhs_variable.value
+      else
+        return
+      end
+
+      result_type = result_variable.type
+      lower_test = unbound_value < ScalarValue.of(result_type.min_value)
+      upper_test = unbound_value > ScalarValue.of(result_type.max_value)
+
+      if !lower_test.must_be_true? && lower_test.may_be_true? or
+          !upper_test.must_be_true? && upper_test.may_be_true?
+        W(:W0723, binary_expression.location)
+      end
+    end
+  end
+
+  class W0727 < PassiveMessageDetection
+    def initialize(context)
+      super
+      interp = context[:c_interpreter]
+      interp.on_explicit_conv_performed += method(:check)
+      interp.on_implicit_conv_performed += method(:check)
+    end
+
+    private
+    def check(initializer_or_expression, original_variable, result_variable)
+      return unless result_variable.type.enum?
+
+      value = original_variable.value.unique_sample
+
+      unless result_variable.type.enumerators.any? { |enum| value == enum.value }
+        W(:W0727, initializer_or_expression.location)
+      end
+    end
+  end
+
+  class W0728 < 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, result_variable)
+      args = arg_variables.zip(function.type.parameter_types)
+      args.each_with_index do |(arg_variable, param_type), index|
+        next unless param_type && param_type.enum?
+
+        if arg_variable.type.enum?
+          unless arg_variable.type.same_as?(param_type)
+            W(:W0728, expression.argument_expressions[index].location)
+          end
+        end
+      end
+    end
+  end
+
+  class W0729 < PassiveMessageDetection
+    def initialize(context)
+      super
+      interp = context[:c_interpreter]
+      interp.on_assignment_expr_evaled += method(:check)
+    end
+
+    private
+    def check(expression, lhs_variable, rhs_variable)
+      return unless lhs_variable.type.enum?
+
+      if rhs_variable.type.enum?
+        unless lhs_variable.type.same_as?(rhs_variable.type)
+          W(:W0729, expression.location)
+        end
+      end
+    end
+  end
+
+  class W0730 < 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)
+      @current_function = nil
+    end
+
+    private
+    def start_function(function_definition)
+      @current_function = function_definition
+    end
+
+    def end_function(function_definition)
+      @current_function = nil
+    end
+
+    def check(return_statement, result_variable)
+      return unless @current_function && result_variable
+
+      return unless return_type = @current_function.type.return_type
+      return unless return_type.enum?
+
+      if result_variable.type.enum?
+        unless return_type.same_as?(result_variable.type)
+          W(:W0730, return_statement.expression.location)
+        end
+      end
+    end
+  end
+
+  class W0731 < PassiveMessageDetection
+    def initialize(context)
+      super
+      interp = context[:c_interpreter]
+      interp.on_switch_stmt_ended += method(:end_switch_statement)
+      interp.on_switch_ctrlexpr_evaled += method(:memorize_switch_ctrlexpr)
+      interp.on_case_ctrlexpr_evaled += method(:check)
+      @switch_ctrlexpr_stack = []
+    end
+
+    private
+    def end_switch_statement(node)
+      @switch_ctrlexpr_stack.pop
+    end
+
+    def memorize_switch_ctrlexpr(node, ctrlexpr_result)
+      @switch_ctrlexpr_stack.push(ctrlexpr_result)
+    end
+
+    def check(case_labeled_statement, ctrlexpr_result)
+      unless switch_ctrlexpr_result = @switch_ctrlexpr_stack.last
+        return
+      end
+
+      return unless switch_ctrlexpr_result.type.enum?
+      expected_type = switch_ctrlexpr_result.type
+
+      value = ctrlexpr_result.value.unique_sample
+      unless expected_type.enumerators.any? { |enum| value == enum.value }
+        W(:W0731, case_labeled_statement.expression.location,
+          case_labeled_statement.expression.to_s)
+      end
+    end
+  end
+
   class W0736 < PassiveMessageDetection
     def initialize(context)
       super
@@ -12328,6 +12570,146 @@ module C #:nodoc:
     end
   end
 
+  class W0737 < PassiveMessageDetection
+    def initialize(context)
+      super
+      interp = context[:c_interpreter]
+      interp.on_variable_declared += method(:check)
+      interp.on_variable_defined += method(:check)
+    end
+
+    private
+    def check(decl_or_def, variable)
+      return unless decl_or_def.type.enum?
+
+      if decl_or_def.type.incomplete?
+        W(:W0737, decl_or_def.location, decl_or_def.type.name)
+      end
+    end
+  end
+
+  class W0738 < PassiveMessageDetection
+    def initialize(context)
+      super
+      interp = context[:c_interpreter]
+      interp.on_implicit_conv_performed += method(:check)
+    end
+
+    private
+    def check(initializer_or_expression, original_variable, result_variable)
+      case initializer_or_expression
+      when Initializer
+        unless expression = initializer_or_expression.expression
+          return
+        end
+      when Expression
+        expression = initializer_or_expression
+      end
+
+      return unless expression.constant?
+
+      orig_type = original_variable.type
+      conv_type = result_variable.type
+
+      unless orig_type.scalar? && orig_type.integer? &&
+          conv_type.scalar? && conv_type.integer? && conv_type.unsigned?
+        return
+      end
+
+      orig_value = original_variable.value
+      return unless orig_value.scalar?
+
+      upper_test = orig_value > ScalarValue.of(conv_type.max_value)
+
+      W(:W0738, expression.location) if upper_test.must_be_true?
+    end
+  end
+
+  class W0739 < PassiveMessageDetection
+    def initialize(context)
+      super
+      interp = context[:c_interpreter]
+      interp.on_additive_expr_evaled += method(:check)
+    end
+
+    private
+    def check(additive_expression, lhs_variable, rhs_variable, result_variable)
+      return unless additive_expression.operator.type == "-"
+
+      return unless additive_expression.lhs_operand.constant?
+      return unless additive_expression.rhs_operand.constant?
+
+      return unless lhs_variable.type.scalar? && lhs_variable.type.unsigned?
+      return unless rhs_variable.type.scalar? && rhs_variable.type.unsigned?
+
+      return unless lhs_variable.value.scalar? && rhs_variable.value.scalar?
+
+      unbound_value = lhs_variable.value - rhs_variable.value
+
+      result_type = result_variable.type
+      lower_test = unbound_value < ScalarValue.of(result_type.min_value)
+
+      W(:W0739, additive_expression.location) if lower_test.must_be_true?
+    end
+  end
+
+  class W0740 < PassiveMessageDetection
+    def initialize(context)
+      super
+      interp = context[:c_interpreter]
+      interp.on_additive_expr_evaled += method(:check)
+    end
+
+    private
+    def check(additive_expression, lhs_variable, rhs_variable, result_variable)
+      return unless additive_expression.operator.type == "+"
+
+      return unless additive_expression.lhs_operand.constant?
+      return unless additive_expression.rhs_operand.constant?
+
+      return unless lhs_variable.type.scalar? && lhs_variable.type.unsigned?
+      return unless rhs_variable.type.scalar? && rhs_variable.type.unsigned?
+
+      return unless lhs_variable.value.scalar? && rhs_variable.value.scalar?
+
+      unbound_value = lhs_variable.value + rhs_variable.value
+
+      result_type = result_variable.type
+      upper_test = unbound_value > ScalarValue.of(result_type.max_value)
+
+      W(:W0740, additive_expression.location) if upper_test.must_be_true?
+    end
+  end
+
+  class W0741 < PassiveMessageDetection
+    def initialize(context)
+      super
+      interp = context[:c_interpreter]
+      interp.on_multiplicative_expr_evaled += method(:check)
+    end
+
+    private
+    def check(multiplicative_expression, lhs_variable, rhs_variable,
+              result_variable)
+      return unless multiplicative_expression.operator.type == "*"
+
+      return unless multiplicative_expression.lhs_operand.constant?
+      return unless multiplicative_expression.rhs_operand.constant?
+
+      return unless lhs_variable.type.scalar? && lhs_variable.type.unsigned?
+      return unless rhs_variable.type.scalar? && rhs_variable.type.unsigned?
+
+      return unless lhs_variable.value.scalar? && rhs_variable.value.scalar?
+
+      unbound_value = lhs_variable.value * rhs_variable.value
+
+      result_type = result_variable.type
+      upper_test = unbound_value > ScalarValue.of(result_type.max_value)
+
+      W(:W0741, multiplicative_expression.location) if upper_test.must_be_true?
+    end
+  end
+
   class W0742 < PassiveMessageDetection
     def initialize(context)
       super
@@ -12355,6 +12737,46 @@ module C #:nodoc:
     end
   end
 
+  class W0743 < PassiveMessageDetection
+    def initialize(context)
+      super
+      interp = context[:c_interpreter]
+      interp.on_implicit_conv_performed += method(:check)
+    end
+
+    private
+    def check(initializer_or_expression, original_variable, result_variable)
+      case initializer_or_expression
+      when Initializer
+        unless expression = initializer_or_expression.expression
+          return
+        end
+      when Expression
+        expression = initializer_or_expression
+      end
+
+      return unless expression.constant?
+
+      orig_type = original_variable.type
+      conv_type = result_variable.type
+
+      unless orig_type.scalar? && orig_type.integer? &&
+          conv_type.scalar? && conv_type.integer? && conv_type.signed?
+        return
+      end
+
+      orig_value = original_variable.value
+      return unless orig_value.scalar?
+
+      lower_test = orig_value < ScalarValue.of(conv_type.min_value)
+      upper_test = orig_value > ScalarValue.of(conv_type.max_value)
+
+      if lower_test.must_be_true? || upper_test.must_be_true?
+        W(:W0743, expression.location)
+      end
+    end
+  end
+
   class W0744 < PassiveMessageDetection
     def initialize(context)
       super
@@ -13593,7 +14015,11 @@ module C #:nodoc:
     def check(expression, original_variable, result_variable)
       orig_type = original_variable.type
       conv_type = result_variable.type
-      return unless orig_type.scalar? && conv_type.scalar? && conv_type.signed?
+
+      unless orig_type.scalar? && orig_type.integer? &&
+          conv_type.scalar? && conv_type.integer? && conv_type.signed?
+        return
+      end
 
       orig_value = original_variable.value
       return unless orig_value.scalar?
@@ -13619,7 +14045,11 @@ module C #:nodoc:
     def check(expression, original_variable, result_variable)
       orig_type = original_variable.type
       conv_type = result_variable.type
-      return unless orig_type.scalar? && conv_type.scalar? && conv_type.signed?
+
+      unless orig_type.scalar? && orig_type.integer? &&
+          conv_type.scalar? && conv_type.integer? && conv_type.signed?
+        return
+      end
 
       orig_value = original_variable.value
       return unless orig_value.scalar?
@@ -13706,6 +14136,39 @@ module C #:nodoc:
     end
   end
 
+  class W1064 < W0731
+    private
+    def check(case_labeled_statement, ctrlexpr_result)
+      unless switch_ctrlexpr_result = @switch_ctrlexpr_stack.last
+        return
+      end
+
+      return unless switch_ctrlexpr_result.type.enum?
+
+      unless ctrlexpr_result.type.enum?
+        W(:W1064, case_labeled_statement.expression.location)
+      end
+    end
+  end
+
+  class W1065 < W0731
+    private
+    def check(case_labeled_statement, ctrlexpr_result)
+      unless switch_ctrlexpr_result = @switch_ctrlexpr_stack.last
+        return
+      end
+
+      return unless switch_ctrlexpr_result.type.enum?
+      expected_type = switch_ctrlexpr_result.type
+
+      if ctrlexpr_result.type.enum?
+        unless ctrlexpr_result.type.same_as?(expected_type)
+          W(:W1065, case_labeled_statement.expression.location)
+        end
+      end
+    end
+  end
+
   class W9001 < PassiveMessageDetection
     def initialize(context)
       super