steep 1.10.0 → 2.1.0.dev.1

data/lib/steep/signature/validator.rb

@@ -49,7 +49,7 @@ module Steep
       end
 
       def type_name_resolver
-        @type_name_resolver ||= RBS::Resolver::TypeNameResolver.new(env)
+        @type_name_resolver ||= RBS::Resolver::TypeNameResolver.build(env)
       end
 
       def validator
@@ -321,12 +321,12 @@ module Steep
             args: entry.type_params.map { AST::Types::Any.instance() }
           )
 
-          entry.decls.each do |decl|
-            ast = decl.decl
-
-            unless AnnotationsHelper.deprecated_annotation?(ast.annotations)
-              if location = ast.location
-                validate_type_name_deprecation(name, location[:name])
+          entry.each_decl do |decl|
+            if decl.is_a?(RBS::AST::Declarations::Base)
+              unless AnnotationsHelper.deprecated_annotation?(decl.annotations)
+                if location = decl.location
+                  validate_type_name_deprecation(name, location[:name])
+                end
               end
             end
           end
@@ -391,7 +391,7 @@ module Steep
                       location =
                         case ancestor.source
                         when :super
-                          if (primary_decl = entry.primary.decl).is_a?(RBS::AST::Declarations::Class)
+                          if (primary_decl = entry.primary_decl).is_a?(RBS::AST::Declarations::Class)
                             primary_decl.super_class&.location
                           end
                         when nil
@@ -455,7 +455,13 @@ module Steep
                 definition.class_variables.each do |name, var|
                   if var.declared_in == definition.type_name
                     if (parent = var.parent_variable) && var.declared_in != parent.declared_in
-                      class_var = entry.decls.flat_map {|decl| decl.decl.members }.find do |member|
+                      members = entry.each_decl.flat_map do |decl|
+                        case decl
+                        when RBS::AST::Declarations::Class, RBS::AST::Declarations::Module
+                          decl.members
+                        end
+                      end
+                      class_var = members.find do |member|
                         member.is_a?(RBS::AST::Members::ClassVariable) && member.name == name
                       end
 
@@ -534,8 +540,10 @@ module Steep
           location =
             case ancestor.source
             when :super
-              primary_decl = env.class_decls.fetch(name).primary.decl
-              primary_decl.is_a?(RBS::AST::Declarations::Class) or raise
+              primary_decl = env.class_decls.fetch(name).primary_decl
+              unless primary_decl.is_a?(RBS::AST::Declarations::Class) || primary_decl.is_a?(RBS::AST::Ruby::Declarations::ClassDecl)
+                raise
+              end
               if super_class = primary_decl.super_class
                 super_class.location
               else
@@ -644,13 +652,17 @@ module Steep
       end
 
       def validate_one_alias(name, entry = env.type_alias_decls.fetch(name))
-        *, inner_most_outer_module = entry.outer
-        if inner_most_outer_module
-          class_type = AST::Types::Name::Singleton.new(name: inner_most_outer_module.name)
-          instance_type = AST::Types::Name::Instance.new(
-            name: inner_most_outer_module.name,
-            args: inner_most_outer_module.type_params.map { AST::Types::Any.instance() },
-          )
+        inner_most_outer_module_name = entry.context&.last
+
+        if inner_most_outer_module_name
+          inner_most_outer_module = env.module_class_entry(inner_most_outer_module_name, normalized: true)
+          if inner_most_outer_module
+            class_type = AST::Types::Name::Singleton.new(name: inner_most_outer_module.name)
+            instance_type = AST::Types::Name::Instance.new(
+              name: inner_most_outer_module.name,
+              args: inner_most_outer_module.type_params.map { AST::Types::Any.instance() },
+            )
+          end
         end
 
         push_context(class_type: class_type, instance_type: instance_type, self_type: nil) do

data/lib/steep/source/ignore_ranges.rb

@@ -21,7 +21,7 @@ module Steep
             last_start = ignore
           when AST::Ignore::IgnoreEnd
             if last_start
-              ignored_ranges << (last_start.line..ignore.line)
+              ignored_ranges << [last_start, ignore]
               last_start = nil
             else
               error_ignores << ignore
@@ -40,18 +40,28 @@ module Steep
         end
       end
 
