Build exhaustiveness support for type members (sorbet#9535)

* Add a test showing behavior before

* Build exhaustiveness support for type members

The key observation is that if we just return the `droppedFromUpper`,
then that means that we're not returning something that's a subtype of
the input. To make it a subtype of the input, we have to use `T.all` to
remember that it started as a type member, and also that there is a more
narrow bound.

* This test improves

In sorbet#9505, I wrote:

> we can't easily fix this one, so I didn't go out of my way to make it
> work.

Little did I know that it was actually not that hard.

Author: jez

core/Types.h

@@ -858,6 +858,8 @@ TYPE(AndType) final : public Refcounted {
     friend TypePtr Types::lub(const GlobalState &gs, const TypePtr &t1, const TypePtr &t2);
     friend TypePtr Types::glb(const GlobalState &gs, const TypePtr &t1, const TypePtr &t2);
     friend TypePtr Types::unwrapSelfTypeParam(Context ctx, const TypePtr &t1);
+    friend TypePtr Types::dropSubtypesOf(const GlobalState &gs, const TypePtr &from,
+                                         absl::Span<const ClassOrModuleRef> klasses);
 
     static TypePtr make_shared(const TypePtr &left, const TypePtr &right);
 };

core/types/types.cc

@@ -247,6 +247,25 @@ TypePtr Types::dropSubtypesOf(const GlobalState &gs, const TypePtr &from, absl::
                 result = from;
             }
         },
+        [&](const SelfTypeParam &p) {
+            if (!p.definition.isTypeMember()) {
+                // Only type members have upper bounds--type parameters do not
+                result = from;
+                return;
+            }
+
+            auto &lambdaParam = cast_type_nonnull<LambdaParam>(p.definition.asTypeMemberRef().data(gs)->resultType);
+            auto droppedFromUpper = dropSubtypesOf(gs, lambdaParam.upperBound, klasses);
+            if (droppedFromUpper.isBottom()) {
+                result = Types::bottom();
+            } else if (droppedFromUpper == lambdaParam.upperBound) {
+                result = from;
+            } else if (droppedFromUpper.kind() <= from.kind()) {
+                result = AndType::make_shared(droppedFromUpper, from);
+            } else {
+                result = AndType::make_shared(from, droppedFromUpper);
+            }
+        },
         [&](const TypePtr &) {
             if (is_proxy_type(from) && dropSubtypesOf(gs, from.underlying(gs), klasses).isBottom()) {
                 result = Types::bottom();

test/testdata/infer/drop_subtypes_self_type.rb

@@ -0,0 +1,36 @@
+# typed: true
+
+class Parent
+  extend T::Sig, T::Helpers
+  abstract!
+  sealed!
+
+  class Child1 < Parent; end
+  class Child2 < Parent; end
+
+  sig { returns(T.attached_class) }
+  def self.make_and_inspect
+    inst = self.new
+    T.reveal_type(inst) # error: `T.attached_class (of Parent)`
+    case inst
+    when Child1
+      T.reveal_type(inst) # error: `T.all(Parent::Child1, T.attached_class (of Parent))`
+    when Child2
+      T.reveal_type(inst) # error: `T.all(Parent::Child2, T.attached_class (of Parent))`
+    else
+      T.absurd(inst)
+    end
+  end
+
+  sig { returns(T.attached_class) }
+  def self.make_and_inspect_partial
+    inst = self.new
+    T.reveal_type(inst) # error: `T.attached_class (of Parent)`
+    case inst
+    when Child1
+      T.reveal_type(inst) # error: `T.all(Parent::Child1, T.attached_class (of Parent))`
+    else
+      T.absurd(inst) # error: Control flow could reach `T.absurd` because the type `T.all(Parent::Child2, T.attached_class (of Parent))` wasn't handled
+    end
+  end
+end

test/testdata/infer/kwsplat_nil.rb

@@ -21,6 +21,12 @@ def example(hash, maybe_hash_tm)
 
     takes_kwargs(**hash)
 
-    takes_kwargs(**maybe_hash_tm) # error: Method `to_hash` does not exist on `NilClass` component
+    takes_kwargs(**maybe_hash_tm)
+
+    case maybe_hash_tm
+    when nil
+    else
+      T.reveal_type(maybe_hash_tm) # error: `T.all(T::Hash[T.untyped, T.untyped], Example::MaybeHash)`
+    end
   end
 end