[SE-0309] Gate SE-0309 behind the frontend flag -enable-experimental-universal-existentials,

hborla · hborla · commit ff771739cf26 · 2022-02-01T10:49:03.000-08:00
and disable the flag by default.
diff --git a/include/swift/AST/DiagnosticsSema.def b/include/swift/AST/DiagnosticsSema.def
@@ -4647,6 +4647,9 @@ ERROR(unchecked_not_inheritance_clause,none,
 ERROR(unchecked_not_existential,none,
       "'unchecked' attribute cannot apply to non-protocol type %0", (Type))
 
+ERROR(unsupported_existential_type,none,
+      "protocol %0 can only be used as a generic constraint because it has "
+      "Self or associated type requirements", (Identifier))
 ERROR(any_not_existential,none,
        "'any' has no effect on %select{concrete type|type parameter}0 %1",
        (bool, Type))
diff --git a/include/swift/Basic/LangOptions.h b/include/swift/Basic/LangOptions.h
@@ -317,6 +317,10 @@ namespace swift {
     /// keyword.
     bool EnableExplicitExistentialTypes = true;
 
+    /// Enable experimental support for universal existential types
+    /// as proposed in SE-0309.
+    bool EnableExperimentalUniversalExistentials = false;
+
     /// Enable experimental flow-sensitive concurrent captures.
     bool EnableExperimentalFlowSensitiveConcurrentCaptures = false;
 
diff --git a/include/swift/Option/FrontendOptions.td b/include/swift/Option/FrontendOptions.td
@@ -486,6 +486,10 @@ def enable_explicit_existential_types :
   Flag<["-"], "enable-explicit-existential-types">,
   HelpText<"Enable experimental support for explicit existential types">;
 
+def enable_experimental_universal_existentials :
+  Flag<["-"], "enable-experimental-universal-existentials">,
+  HelpText<"Enable experimental support for universal existential types">;
+
 def enable_deserialization_recovery :
   Flag<["-"], "enable-deserialization-recovery">,
   HelpText<"Attempt to recover from missing xrefs (etc) in swiftmodules">;
diff --git a/lib/Frontend/CompilerInvocation.cpp b/lib/Frontend/CompilerInvocation.cpp
@@ -441,6 +441,9 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
   Opts.EnableExplicitExistentialTypes |=
       Args.hasArg(OPT_enable_explicit_existential_types);
 
+  Opts.EnableExperimentalUniversalExistentials |=
+      Args.hasArg(OPT_enable_experimental_universal_existentials);
+
   Opts.EnableExperimentalDistributed |=
     Args.hasArg(OPT_enable_experimental_distributed);
 
diff --git a/lib/Sema/TypeCheckType.cpp b/lib/Sema/TypeCheckType.cpp
@@ -3966,7 +3966,8 @@ class ExistentialTypeVisitor
       return false;
 
     // Arbitrary protocol constraints are okay for 'any' types.
-    if (isa<ExistentialTypeRepr>(T))
+    if (Ctx.LangOpts.EnableExperimentalUniversalExistentials &&
+        isa<ExistentialTypeRepr>(T))
       return false;
 
     visit(T);
@@ -3991,16 +3992,23 @@ class ExistentialTypeVisitor
   }
 
   void visitIdentTypeRepr(IdentTypeRepr *T) {
-    if (T->isInvalid() || !Ctx.LangOpts.EnableExplicitExistentialTypes)
+    if (T->isInvalid())
       return;
 
     auto comp = T->getComponentRange().back();
     if (auto *proto = dyn_cast_or_null<ProtocolDecl>(comp->getBoundDecl())) {
       if (proto->existentialRequiresAny()) {
-        Ctx.Diags.diagnose(comp->getNameLoc(),
-                           diag::existential_requires_any,
-                           proto->getName())
-            .limitBehavior(DiagnosticBehavior::Warning);
+        if (!Ctx.LangOpts.EnableExperimentalUniversalExistentials) {
+          Ctx.Diags.diagnose(comp->getNameLoc(),
+                             diag::unsupported_existential_type,
+                             proto->getName());
+          T->setInvalid();
+        } else if (Ctx.LangOpts.EnableExplicitExistentialTypes) {
+          Ctx.Diags.diagnose(comp->getNameLoc(),
+                             diag::existential_requires_any,
+                             proto->getName())
+              .limitBehavior(DiagnosticBehavior::Warning);
+        }
       }
     } else if (auto *alias = dyn_cast_or_null<TypeAliasDecl>(comp->getBoundDecl())) {
       auto type = Type(alias->getDeclaredInterfaceType()->getDesugaredType());
@@ -4014,10 +4022,17 @@ class ExistentialTypeVisitor
             if (!protoDecl->existentialRequiresAny())
               continue;
 
-            Ctx.Diags.diagnose(comp->getNameLoc(),
-                               diag::existential_requires_any,
-                               protoDecl->getName())
-                .limitBehavior(DiagnosticBehavior::Warning);
+            if (!Ctx.LangOpts.EnableExperimentalUniversalExistentials) {
+              Ctx.Diags.diagnose(comp->getNameLoc(),
+                                 diag::unsupported_existential_type,
+                                 protoDecl->getName());
+              T->setInvalid();
+            } else if (Ctx.LangOpts.EnableExplicitExistentialTypes) {
+              Ctx.Diags.diagnose(comp->getNameLoc(),
+                                 diag::existential_requires_any,
+                                 protoDecl->getName())
+                  .limitBehavior(DiagnosticBehavior::Warning);
+            }
           }
         }
         return false;
diff --git a/test/Generics/function_defs.swift b/test/Generics/function_defs.swift
@@ -1,4 +1,4 @@
-// RUN: %target-typecheck-verify-swift
+// RUN: %target-typecheck-verify-swift -enable-experimental-universal-existentials
 
 //===----------------------------------------------------------------------===//
 // Type-check function definitions
diff --git a/test/decl/nested/protocol.swift b/test/decl/nested/protocol.swift
@@ -1,4 +1,4 @@
-// RUN: %target-typecheck-verify-swift -parse-as-library
+// RUN: %target-typecheck-verify-swift -parse-as-library -enable-experimental-universal-existentials
 
 // Protocols cannot be nested inside other types, and types cannot
 // be nested inside protocols
diff --git a/test/decl/protocol/conforms/inherited.swift b/test/decl/protocol/conforms/inherited.swift
@@ -1,4 +1,4 @@
-// RUN: %target-typecheck-verify-swift
+// RUN: %target-typecheck-verify-swift -enable-experimental-universal-existentials
 
 // Inheritable: method with 'Self' in contravariant position.
 protocol P1 {
diff --git a/test/decl/protocol/protocols.swift b/test/decl/protocol/protocols.swift
@@ -1,4 +1,4 @@
-// RUN: %target-typecheck-verify-swift -enable-objc-interop
+// RUN: %target-typecheck-verify-swift -enable-objc-interop -enable-experimental-universal-existentials
 protocol EmptyProtocol { }
 
 protocol DefinitionsInProtocols {
diff --git a/test/decl/protocol/protocols_with_self_or_assoc_reqs.swift b/test/decl/protocol/protocols_with_self_or_assoc_reqs.swift
@@ -1,4 +1,4 @@
-// RUN: %target-typecheck-verify-swift -disable-availability-checking
+// RUN: %target-typecheck-verify-swift -disable-availability-checking -enable-experimental-universal-existentials
 
 //===----------------------------------------------------------------------===//
 // Use of protocols with Self or associated type requirements
diff --git a/test/decl/protocol/recursive_requirement.swift b/test/decl/protocol/recursive_requirement.swift
@@ -1,4 +1,4 @@
-// RUN: %target-typecheck-verify-swift
+// RUN: %target-typecheck-verify-swift -enable-experimental-universal-existentials
 
 // -----
 
diff --git a/test/stmt/foreach.swift b/test/stmt/foreach.swift
@@ -1,4 +1,4 @@
-// RUN: %target-typecheck-verify-swift
+// RUN: %target-typecheck-verify-swift -enable-experimental-universal-existentials
 
 // Bad containers and ranges
 struct BadContainer1 {
diff --git a/test/type/explicit_existential.swift b/test/type/explicit_existential.swift
@@ -3,7 +3,7 @@
 protocol HasSelfRequirements {
   func foo(_ x: Self)
 
-  func returnsOwnProtocol() -> any HasSelfRequirements
+  func returnsOwnProtocol() -> HasSelfRequirements // expected-error {{protocol 'HasSelfRequirements' can only be used as a generic constraint because it has Self or associated type requirements}}
 }
 protocol Bar {
   init()
@@ -35,10 +35,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(_: any HasSelfRequirements,
-               _: any HasSelfRequirements & Bar,
-               _: any Compo,
-               _: any CompoAssocType.Compo) { }
+func useAsType(_: any HasSelfRequirements, // expected-error {{protocol 'HasSelfRequirements' can only be used as a generic constraint because it has Self or associated type requirements}}
+               _: any HasSelfRequirements & Bar, // expected-error {{protocol 'HasSelfRequirements' can only be used as a generic constraint because it has Self or associated type requirements}}
+               _: any Compo, // expected-error {{protocol 'HasSelfRequirements' can only be used as a generic constraint because it has Self or associated type requirements}}
+               _: any CompoAssocType.Compo) { } // expected-error {{protocol 'HasSelfRequirements' can only be used as a generic constraint because it has Self or associated type requirements}}
 
 struct TypeRequirement<T: HasSelfRequirements> {}
 struct CompoTypeRequirement<T: HasSelfRequirements & Bar> {}
@@ -66,7 +66,7 @@ do {
 
   func checkIt(_ js: Any) throws {
     switch js {
-    case let dbl as any HasAssoc:
+    case let dbl as any HasAssoc: // expected-error {{protocol 'HasAssoc' can only be used as a generic constraint because it has Self or associated type requirements}}
       throw MyError.bad(dbl)
 
     default:
@@ -75,25 +75,25 @@ do {
   }
 }
 
-func testHasAssoc(_ x: Any, _: any HasAssoc) {
-  if let p = x as? any HasAssoc {
+func testHasAssoc(_ x: Any, _: any HasAssoc) { // expected-error {{protocol 'HasAssoc' can only be used as a generic constraint because it has Self or associated type requirements}}
+  if let p = x as? any HasAssoc { // expected-error {{protocol 'HasAssoc' can only be used as a generic constraint because it has Self or associated type requirements}}
     p.foo()
   }
 
   struct ConformingType : HasAssoc {
     typealias Assoc = Int
     func foo() {}
 
-    func method() -> any HasAssoc {}
+    func method() -> any HasAssoc {} // expected-error {{protocol 'HasAssoc' can only be used as a generic constraint because it has Self or associated type requirements}}
   }
 }
 
-var b: any HasAssoc
+var b: any HasAssoc // expected-error {{protocol 'HasAssoc' can only be used as a generic constraint because it has Self or associated type requirements}}
 
 protocol P {}
 typealias MoreHasAssoc = HasAssoc & P
 func testHasMoreAssoc(_ x: Any) {
-  if let p = x as? any MoreHasAssoc {
+  if let p = x as? any MoreHasAssoc { // expected-error {{protocol 'HasAssoc' can only be used as a generic constraint because it has Self or associated type requirements}}
     p.foo()
   }
 }
@@ -102,36 +102,36 @@ typealias X = Struct1<any Pub & Bar>
 _ = Struct1<any Pub & Bar>.self
 
 typealias AliasWhere<T> = T
-where T: HasAssoc, T.Assoc == any HasAssoc
+where T: HasAssoc, T.Assoc == any HasAssoc // expected-error {{protocol 'HasAssoc' can only be used as a generic constraint because it has Self or associated type requirements}}
 
 struct StructWhere<T>
 where T: HasAssoc,
-      T.Assoc == any HasAssoc {}
+      T.Assoc == any HasAssoc {} // expected-error {{protocol 'HasAssoc' can only be used as a generic constraint because it has Self or associated type requirements}}
 
-protocol ProtocolWhere where T == any HasAssoc {
+protocol ProtocolWhere where T == any HasAssoc { // expected-error {{protocol 'HasAssoc' can only be used as a generic constraint because it has Self or associated type requirements}}
   associatedtype T
 
   associatedtype U: HasAssoc
-    where U.Assoc == any HasAssoc
+    where U.Assoc == any HasAssoc // expected-error {{protocol 'HasAssoc' can only be used as a generic constraint because it has Self or associated type requirements}}
 }
 
-extension HasAssoc where Assoc == any HasAssoc {}
+extension HasAssoc where Assoc == any HasAssoc {} // expected-error {{protocol 'HasAssoc' can only be used as a generic constraint because it has Self or associated type requirements}}
 
 func FunctionWhere<T>(_: T)
 where T : HasAssoc,
-      T.Assoc == any HasAssoc {}
+      T.Assoc == HasAssoc {} // expected-error {{protocol 'HasAssoc' can only be used as a generic constraint because it has Self or associated type requirements}}
 
 struct SubscriptWhere {
   subscript<T>(_: T) -> Int
   where T : HasAssoc,
-        T.Assoc == any HasAssoc {
+        T.Assoc == HasAssoc { // expected-error {{protocol 'HasAssoc' can only be used as a generic constraint because it has Self or associated type requirements}}
     get {}
     set {}
   }
 }
 
 struct OuterGeneric<T> {
-  func contextuallyGenericMethod() where T == any HasAssoc {}
+  func contextuallyGenericMethod() where T == HasAssoc {} // expected-error {{protocol 'HasAssoc' can only be used as a generic constraint because it has Self or associated type requirements}}
 }
 
 func testInvalidAny() {
diff --git a/test/type/protocol_types.swift b/test/type/protocol_types.swift
@@ -1,4 +1,4 @@
-// RUN: %target-typecheck-verify-swift
+// RUN: %target-typecheck-verify-swift -enable-experimental-universal-existentials
 
 protocol HasSelfRequirements {
   func foo(_ x: Self)

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-// RUN: %target-typecheck-verify-swift`
	`1`	`+// RUN: %target-typecheck-verify-swift -enable-experimental-universal-existentials`
`2`	`2`
`3`	`3`	`//===----------------------------------------------------------------------===//`
`4`	`4`	`// Type-check function definitions`