+      def each_ignore(&block)
+        if block
+          ignored_ranges.each(&block)
+          ignored_lines.each_value(&block)
+        else
+          enum_for(:each_ignore)
+        end
+      end
+
       def ignore?(start_line, end_line, code)
         if ignore = ignored_lines.fetch(start_line, nil)
-          ignore_code?(ignore, code) and return true
+          ignore_code?(ignore, code) and return ignore
         end
 
         if start_line != end_line
           if ignore = ignored_lines.fetch(end_line, nil)
-            ignore_code?(ignore, code) and return true
+            ignore_code?(ignore, code) and return ignore
           end
         end
 
-        ignored_ranges.any? do |range|
+        ignored_ranges.find do |ignore_start, ignore_end|
+          range = ignore_start.line..ignore_end.line
           range.cover?(start_line) && range.cover?(end_line)
         end
       end

data/lib/steep/source.rb

@@ -19,7 +19,7 @@ module Steep
       @ignores = ignores
     end
 
-    class Builder < ::Parser::Builders::Default
+    class Builder < Prism::Translation::Parser::Builder
       def string_value(token)
         value(token)
       end
@@ -31,7 +31,7 @@ module Steep
     end
 
     def self.new_parser
-      ::Parser::Ruby33.new(Builder.new).tap do |parser|
+      Prism::Translation::Parser34.new(Builder.new).tap do |parser|
         parser.diagnostics.all_errors_are_fatal = true
         parser.diagnostics.ignore_warnings = true
       end
@@ -257,7 +257,7 @@ module Steep
         annot.line or next
 
         case node.type
-        when :def, :module, :class, :block, :numblock, :ensure, :defs, :resbody
+        when :def, :module, :class, :block, :numblock, :itblock, :ensure, :defs, :resbody
           location = node.loc
           location.line <= annot.line && annot.line < location.last_line
         else
@@ -319,6 +319,20 @@ module Steep
       end
     end
 
+    def each_block_annotation(node, &block)
+      if block
+        if annots = mapping.fetch(node, nil)
+          annots.each(&block)
+        end
+      else
+        enum_for :each_block_annotation, node
+      end
+    end
+
+    def find_block_node(nodes)
+      nodes.find { mapping.key?(_1) }
+    end
+
     def each_heredoc_node(node = self.node, parents = [], &block)
       if block
         return unless node
@@ -551,13 +565,13 @@ module Steep
                   end
                 ]
               )
-            when :numblock
-              send, size, body = node.children
+            when :numblock, :itblock
+              send, arg, body = node.children
               node = node.updated(
                 nil,
                 [
                   map_child_node(send) {|child| insert_type_node(child, child_assertions) },
-                  size,
+                  arg,
                   insert_type_node(body, child_assertions)
                 ]
               )
@@ -634,7 +648,7 @@ module Steep
         case node.type
         when :send, :csend
           node
-        when :block, :numblock
+        when :block, :numblock, :itblock
           send = node.children[0]
           case send.type
           when :send, :csend

data/lib/steep/tagged_logging.rb

@@ -0,0 +1,39 @@
+module Steep
+  # A basic implementation of ActiveSupport::TaggedLogging.
+  # Might be able to be replaced by plain logger in the future.
+  # https://github.com/ruby/logger/pull/132
+  class TaggedLogging < Logger
+    def initialize(...)
+      super
+      self.formatter = proc do |severity, datetime, progname, msg|
+        # @type var severity: String
+        # @type var datetime: Time
+        # @type var progname: untyped
+        # @type var msg: untyped
+        # @type block: String
+        "#{datetime.strftime('%Y-%m-%d %H:%M:%S.%L')}: #{severity}: #{formatted_tags} #{msg}\n"
+      end
+      @thread_key = "steep_tagged_logging_tags:#{object_id}"
+      current_tags << "Steep #{VERSION}"
+    end
+
+    def tagged(tag)
+      current_tags << tag
+      yield
+    ensure
+      current_tags.pop
+    end
+
+    def current_tags
+      Thread.current[@thread_key] ||= []
+    end
+
+    def push_tags(*tags)
+      current_tags.concat(tags)
+    end
+
+    def formatted_tags
+      current_tags.map { |tag| "[#{tag}]" }.join(" ")
+    end
+  end
+end

data/lib/steep/type_construction.rb

@@ -39,6 +39,10 @@ module Steep
 
     SPECIAL_LVAR_NAMES = Set[:_, :__any__, :__skip__]
 
