Fix type-checking against type placeholders

Under certain cases we'd compare a type with a TypePlaceholderId, but
due to the lack of explicit match rules for this type we'd treat the
comparison as incompatible.

Changelog: fixed

types/src/lib.rs

@@ -4476,13 +4476,35 @@ impl TypeRef {
         false
     }
 
+    fn type_check_with_type_placeholder(
+        self,
+        db: &mut Database,
+        with: TypePlaceholderId,
+        context: &mut TypeContext,
+        subtyping: bool,
+    ) -> bool {
+        if let Some(assigned) = with.value(db) {
+            self.type_check(db, assigned, context, subtyping)
+        } else {
+            with.assign(db, self);
+            true
+        }
+    }
+
     fn type_check_directly(
         self,
         db: &mut Database,
         with: TypeRef,
         context: &mut TypeContext,
         subtyping: bool,
     ) -> bool {
+        // This case is the same for all variants of `self`, so we handle it
+        // here once.
+        if let TypeRef::Placeholder(id) = with {
+            return self
+                .type_check_with_type_placeholder(db, id, context, subtyping);
+        }
+
         match self {
             TypeRef::Owned(our_id) => match with {
                 TypeRef::Owned(their_id) | TypeRef::Infer(their_id) => {