Revised predicate-type-checking warning.

A method foo? must be observed to return an instance of a truthy class at least once, and an instance of a falsy class at least once.

lib/laser/analysis/bootstrap/laser_method.rb

@@ -69,8 +69,8 @@ def argument_annotations
 
       # Combines all known return types for this method into one union type.
       def combined_return_type
-        Types::UnionType.new(@type_instantiations.keys.map do |argtypes|
-          return_type_for_types(*argtypes)
+        Types::UnionType.new(@type_instantiations.keys.map do |self_type, *argtypes, blk_type|
+          return_type_for_types(self_type, argtypes, blk_type)
         end)
       end
 

lib/laser/analysis/method_analysis/incorrect_predicate_method_detection.rb

@@ -0,0 +1,19 @@
+module Laser
+  module Analysis
+    module IncorrectPredicateMethodDetection
+      def incorrect_predicate_methods
+        each_user_method.select do |method|
+          method.name.end_with?('?')
+        end.select do |method|
+          !correct_predicate_type?(method.combined_return_type)
+        end
+      end
+
+      def correct_predicate_type?(return_type)
+          (Types.subtype?(Types::FALSECLASS, return_type) ||
+           Types.subtype?(Types::NILCLASS, return_type  )) &&
+          !Types.subtype?(return_type, Types::FALSY)
+      end
+    end
+  end
+end

lib/laser/analysis/method_analysis/method_analysis.rb

@@ -1,9 +1,11 @@
+require_relative 'incorrect_predicate_method_detection'
 require_relative 'unused_methods'
 module Laser
   module Analysis
     # General-purpose method analysis functions.
     module MethodAnalysis
       extend UnusedMethodDetection
+      extend IncorrectPredicateMethodDetection
       def self.each_user_method
         return enum_for(__method__) unless block_given?
         classes = Set[]

spec/analysis_specs/control_flow_specs/improper_override_spec.rb

@@ -172,8 +172,8 @@ def silly?(x, y)
     ClassRegistry["OverI4"].instance_method(:silly?).
         return_type_for_types(
           ClassRegistry["OverI4"].as_type, [Types::STRING, Types::FIXNUM])
-    ClassRegistry["OverI4"].instance_method(:silly?).proc.ast_node.should(
-        have_error(ImproperOverrideTypeError))
+    MethodAnalysis.incorrect_predicate_methods.should include(
+        ClassRegistry["OverI4"].instance_method(:silly?))
   end
 
   it 'should not warn when a method whose name ends in ? does return a bool | nil' do
@@ -187,8 +187,8 @@ def silly?(x, y)
     ClassRegistry["OverI5"].instance_method(:silly?).
         return_type_for_types(
           ClassRegistry["OverI5"].as_type, [Types::FIXNUM, Types::FIXNUM])
-    ClassRegistry["OverI5"].instance_method(:silly?).proc.ast_node.should_not(
-        have_error(ImproperOverrideTypeError))
+    MethodAnalysis.incorrect_predicate_methods.should_not include(
+        ClassRegistry["OverI5"].instance_method(:silly?))
   end
 
   %w(public private protected module_function).each do |method|