+    # a synthetic variable name for anonymous block params (can't conflict with
+    # user variables since Ruby doesn't allow * in local variable names).
+    ANONYMOUS_BLOCK_PASSABLE_LVAR = :"*block"
+
     include ModuleHelper
 
     attr_reader :checker
@@ -212,13 +216,21 @@ module Steep
           TypeInference::MethodParams.empty(node: node)
         end
 
+      block_param_name = nil #: Symbol?
+      method_params.each_param do |param|
+        if param.is_a?(TypeInference::MethodParams::BlockParameter)
+          block_param_name = param.name || ANONYMOUS_BLOCK_PASSABLE_LVAR
+        end
+      end
+
       method_context = TypeInference::Context::MethodContext.new(
         name: method_name,
         method: definition && definition.methods[method_name],
         method_type: method_type,
         return_type: annots.return_type || method_type&.type&.return_type || AST::Builtin.any_type,
         super_method: super_method,
-        forward_arg_type: method_params.forward_arg_type
+        forward_arg_type: method_params.forward_arg_type,
+        block_param_name: block_param_name
       )
 
       local_variable_types = method_params.each_param.with_object({}) do |param, hash| #$ Hash[Symbol, AST::Types::t]
@@ -226,6 +238,8 @@ module Steep
           unless SPECIAL_LVAR_NAMES.include?(param.name)
             hash[param.name] = param.var_type
           end
+        elsif param.is_a?(TypeInference::MethodParams::BlockParameter)
+          hash[ANONYMOUS_BLOCK_PASSABLE_LVAR] = param.var_type
         end
       end
       type_env = context.type_env.assign_local_variables(local_variable_types)
@@ -368,7 +382,7 @@ module Steep
       end
 
       if implement_module_name
-        module_entry = checker.factory.definition_builder.env.normalized_module_entry(implement_module_name.name)
+        module_entry = checker.factory.definition_builder.env.module_entry(implement_module_name.name, normalized: true)
         if module_entry
           module_context = module_context.update(
             instance_type: AST::Types::Intersection.build(
@@ -397,7 +411,7 @@ module Steep
               ].compact
             )
           )
-        elsif checker.factory.definition_builder.env.normalized_class_entry(implement_module_name.name)
+        elsif checker.factory.definition_builder.env.class_entry(implement_module_name.name, normalized:true)
           typing.add_error(
             Diagnostic::Ruby::ClassModuleMismatch.new(node: node, name: new_module_name)
           )
@@ -489,8 +503,8 @@ module Steep
           module_context = module_context.update(instance_definition: nil, module_definition: nil)
         end
 
-        if !checker.factory.definition_builder.env.normalized_class_entry(implement_module_name.name) &&
-          checker.factory.definition_builder.env.normalized_module_entry(implement_module_name.name)
+        if !checker.factory.definition_builder.env.class_entry(implement_module_name.name, normalized: true) &&
+          checker.factory.definition_builder.env.module_entry(implement_module_name.name, normalized: true)
           typing.add_error(
             Diagnostic::Ruby::ClassModuleMismatch.new(node: node, name: new_class_name)
           )
@@ -1355,7 +1369,7 @@ module Steep
           yield_self do
             var = node.children[0]
 
-            if SPECIAL_LVAR_NAMES.include?(var)
+            if !var || SPECIAL_LVAR_NAMES.include?(var)
               return add_typing(node, type: AST::Builtin.any_type)
             end
 
@@ -1376,7 +1390,7 @@ module Steep
           yield_self do
             var = node.children[0]
 
-            if SPECIAL_LVAR_NAMES.include?(var)
+            if !var || SPECIAL_LVAR_NAMES.include?(var)
               return add_typing(node, type: AST::Builtin.any_type)
             end
 
@@ -1442,7 +1456,7 @@ module Steep
 
           case
           when hint && check_relation(sub_type: ty, super_type: hint).success? && !hint.is_a?(AST::Types::Any) && !hint.is_a?(AST::Types::Top)
-            add_typing(node, type: hint)
+            add_typing(node, type: unwrap(hint))
           when condition
             add_typing(node, type: ty)
           else
@@ -1670,7 +1684,7 @@ module Steep
           end
 
         when :yield
