[Test] Start to add tests for explicit existential types.

Author: hborla

test/type/explicit_existential.swift

@@ -0,0 +1,164 @@
+// RUN: %target-typecheck-verify-swift -enable-explicit-existential-types
+
+protocol HasSelfRequirements {
+  func foo(_ x: Self)
+
+  func returnsOwnProtocol() -> any HasSelfRequirements
+}
+protocol Bar {
+  init()
+
+  func bar() -> any Bar
+}
+
+func useBarAsType(_ x: any Bar) {}
+
+protocol Pub : Bar { }
+
+func refinementErasure(_ p: any Pub) {
+  useBarAsType(p)
+}
+
+typealias Compo = HasSelfRequirements & Bar
+
+struct CompoAssocType {
+  typealias Compo = HasSelfRequirements & Bar
+}
+
+func useAsRequirement<T: HasSelfRequirements>(_ x: T) { }
+func useCompoAsRequirement<T: HasSelfRequirements & Bar>(_ x: T) { }
+func useCompoAliasAsRequirement<T: Compo>(_ x: T) { }
+func useNestedCompoAliasAsRequirement<T: CompoAssocType.Compo>(_ x: T) { }
+
+func useAsWhereRequirement<T>(_ x: T) where T: HasSelfRequirements {}
+func useCompoAsWhereRequirement<T>(_ x: T) where T: HasSelfRequirements & Bar {}
+func useCompoAliasAsWhereRequirement<T>(_ x: T) where T: Compo {}
+func useNestedCompoAliasAsWhereRequirement<T>(_ x: T) where T: CompoAssocType.Compo {}
+
+func useAsType(_: any HasSelfRequirements,
+               _: any HasSelfRequirements & Bar,
+               _: any Compo,
+               _: any CompoAssocType.Compo) { }
+
+struct TypeRequirement<T: HasSelfRequirements> {}
+struct CompoTypeRequirement<T: HasSelfRequirements & Bar> {}
+struct CompoAliasTypeRequirement<T: Compo> {}
+struct NestedCompoAliasTypeRequirement<T: CompoAssocType.Compo> {}
+
+struct CompoTypeWhereRequirement<T> where T: HasSelfRequirements & Bar {}
+struct CompoAliasTypeWhereRequirement<T> where T: Compo {}
+struct NestedCompoAliasTypeWhereRequirement<T> where T: CompoAssocType.Compo {}
+
+struct Struct1<T> { }
+
+typealias T1 = Pub & Bar
+typealias T2 = any Pub & Bar
+
+protocol HasAssoc {
+  associatedtype Assoc
+  func foo()
+}
+
+do {
+  enum MyError: Error {
+    case bad(Any)
+  }
+
+  func checkIt(_ js: Any) throws {
+    switch js {
+    case let dbl as any HasAssoc:
+      throw MyError.bad(dbl)
+
+    default:
+      fatalError("wrong")
+    }
+  }
+}
+
+func testHasAssoc(_ x: Any, _: any HasAssoc) {
+  if let p = x as? any HasAssoc {
+    p.foo()
+  }
+
+  struct ConformingType : HasAssoc {
+    typealias Assoc = Int
+    func foo() {}
+
+    func method() -> any HasAssoc {}
+  }
+}
+
+var b: any HasAssoc
+
+protocol P {}
+typealias MoreHasAssoc = HasAssoc & P
+func testHasMoreAssoc(_ x: Any) {
+  if let p = x as? any MoreHasAssoc {
+    p.foo()
+  }
+}
+
+typealias X = Struct1<any Pub & Bar>
+_ = Struct1<any Pub & Bar>.self
+
+typealias AliasWhere<T> = T
+where T: HasAssoc, T.Assoc == any HasAssoc
+
+struct StructWhere<T>
+where T: HasAssoc,
+      T.Assoc == any HasAssoc {}
+
+protocol ProtocolWhere where T == any HasAssoc {
+  associatedtype T
+
+  associatedtype U: HasAssoc
+    where U.Assoc == any HasAssoc
+}
+
+extension HasAssoc where Assoc == any HasAssoc {}
+
+func FunctionWhere<T>(_: T)
+where T : HasAssoc,
+      T.Assoc == any HasAssoc {}
+
+struct SubscriptWhere {
+  subscript<T>(_: T) -> Int
+  where T : HasAssoc,
+        T.Assoc == any HasAssoc {
+    get {}
+    set {}
+  }
+}
+
+struct OuterGeneric<T> {
+  func contextuallyGenericMethod() where T == any HasAssoc {}
+}
+
+func testInvalidAny() {
+  struct S: HasAssoc {
+    typealias Assoc = Int
+    func foo() {}
+  }
+  let _: any S = S() // expected-error{{'any' has no effect on concrete type 'S'}}
+
+  func generic<T: HasAssoc>(t: T) {
+    let _: any T = t // expected-error{{'any' has no effect on type parameter 'T'}}
+    let _: any T.Assoc // expected-error {{'any' has no effect on type parameter 'T.Assoc'}}
+  }
+
+  let _: any ((S) -> Void) = generic // expected-error{{'any' has no effect on concrete type '(S) -> Void'}}
+}
+
+func testRedundantAnyWarning() {
+  let _: any Any // expected-warning {{'any' is redundant on type 'Any'}}
+  let _: any AnyObject // expected-warning {{'any' is redundant on type 'AnyObject'}}
+}
+
+protocol P1 {}
+protocol P2 {}
+struct ConcreteComposition: P1, P2 {}
+
+func testMetatypes() {
+  let _: any P1.Type = ConcreteComposition.self
+  let _: any (P1 & P2).Type = ConcreteComposition.self
+}