[wip] start banning casts of move-only types unless its the identity cast

Since structs and enums only
participate in subtyping via
protocols, move-only types that are
structs and enums effectively are
only subtypes of themselves.

Author: kavon

lib/Sema/TypeCheckConstraints.cpp

@@ -1659,6 +1659,27 @@ TypeChecker::typeCheckCheckedCast(Type fromType, Type toType,
        !unwrappedIUO)) {
     return CheckedCastKind::Coercion;
   }
+
+  // Since move-only types currently cannot conform to protocols, nor be a class
+  // type, the subtyping hierarchy is a bit bizarre as of now:
+  //
+  //              noncopyable
+  //           structs and enums
+  //                   |
+  //       +--------- Any
+  //       |           |
+  //   AnyObject    protocol
+  //       |       existentials
+  //       |            |   \
+  //       +---------+  |    +-- structs/enums
+  //                 |  |
+  //                classes
+  //           (and their subtyping)
+  //
+  //
+  // Thus, right now, a move-only type is only a subtype of itself.
+  if (fromType->isPureMoveOnly())
+    return CheckedCastKind::Unresolved;
 
   // Check for a bridging conversion.
   // Anything bridges to AnyObject.

test/Constraints/moveonly_constraints.swift

@@ -13,6 +13,8 @@
 
 struct LocalArray<Element> {}
 
+protocol P {}
+
 protocol Box<T> {
   associatedtype T
   func get() -> T
@@ -152,9 +154,16 @@ func checkCasting(_ b: any Box, _ mo: MO) {
   let _: AnyObject = MO() // expected-error {{move-only type 'MO' cannot be used with generics yet}}
   let _: Any = mo // expected-error {{move-only type 'MO' cannot be used with generics yet}}
 
-  // FIXME: this shouldn't be allowed
-  let _: AnyHashable = MO() as! AnyHashable
+  _ = MO() as P // expected-error {{move-only type 'MO' cannot be used with generics yet}}
+  _ = MO() as any P // expected-error {{move-only type 'MO' cannot be used with generics yet}}
+  _ = MO() as Any // expected-error {{move-only type 'MO' cannot be used with generics yet}}
+  _ = MO() as MO
+
+  // TODO: make sure at runtime these casts actually fail, or just make them errors?
+  let _: AnyHashable = MO() as! AnyHashable // expected-warning {{cast from 'MO' to unrelated type 'AnyHashable' always fails}}
 
+  // TODO: figure out how this is getting past us! Doesn't seem to hit `typeCheckCheckedCast` at all!
+  _ = MO() as AnyObject // expected-error {{move-only type 'MO' cannot be used with generics yet}}
 }
 
 func checkStdlibTypes(_ mo: MO) {