-          if method_context && method_context.method_type
+          if method_context && (method_type = method_context.method_type)
             if block_type = method_context.block_type
               if block_type.type.params
                 type = AST::Types::Proc.new(
@@ -1701,9 +1715,12 @@ module Steep
               end
 
               add_typing(node, type: block_type.type.return_type)
-            else
+            elsif method_type.type.params
               typing.add_error(Diagnostic::Ruby::UnexpectedYield.new(node: node))
               fallback_to_any node
+            else
+              constr = type_check_untyped_args(node.children)
+              add_typing(node, type: AST::Builtin.any_type)
             end
           else
             fallback_to_any node
@@ -1733,7 +1750,7 @@ module Steep
               if hint
                 array = AST::Builtin::Array.instance_type(AST::Builtin.any_type)
                 if check_relation(sub_type: array, super_type: hint).success?
-                  add_typing node, type: hint
+                  add_typing node, type: unwrap(hint)
                 else
                   add_typing node, type: array
                 end
@@ -1745,13 +1762,18 @@ module Steep
               if hint
                 tuples = select_flatten_types(hint) {|type| type.is_a?(AST::Types::Tuple) } #: Array[AST::Types::Tuple]
                 unless tuples.empty?
+                  fallback_pair = nil #: Pair?
                   tuples.each do |tuple|
                     typing.new_child() do |child_typing|
                       if pair = with_new_typing(child_typing).try_tuple_type(node, tuple)
-                        return pair.with(constr: pair.constr.save_typing)
+                        if pair.constr.check_relation(sub_type: pair.type, super_type: tuple).success?
+                          return pair.with(constr: pair.constr.save_typing)
+                        end
+                        fallback_pair ||= pair.with(constr: pair.constr.save_typing)
                       end
                     end
                   end
+                  return fallback_pair if fallback_pair
                 end
               end
 
@@ -2192,7 +2214,10 @@ module Steep
           yield_self do
             body, ensure_body = node.children
             body_type = synthesize(body).type if body
-            synthesize(ensure_body) if ensure_body
+            if ensure_body
+              ensure_constr = for_branch(node)
+              ensure_constr.synthesize(ensure_body)
+            end
             if body_type
               add_typing(node, type: body_type)
             else
@@ -2505,7 +2530,9 @@ module Steep
               end
             else
               # Anonymous block_pass only happens inside method definition
-              if block_type = method_context!.block_type
+              if (type = context.type_env[ANONYMOUS_BLOCK_PASSABLE_LVAR])
+                # Use type from type_env (may have been narrowed by block_given?)
+              elsif block_type = method_context!.block_type
                 type = AST::Types::Proc.new(
                   type: block_type.type,
                   block: nil,
@@ -2669,7 +2696,7 @@ module Steep
             constr.add_typing(node, type: type)
           end
 
-        when :block, :numblock, :send, :csend
+        when :block, :numblock, :itblock, :send, :csend
           synthesize_sendish(node, hint: hint, tapp: nil)
 
         when :forwarded_args, :forward_arg
@@ -2687,7 +2714,6 @@ module Steep
           end
         end
       rescue RBS::BaseError => exn
-        Steep.logger.warn("hello")
         Steep.logger.warn { "Unexpected RBS error: #{exn.message}" }
         exn.backtrace&.each {|loc| Steep.logger.warn "  #{loc}" }
         typing.add_error(Diagnostic::Ruby::UnexpectedError.new(node: node, error: exn))
@@ -2746,6 +2772,20 @@ module Steep
 
           params = Parser::AST::Node.new(:args, arg_nodes)
 
+          if send_node.type == :lambda
+            # @type var node: Parser::AST::Node & Parser::AST::_BlockNode
+            type_lambda(node, params_node: params, body_node: body, type_hint: hint)
+          else
+            type_send(node, send_node: send_node, block_params: params, block_body: body, unwrap: send_node.type == :csend, tapp: tapp, hint: hint)
+          end
+        end
+      when :itblock
+        yield_self do
+          send_node, _name, body = node.children
+
+          arg_nodes = [Parser::AST::Node.new(:procarg0, [:it])]
+          params = Parser::AST::Node.new(:args, arg_nodes)
+
           if send_node.type == :lambda
             # @type var node: Parser::AST::Node & Parser::AST::_BlockNode
             type_lambda(node, params_node: params, body_node: body, type_hint: hint)
@@ -3225,6 +3265,8 @@ module Steep
       MethodName("::Hash#[]")
     ]
 
+    KERNEL_BLOCK_GIVEN = MethodName("::Kernel#block_given?")
+
     def pure_send?(call, receiver, arguments)
       return false unless call.node.type == :send || call.node.type == :csend
       return false unless call.pure? || KNOWN_PURE_METHODS.superset?(Set.new(call.method_decls.map(&:method_name)))
@@ -3318,7 +3360,7 @@ module Steep
             end
           end
 
-          if node.type == :csend || ((node.type == :block || node.type == :numblock) && node.children[0].type == :csend)
+          if node.type == :csend || ((node.type == :block || node.type == :numblock || node.type == :itblock) && node.children[0].type == :csend)
             optional_type = AST::Types::Union.build(types: [call.return_type, AST::Builtin.nil_type])
             call = call.with_return_type(optional_type)
           end
@@ -3364,6 +3406,34 @@ module Steep
           )
         end
 
