[Type System] Enable explicit existential types.

Author: hborla

include/swift/Basic/LangOptions.h

@@ -315,7 +315,7 @@ namespace swift {
 
     /// Enable support for explicit existential types via the \c any
     /// keyword.
-    bool EnableExplicitExistentialTypes = false;
+    bool EnableExplicitExistentialTypes = true;
 
     /// Enable experimental flow-sensitive concurrent captures.
     bool EnableExperimentalFlowSensitiveConcurrentCaptures = false;

lib/Serialization/ModuleFormat.h

@@ -56,7 +56,7 @@ const uint16_t SWIFTMODULE_VERSION_MAJOR = 0;
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
 /// Don't worry about adhering to the 80-column limit for this line.
-const uint16_t SWIFTMODULE_VERSION_MINOR = 652; // @main cleanup
+const uint16_t SWIFTMODULE_VERSION_MINOR = 653; // enable explicit existentials
 
 /// A standard hash seed used for all string hashes in a serialized module.
 ///

test/Generics/function_defs.swift

@@ -34,7 +34,7 @@ func min<T : MethodLessComparable>(_ x: T, y: T) -> T {
 //===----------------------------------------------------------------------===//
 
 func existential<T : EqualComparable, U : EqualComparable>(_ t1: T, t2: T, u: U) {
-  var eqComp : EqualComparable = t1 // Ok
+  var eqComp : EqualComparable = t1 // expected-warning {{protocol 'EqualComparable' as a type must be explicitly marked as 'any'}}
   eqComp = u
   if t1.isEqual(eqComp) {} // expected-error{{cannot convert value of type 'EqualComparable' to expected argument type 'T'}}
   if eqComp.isEqual(t2) {} // expected-error{{member 'isEqual' cannot be used on value of protocol type 'EqualComparable'; use a generic constraint instead}}
@@ -49,11 +49,11 @@ func otherExistential<T : EqualComparable>(_ t1: T) {
   otherEqComp = t1 // expected-error{{value of type 'T' does not conform to 'OtherEqualComparable' in assignment}}
   _ = otherEqComp
 
-  var otherEqComp2 : OtherEqualComparable // Ok
+  var otherEqComp2 : any OtherEqualComparable // Ok
   otherEqComp2 = t1 // expected-error{{value of type 'T' does not conform to 'OtherEqualComparable' in assignment}}
   _ = otherEqComp2
 
-  _ = t1 as EqualComparable & OtherEqualComparable // expected-error{{value of type 'T' does not conform to 'EqualComparable & OtherEqualComparable' in coercion}}
+  _ = t1 as any EqualComparable & OtherEqualComparable // expected-error{{value of type 'T' does not conform to 'EqualComparable & OtherEqualComparable' in coercion}}
 }
 
 //===----------------------------------------------------------------------===//

test/decl/nested/protocol.swift

@@ -31,7 +31,7 @@ protocol OuterProtocol {
 struct ConformsToOuterProtocol : OuterProtocol {
   typealias Hen = Int
 
-  func f() { let _ = InnerProtocol.self } // Ok
+  func f() { let _ = InnerProtocol.self } // expected-warning {{protocol 'InnerProtocol' as a type must be explicitly marked as 'any'}}
 }
 
 protocol Racoon {

test/decl/protocol/conforms/inherited.swift

@@ -167,13 +167,13 @@ class B : A {
 }
 
 func testB(_ b: B) {
-  var _: P1 = b
-  var _: P4 = b
+  var _: P1 = b // expected-warning {{protocol 'P1' as a type must be explicitly marked as 'any'}}
+  var _: P4 = b // expected-warning {{protocol 'P4' as a type must be explicitly marked as 'any'}}
   var _: P5 = b
   var _: P6 = b
-  var _: P7 = b
+  var _: P7 = b // expected-warning {{protocol 'P7' as a type must be explicitly marked as 'any'}}
   var _: P8 = b
-  var _: P9 = b
+  var _: P9 = b // expected-warning {{protocol 'P9' as a type must be explicitly marked as 'any'}}
 }
 
 // Class A5 conforms to P5 in an inheritable manner.

test/decl/protocol/protocols.swift

@@ -119,7 +119,7 @@ struct Circle {
 func testCircular(_ circle: Circle) {
   // FIXME: It would be nice if this failure were suppressed because the protocols
   // have circular definitions.
-  _ = circle as CircleStart // expected-error{{value of type 'Circle' does not conform to 'CircleStart' in coercion}}
+  _ = circle as any CircleStart // expected-error{{value of type 'Circle' does not conform to 'CircleStart' in coercion}}
 }
 
 // <rdar://problem/14750346>
@@ -439,18 +439,18 @@ func g<T : C2>(_ x : T) {
 
 class C3 : P1 {} // expected-error{{type 'C3' does not conform to protocol 'P1'}}
 func h<T : C3>(_ x : T) {
-  _ = x as P1
+  _ = x as any P1
 }
 func i<T : C3>(_ x : T?) -> Bool {
-  return x is P1
+  return x is any P1
   // FIXME: Bogus diagnostic.  See SR-11920.
   // expected-warning@-2 {{checking a value with optional type 'T?' against dynamic type 'P1' succeeds whenever the value is non-nil; did you mean to use '!= nil'?}}
 }
 func j(_ x : C1) -> Bool {
-  return x is P1
+  return x is P1 // expected-warning {{protocol 'P1' as a type must be explicitly marked as 'any'}}
 }
 func k(_ x : C1?) -> Bool {
-  return x is P1
+  return x is any P1
 }
 
 

test/decl/protocol/protocols_with_self_or_assoc_reqs.swift

@@ -57,7 +57,7 @@ protocol P1 {
   func invariantSelf7(_: (G<Self>) -> Void)
   func invariantSelf8(_: G<(Self) -> Void>)
   func invariantSelf9(_: G<() -> Self>)
-  func invariantSelf10(_: P1 & C<Self>)
+  func invariantSelf10(_: any P1 & C<Self>)
   func invariantSelf11() -> G<Self>.InnerG<Void>
   func invariantAssoc1(_: inout Q)
   func invariantAssoc2(_: (inout Q) -> Void)
@@ -68,7 +68,7 @@ protocol P1 {
   func invariantAssoc7(_: (G<Q>) -> Void)
   func invariantAssoc8(_: G<(Q) -> Void>)
   func invariantAssoc9(_: G<() -> Q>)
-  func invariantAssoc10(_: P1 & C<Q>)
+  func invariantAssoc10(_: any P1 & C<Q>)
   func invariantAssoc11() -> G<Q>.InnerG<Void>
 
   // Properties
@@ -117,7 +117,7 @@ protocol P1 {
   var invariantSelfProp7: ((G<Self>) -> Void) -> Void { get }
   var invariantSelfProp8: (G<(Self) -> Void>) -> Void { get }
   var invariantSelfProp9: (G<() -> Self>) -> Void { get }
-  var invariantSelfProp10: (P1 & C<Self>) -> Void { get }
+  var invariantSelfProp10: (any P1 & C<Self>) -> Void { get }
   var invariantSelfProp11: G<Self>.InnerG<Void> { get }
   var invariantAssocProp1: (inout Q) -> Void { get }
   var invariantAssocProp2: ((inout Q) -> Void) -> Void { get }
@@ -128,7 +128,7 @@ protocol P1 {
   var invariantAssocProp7: ((G<Q>) -> Void) { get }
   var invariantAssocProp8: (G<(Q) -> Void>) { get }
   var invariantAssocProp9: (G<() -> Q>) -> Void { get }
-  var invariantAssocProp10: (P1 & C<Q>) -> Void { get }
+  var invariantAssocProp10: (any P1 & C<Q>) -> Void { get }
   var invariantAssocProp11: G<Q>.InnerG<Void> { get }
 
   // Subscripts
@@ -172,15 +172,15 @@ protocol P1 {
   subscript(invariantSelfSubscript4 _: (G<Self>) -> Void) -> Void { get }
   subscript(invariantSelfSubscript5 _: G<(Self) -> Void>) -> Void { get }
   subscript(invariantSelfSubscript6 _: G<() -> Self>) -> Void { get }
-  subscript(invariantSelfSubscript7 _: P1 & C<Self>) -> Void { get }
+  subscript(invariantSelfSubscript7 _: any P1 & C<Self>) -> Void { get }
   subscript(invariantSelfSubscript8 _: Void) -> G<Self>.InnerG<Void> { get }
   subscript(invariantAssocSubscript1 _: G<Q>) -> Void { get }
   subscript(invariantAssocSubscript2 _: Void) -> G<Q> { get }
   subscript(invariantAssocSubscript3 _: Void) -> G<Q>.Inner { get }
   subscript(invariantAssocSubscript4 _: (G<Q>) -> Void) -> Void { get }
   subscript(invariantAssocSubscript5 _: G<(Q) -> Void>) -> Void { get }
   subscript(invariantAssocSubscript6 _: G<() -> Q>) -> Void { get }
-  subscript(invariantAssocSubscript7 _: P1 & C<Q>) -> Void { get }
+  subscript(invariantAssocSubscript7 _: any P1 & C<Q>) -> Void { get }
   subscript(invariantAssocSubscript8 _: Void) -> G<Q>.InnerG<Void> { get }
 }
 @available(macOS 10.15, *)
@@ -191,40 +191,40 @@ extension P1 {
 }
 
 do {
-  func testP1(arg: P1) {
+  func testP1(arg: any P1) {
     _ = arg.covariantSelfSimple() // ok
-    let _: P1 = arg.covariantSelfSimple() // ok
+    let _: any P1 = arg.covariantSelfSimple() // ok
     _ = arg.covariantSelfComplex({ _ in },  { _ in }, { _ in }, { _ in }) // ok
-    let _: [String : () -> (P1, P1)] = arg.covariantSelfComplex(
-      { (x: P1) in },
-      { (x: P1?) in },
-      { (x: Array<P1>) in },
-      { (x: Array<Array<P1>?>) in }
+    let _: [String : () -> (any P1, any P1)] = arg.covariantSelfComplex(
+      { (x: any P1) in },
+      { (x: (any P1)?) in },
+      { (x: Array<any P1>) in },
+      { (x: Array<Array<any P1>?>) in }
     ) // ok
     arg.covariantAssocSimple // expected-error {{member 'covariantAssocSimple' cannot be used on value of protocol type 'P1'; use a generic constraint instead}}
     arg.covariantAssocComplex({ _ in }, { _ in }, { _ in }, { _ in }) // expected-error {{member 'covariantAssocComplex' cannot be used on value of protocol type 'P1'; use a generic constraint instead}}
     // FIXME: expected-error@-1 {{unable to infer type of a closure parameter '_' in the current context}}
 
     _ = arg.covariantSelfPropSimple // ok
-    let _: P1 = arg.covariantSelfPropSimple // ok
+    let _: any P1 = arg.covariantSelfPropSimple // ok
     _ = arg.covariantSelfPropComplex // ok
     let _: (
-      _: (P1) -> Void,
-      _: (P1?) -> Void,
-      _: (Array<P1>) -> Void,
-      _: (Array<Array<P1>?>) -> Void
-    ) -> [String : () -> (P1, P1)] = arg.covariantSelfPropComplex // ok
+      _: (any P1) -> Void,
+      _: ((any P1)?) -> Void,
+      _: (Array<any P1>) -> Void,
+      _: (Array<Array<any P1>?>) -> Void
+    ) -> [String : () -> (any P1, any P1)] = arg.covariantSelfPropComplex // ok
     arg.covariantAssocPropSimple // expected-error {{member 'covariantAssocPropSimple' cannot be used on value of protocol type 'P1'; use a generic constraint instead}}
     arg.covariantAssocPropComplex // expected-error {{member 'covariantAssocPropComplex' cannot be used on value of protocol type 'P1'; use a generic constraint instead}}
 
     _ = arg[covariantSelfSubscriptSimple: ()] // ok
-    let _: P1 = arg[covariantSelfSubscriptSimple: ()] // ok
+    let _: any P1 = arg[covariantSelfSubscriptSimple: ()] // ok
     _ = arg[covariantSelfSubscriptComplex: { _ in },  { _ in }, { _ in }, { _ in }] // ok
-    let _: [String : () -> (P1, P1)] = arg[
-      covariantSelfSubscriptComplex: { (x: P1) in },
-      { (x: P1?) in },
-      { (x: Array<P1>) in },
-      { (x: Array<Array<P1>?>) in }
+    let _: [String : () -> (any P1, any P1)] = arg[
+      covariantSelfSubscriptComplex: { (x: any P1) in },
+      { (x: (any P1)?) in },
+      { (x: Array<any P1>) in },
+      { (x: Array<Array<any P1>?>) in }
     ] // ok
     arg[covariantAssocSubscriptSimple: ()] // expected-error {{member 'subscript' cannot be used on value of protocol type 'P1'; use a generic constraint instead}}
     arg[covariantAssocSubscriptComplex: { _ in }, { _ in }, { _ in }, { _ in }] // expected-error {{member 'subscript' cannot be used on value of protocol type 'P1'; use a generic constraint instead}}
@@ -444,15 +444,15 @@ protocol P1_TypeMemberOnInstanceAndViceVersa {
 do {
   // Test that invalid reference errors prevail over unsupported existential
   // member accesses.
-  func test(protoMeta: P1_TypeMemberOnInstanceAndViceVersa.Protocol,
-            existMeta: P1_TypeMemberOnInstanceAndViceVersa.Type,
-            instance: P1_TypeMemberOnInstanceAndViceVersa) {
+  func test(protoMeta: (any P1_TypeMemberOnInstanceAndViceVersa).Type,
+            existMeta: any P1_TypeMemberOnInstanceAndViceVersa.Type,
+            instance: any P1_TypeMemberOnInstanceAndViceVersa) {
     // P1_TypeMemberOnInstanceAndViceVersa.Protocol
-    protoMeta.static_invariantSelfMethod() // expected-error {{static member 'static_invariantSelfMethod' cannot be used on protocol metatype 'P1_TypeMemberOnInstanceAndViceVersa.Protocol'}}
-    protoMeta.static_invariantSelfProp // expected-error {{static member 'static_invariantSelfProp' cannot be used on protocol metatype 'P1_TypeMemberOnInstanceAndViceVersa.Protocol'}}
-    protoMeta[static_invariantSelfSubscript: ()] // expected-error {{static member 'subscript' cannot be used on protocol metatype 'P1_TypeMemberOnInstanceAndViceVersa.Protocol'}}
+    protoMeta.static_invariantSelfMethod() // expected-error {{static member 'static_invariantSelfMethod' cannot be used on protocol metatype '(P1_TypeMemberOnInstanceAndViceVersa).Protocol'}}
+    protoMeta.static_invariantSelfProp // expected-error {{static member 'static_invariantSelfProp' cannot be used on protocol metatype '(P1_TypeMemberOnInstanceAndViceVersa).Protocol'}}
+    protoMeta[static_invariantSelfSubscript: ()] // expected-error {{static member 'subscript' cannot be used on protocol metatype '(P1_TypeMemberOnInstanceAndViceVersa).Protocol'}}
     _ = protoMeta.covariantSelfMethod // ok
-    protoMeta.invariantSelfMethod // expected-error {{member 'invariantSelfMethod' cannot be used on value of protocol type 'P1_TypeMemberOnInstanceAndViceVersa.Protocol'; use a generic constraint instead}}
+    protoMeta.invariantSelfMethod // expected-error {{member 'invariantSelfMethod' cannot be used on value of protocol type '(P1_TypeMemberOnInstanceAndViceVersa).Protocol'; use a generic constraint instead}}
     protoMeta.invariantSelfProp // expected-error {{instance member 'invariantSelfProp' cannot be used on type 'P1_TypeMemberOnInstanceAndViceVersa'}}
     protoMeta[invariantSelfSubscript: ()] // expected-error {{instance member 'subscript' cannot be used on type 'P1_TypeMemberOnInstanceAndViceVersa'}}
 
@@ -481,7 +481,7 @@ protocol P2 {
 
   var prop: Self { get set }
 }
-func takesP2(p2: P2) {
+func takesP2(p2: any P2) {
   _ = p2[]
   // expected-error@-1{{member 'subscript' cannot be used on value of protocol type 'P2'; use a generic constraint instead}}
   _ = p2.prop
@@ -500,7 +500,7 @@ protocol MiscTestsProto {
   subscript(intToInt _: Int) -> Int { get }
 }
 do {
-  func miscTests(_ arg: MiscTestsProto) { // ok
+  func miscTests(_ arg: any MiscTestsProto) { // ok
     arg.runce(5)
 
     do {
@@ -515,7 +515,7 @@ do {
     _ = arg[intToAssoc: 17] // expected-error{{member 'subscript' cannot be used on value of protocol type 'MiscTestsProto'; use a generic constraint instead}}
   }
 
-  func existentialSequence(_ e: Sequence) {
+  func existentialSequence(_ e: any Sequence) {
     var x = e.makeIterator() // expected-error{{member 'makeIterator' cannot be used on value of protocol type 'Sequence'; use a generic constraint instead}}
     x.next()
     x.nonexistent()

test/decl/protocol/recursive_requirement.swift

@@ -91,7 +91,7 @@ protocol AsExistentialB {
 }
 
 protocol AsExistentialAssocTypeA {
-  var delegate : AsExistentialAssocTypeB? { get }
+  var delegate : AsExistentialAssocTypeB? { get } // expected-warning {{protocol 'AsExistentialAssocTypeB' as a type must be explicitly marked as 'any'}}
 }
 protocol AsExistentialAssocTypeB {
   func aMethod(_ object : AsExistentialAssocTypeA)
@@ -103,7 +103,7 @@ protocol AsExistentialAssocTypeAgainA {
   associatedtype Bar
 }
 protocol AsExistentialAssocTypeAgainB {
-  func aMethod(_ object : AsExistentialAssocTypeAgainA)
+  func aMethod(_ object : AsExistentialAssocTypeAgainA) // expected-warning {{protocol 'AsExistentialAssocTypeAgainA' as a type must be explicitly marked as 'any'}}
 }
 
 // SR-547

test/stmt/foreach.swift

@@ -176,7 +176,7 @@ func testOptionalSequence() {
 }
 
 // FIXME: Should this be allowed?
-func testExistentialSequence(s: Sequence) {
+func testExistentialSequence(s: any Sequence) {
   for x in s { // expected-error {{protocol 'Sequence' as a type cannot conform to the protocol itself}} expected-note {{only concrete types such as structs, enums and classes can conform to protocols}}
     _ = x
   }

test/type/protocol_types.swift

@@ -3,7 +3,7 @@
 protocol HasSelfRequirements {
   func foo(_ x: Self)
 
-  func returnsOwnProtocol() -> HasSelfRequirements
+  func returnsOwnProtocol() -> HasSelfRequirements // expected-warning {{protocol 'HasSelfRequirements' as a type must be explicitly marked as 'any'}}
 }
 protocol Bar {
   // init() methods should not prevent use as an existential.
@@ -36,10 +36,10 @@ 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(_: HasSelfRequirements,
-               _: HasSelfRequirements & Bar,
-               _: Compo,
-               _: CompoAssocType.Compo) { }
+func useAsType(_: any HasSelfRequirements,
+               _: any HasSelfRequirements & Bar,
+               _: any Compo,
+               _: any CompoAssocType.Compo) { }
 
 struct TypeRequirement<T: HasSelfRequirements> {}
 struct CompoTypeRequirement<T: HasSelfRequirements & Bar> {}
@@ -74,7 +74,7 @@ do {
 
   func checkIt(_ js: Any) throws {
     switch js {
-    case let dbl as HasAssoc:
+    case let dbl as HasAssoc: // expected-warning {{protocol 'HasAssoc' as a type must be explicitly marked as 'any'}}
       throw MyError.bad(dbl)
 
     default:
@@ -83,27 +83,27 @@ do {
   }
 }
 
-func testHasAssoc(_ x: Any, _: HasAssoc) {
-  if let p = x as? HasAssoc {
+func testHasAssoc(_ x: Any, _: HasAssoc) { // expected-warning {{protocol 'HasAssoc' as a type must be explicitly marked as 'any'}}
+  if let p = x as? any HasAssoc {
     p.foo() // don't crash here.
   }
 
   struct ConformingType : HasAssoc {
     typealias Assoc = Int
     func foo() {}
 
-    func method() -> HasAssoc {}
+    func method() -> HasAssoc {} // expected-warning {{protocol 'HasAssoc' as a type must be explicitly marked as 'any'}}
   }
 }
 
 // SR-38
-var b: HasAssoc
+var b: HasAssoc // expected-warning {{protocol 'HasAssoc' as a type must be explicitly marked as 'any'}}
 
 // Further generic constraint error testing - typealias used inside statements
 protocol P {}
 typealias MoreHasAssoc = HasAssoc & P
 func testHasMoreAssoc(_ x: Any) {
-  if let p = x as? MoreHasAssoc {
+  if let p = x as? any MoreHasAssoc {
     p.foo() // don't crash here.
   }
 }
@@ -118,34 +118,34 @@ typealias X = Struct1<Pub & Bar>
 _ = Struct1<Pub & Bar>.self
 
 typealias AliasWhere<T> = T
-where T : HasAssoc, T.Assoc == HasAssoc
+where T : HasAssoc, T.Assoc == HasAssoc // expected-warning {{protocol 'HasAssoc' as a type must be explicitly marked as 'any'}}
 
 struct StructWhere<T>
 where T : HasAssoc,
-      T.Assoc == HasAssoc {}
+      T.Assoc == any HasAssoc {}
 
-protocol ProtocolWhere where T == HasAssoc {
+protocol ProtocolWhere where T == HasAssoc { // expected-warning {{protocol 'HasAssoc' as a type must be explicitly marked as 'any'}}
   associatedtype T
 
   associatedtype U : HasAssoc
-    where U.Assoc == HasAssoc
+    where U.Assoc == any HasAssoc
 }
 
-extension HasAssoc where Assoc == HasAssoc {}
+extension HasAssoc where Assoc == HasAssoc {} // expected-warning {{protocol 'HasAssoc' as a type must be explicitly marked as 'any'}}
 
 func FunctionWhere<T>(_: T)
 where T : HasAssoc,
-      T.Assoc == HasAssoc {}
+      T.Assoc == any HasAssoc {}
 
 struct SubscriptWhere {
   subscript<T>(_: T) -> Int
   where T : HasAssoc,
-        T.Assoc == HasAssoc {
+        T.Assoc == any HasAssoc {
     get {}
     set {}
   }
 }
 
 struct OuterGeneric<T> {
-  func contextuallyGenericMethod() where T == HasAssoc {}
+  func contextuallyGenericMethod() where T == any HasAssoc {}
 }