prevent MO as AnyObject and friends from typechecking

where `MO` is a move-only type.

turns out it was being allowed because the cast is represented as a
disjunction in the constraint solver:

- `MO conv AnyObject`
- `MO bridge conv AnyObject`

I caught the first one but missed the second, which was unconditionally
being allowed.

Author: kavon

lib/Sema/CSSimplify.cpp

@@ -11124,6 +11124,12 @@ ConstraintSystem::simplifyBridgingConstraint(Type type1,
   if (type1->isTypeVariableOrMember() || type2->isTypeVariableOrMember())
     return formUnsolved();
 
+  // Move-only types can't be involved in a bridging conversion since a bridged
+  // type assumes the ability to copy.
+  if (type1->isPureMoveOnly()) {
+    return SolutionKind::Error;
+  }
+
   Type unwrappedFromType;
   unsigned numFromOptionals;
   std::tie(unwrappedFromType, numFromOptionals) = unwrapType(type1);

test/Constraints/moveonly_constraints.swift

@@ -158,12 +158,28 @@ func checkCasting(_ b: any Box, _ mo: MO) {
   _ = 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
+  _ = MO() as AnyObject // expected-error {{move-only type 'MO' cannot be used with generics yet}}
 
-  // 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}}
+  // FIXME(kavon): make sure at runtime these casts actually fail, or just make them errors? (rdar://104900293)
+
+  _ = MO() is AnyHashable // expected-warning {{cast from 'MO' to unrelated type 'AnyHashable' always fails}}
+  _ = MO() is AnyObject // expected-warning {{cast from 'MO' to unrelated type 'AnyObject' always fails}}
+  _ = MO() is Any // expected-warning {{cast from 'MO' to unrelated type 'Any' always fails}}
+  _ = MO() is P // expected-warning {{cast from 'MO' to unrelated type 'any P' always fails}}
+  _ = MO() is MO // expected-warning {{'is' test is always true}}
+
+  _ = MO() as! AnyHashable // expected-warning {{cast from 'MO' to unrelated type 'AnyHashable' always fails}}
+  _ = MO() as! AnyObject // expected-warning {{cast from 'MO' to unrelated type 'AnyObject' always fails}}
+  _ = MO() as! Any // expected-warning {{cast from 'MO' to unrelated type 'Any' always fails}}
+  _ = MO() as! P // expected-warning {{cast from 'MO' to unrelated type 'any P' always fails}}
+  _ = MO() as! MO // expected-warning {{forced cast of 'MO' to same type has no effect}}
+
+  _ = MO() as? AnyHashable // expected-warning {{cast from 'MO' to unrelated type 'AnyHashable' always fails}}
+  _ = MO() as? AnyObject // expected-warning {{cast from 'MO' to unrelated type 'AnyObject' always fails}}
+  _ = MO() as? Any // expected-warning {{cast from 'MO' to unrelated type 'Any' always fails}}
+  _ = MO() as? P // expected-warning {{cast from 'MO' to unrelated type 'any P' always fails}}
+  _ = MO() as? MO // expected-warning {{conditional cast from 'MO' to 'MO' always succeeds}}
 
-  // 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) {
@@ -211,4 +227,4 @@ protocol Gives: HasType {
 struct GenerousGuy: Gives { // expected-error {{type 'GenerousGuy' does not conform to protocol 'HasType'}}
   typealias Ty = MO // expected-note {{possibly intended match 'GenerousGuy.Ty' (aka 'MO') does not conform to '_Copyable'}}
   func give() -> Ty {}
-}
+}