+        # Handle block_given? type narrowing
+        if method_name == :block_given? && call.is_a?(TypeInference::MethodCall::Typed)
+          if call.method_decls.all? { _1.method_name == KERNEL_BLOCK_GIVEN }
+            if (block_var = constr.method_context&.block_param_name)
+              if (var_type = constr.context.type_env[block_var])
+                unwrapped = constr.checker.factory.unwrap_optional(var_type)
+
+                if unwrapped
+                  truthy_env = constr.context.type_env.refine_types(
+                    local_variable_types: { block_var => unwrapped }
+                  )
+                  falsy_env = constr.context.type_env.refine_types(
+                    local_variable_types: { block_var => AST::Builtin.nil_type }
+                  )
+
+                  env_type = AST::Types::Logic::Env.new(
+                    truthy: truthy_env,
+                    falsy: falsy_env,
+                    type: call.return_type
+                  )
+
+                  call = call.with_return_type(env_type)
+                end
+              end
+            end
+          end
+        end
+
         constr.add_call(call)
       else
         skips = [] #: Array[Parser::AST::Node?]
@@ -3453,7 +3523,7 @@ module Steep
 
         when AST::Types::Any
           case node.type
-          when :block, :numblock
+          when :block, :numblock, :itblock
             # @type var node: Parser::AST::Node & Parser::AST::_BlockNode
             block_annotations = source.annotations(block: node, factory: checker.factory, context: nesting)
             block_params or raise
@@ -4710,8 +4780,15 @@ module Steep
 
     def validate_method_definitions(node, module_name)
       module_name_1 = module_name.name
-      module_entry = checker.factory.env.normalized_module_class_entry(module_name_1) or raise
-      member_decl_count = module_entry.decls.count {|d| d.decl.each_member.count > 0 }
+      module_entry = checker.factory.env.module_class_entry(module_name_1, normalized: true) or raise
+      member_decl_count = module_entry.each_decl.count do |decl|
+        case decl
+        when RBS::AST::Declarations::Base
+          decl.each_member.count > 0
+        else
+          false
+        end
+      end
 
       return unless member_decl_count == 1
 
@@ -4878,7 +4955,7 @@ module Steep
         else
           literal_type = AST::Types::Literal.new(value: literal)
           if check_relation(sub_type: literal_type, super_type: hint).success?
-            hint
+            unwrap(hint)
           end
         end
       end
@@ -4887,7 +4964,7 @@ module Steep
     def to_instance_type(type, args: nil)
       args = args || case type
                      when AST::Types::Name::Singleton
-                       decl = checker.factory.env.normalized_module_class_entry(type.name) or raise
+                       decl = checker.factory.env.module_class_entry(type.name, normalized: true) or raise
                        decl.type_params.each.map { AST::Builtin.any_type }
                      else
                        raise "unexpected type to to_instance_type: #{type}"
@@ -5295,9 +5372,19 @@ module Steep
       annotations =
         case entry
         when RBS::Environment::ModuleEntry, RBS::Environment::ClassEntry
-          entry.decls.flat_map { _1.decl.annotations }
+          entry.each_decl.flat_map do |decl|
+            if decl.is_a?(RBS::AST::Declarations::Base)
+              decl.annotations
+            else
+              []
+            end
+          end
         when RBS::Environment::ConstantEntry, RBS::Environment::ClassAliasEntry, RBS::Environment::ModuleAliasEntry
-          entry.decl.annotations
+          if entry.decl.is_a?(RBS::AST::Declarations::Base)
+            entry.decl.annotations
+          else
+            [] #: Array[RBS::AST::Annotation]
+          end
         end
 
       if annotations

data/lib/steep/type_inference/block_params.rb

@@ -101,13 +101,13 @@ module Steep
       end
 
       def params
-        [].tap do |params|
-          params.push(*leading_params)
-          params.push(*optional_params)
-          params.push rest_param if rest_param
-          params.push(*trailing_params)
-          params.push(block_param) if block_param
-        end
+        params = [] #: Array[Param | MultipleParam]
+        params.push(*leading_params)
+        params.push(*optional_params)
+        params.push rest_param if rest_param
+        params.push(*trailing_params)
+        params.push(block_param) if block_param
+        params
       end
 
       def self.from_node(node, annotations:)

data/lib/steep/type_inference/context.rb

@@ -8,14 +8,16 @@ module Steep
         attr_reader :return_type
         attr_reader :super_method
         attr_reader :forward_arg_type
+        attr_reader :block_param_name
 
-        def initialize(name:, method:, method_type:, return_type:, super_method:, forward_arg_type:)
+        def initialize(name:, method:, method_type:, return_type:, super_method:, forward_arg_type:, block_param_name: nil)
           @name = name
           @method = method
           @return_type = return_type
           @method_type = method_type
           @super_method = super_method
           @forward_arg_type = forward_arg_type
+          @block_param_name = block_param_name
         end
 
         def block_type
@@ -174,7 +176,7 @@ module Steep
           block_context: block_context,
           break_context: break_context,
           module_context: module_context,
-          self_type: self_type,
+          self_type: self_type, # steep:ignore ArgumentTypeMismatch
           type_env: type_env,
           call_context: call_context,
           variable_context: variable_context

data/lib/steep/type_inference/logic_type_interpreter.rb

@@ -344,6 +344,22 @@ module Steep
               falsy_result = Result.new(type: FALSE, env: falsy_env, unreachable: false)
               falsy_result.unreachable! unless falsy_type
 
+              [truthy_result, falsy_result]
+            elsif (truthy_types, falsy_types = literal_var_type_case_select(arg, receiver_type, for_receiver: true))
+              # Handle literal equality: receiver == literal_value
+              truthy_env, falsy_env = refine_node_type(
+                env: env,
+                node: receiver,
+                truthy_type: truthy_types.empty? ? BOT : AST::Types::Union.build(types: truthy_types),
+                falsy_type: falsy_types.empty? ? BOT : AST::Types::Union.build(types: falsy_types)
+              )
+
+              truthy_result = Result.new(type: TRUE, env: truthy_env, unreachable: false)
+              truthy_result.unreachable! if truthy_types.empty?
+
+              falsy_result = Result.new(type: FALSE, env: falsy_env, unreachable: false)
+              falsy_result.unreachable! if falsy_types.empty?
+
               [truthy_result, falsy_result]
             end
           end
@@ -493,7 +509,7 @@ module Steep
         end
       end
 
-      def literal_var_type_case_select(value_node, arg_type)
+      def literal_var_type_case_select(value_node, arg_type, for_receiver: false)
         case arg_type
         when AST::Types::Union
           # @type var truthy_types: Array[AST::Types::t]
@@ -502,7 +518,7 @@ module Steep
           falsy_types = []
 
           arg_type.types.each do |type|
-            if (ts, fs = literal_var_type_case_select(value_node, type))
+            if (ts, fs = literal_var_type_case_select(value_node, type, for_receiver: for_receiver))
               truthy_types.push(*ts)
               falsy_types.push(*fs)
             else
@@ -548,7 +564,12 @@ module Steep
                   false_types << type
                 end
               else
-                true_types << AST::Types::Literal.new(value: value_node.children[0])
+                # For `==`, narrow only when the literal can be a value of `type`.
+                # e.g. `Symbol == :fatal` can be true, but `SomeClass == :fatal` cannot.
+                literal_type = AST::Types::Literal.new(value: value_node.children[0])
+                if !for_receiver || subtyping?(sub_type: literal_type, super_type: type)
+                  true_types << literal_type
+                end
                 false_types << type
               end
             end