Enable parameterized protocols by default, and add new staging flag for parameterized existentials

Author: slavapestov

include/swift/AST/DiagnosticsParse.def

@@ -378,9 +378,6 @@ ERROR(expected_rbrace_actor,none,
       "expected '}' in actor", ())
 
 // Protocol
-ERROR(generic_arguments_protocol,PointsToFirstBadToken,
-      "protocols do not allow generic parameters; use associated types instead",
-      ())
 ERROR(expected_lbrace_protocol,PointsToFirstBadToken,
       "expected '{' in protocol type", ())
 ERROR(expected_rbrace_protocol,none,

include/swift/Basic/LangOptions.h

@@ -330,9 +330,9 @@ namespace swift {
     /// in calls to generic functions.
     bool EnableOpenedExistentialTypes = false;
 
-    /// Enable support for protocol types parameterized by primary
-    /// associated type.
-    bool EnableParameterizedProtocolTypes = false;
+    /// Enable support for parameterized protocol types in existential
+    /// position.
+    bool EnableParameterizedExistentialTypes = false;
 
     /// Enable experimental flow-sensitive concurrent captures.
     bool EnableExperimentalFlowSensitiveConcurrentCaptures = false;

include/swift/Option/FrontendOptions.td

@@ -540,9 +540,9 @@ def enable_explicit_existential_types :
   Flag<["-"], "enable-explicit-existential-types">,
   HelpText<"Enable experimental support for explicit existential types">;
 
-def enable_parameterized_protocol_types :
-  Flag<["-"], "enable-parameterized-protocol-types">,
-  HelpText<"Enable experimental support for primary associated types and parameterized protocols">;
+def enable_parameterized_existential_types :
+  Flag<["-"], "enable-parameterized-existential-types">,
+  HelpText<"Enable experimental support for parameterized existential types">;
 
 def enable_experimental_opened_existential_types :
   Flag<["-"], "enable-experimental-opened-existential-types">,

lib/Frontend/CompilerInvocation.cpp

@@ -448,8 +448,8 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
   Opts.EnableExperimentalNamedOpaqueTypes |=
       Args.hasArg(OPT_enable_experimental_named_opaque_types);
 
-  Opts.EnableParameterizedProtocolTypes |=
-      Args.hasArg(OPT_enable_parameterized_protocol_types);
+  Opts.EnableParameterizedExistentialTypes |=
+      Args.hasArg(OPT_enable_parameterized_existential_types);
 
   Opts.EnableOpenedExistentialTypes =
     Args.hasFlag(OPT_enable_experimental_opened_existential_types,

lib/Parse/ParseDecl.cpp

@@ -8066,19 +8066,8 @@ parseDeclProtocol(ParseDeclOptions Flags, DeclAttributes &Attributes) {
     return Status;
 
   SmallVector<PrimaryAssociatedTypeName, 2> PrimaryAssociatedTypeNames;
-
-  if (Context.LangOpts.EnableParameterizedProtocolTypes) {
-    if (startsWithLess(Tok)) {
-      Status |= parsePrimaryAssociatedTypes(PrimaryAssociatedTypeNames);
-    }
-  } else {
-    // Protocols don't support generic parameters, but people often want them and
-    // we want to have good error recovery if they try them out.  Parse them and
-    // produce a specific diagnostic if present.
-    if (startsWithLess(Tok)) {
-      diagnose(Tok, diag::generic_arguments_protocol);
-      maybeParseGenericParams();
-    }
+  if (startsWithLess(Tok)) {
+    Status |= parsePrimaryAssociatedTypes(PrimaryAssociatedTypeNames);
   }
 
   DebuggerContextChange DCC (*this);

lib/Sema/TypeCheckType.cpp

@@ -628,50 +628,48 @@ static Type applyGenericArguments(Type type, TypeResolution resolution,
   auto &ctx = dc->getASTContext();
   auto &diags = ctx.Diags;
 
-  if (ctx.LangOpts.EnableParameterizedProtocolTypes) {
-    if (auto *protoType = type->getAs<ProtocolType>()) {
-      // Build ParameterizedProtocolType if the protocol has a primary associated
-      // type and we're in a supported context (for now just generic requirements,
-      // inheritance clause, extension binding).
-      if (!resolution.getOptions().isParameterizedProtocolSupported()) {
-        diags.diagnose(loc, diag::parameterized_protocol_not_supported);
-        return ErrorType::get(ctx);
-      }
+  if (auto *protoType = type->getAs<ProtocolType>()) {
+    // Build ParameterizedProtocolType if the protocol has a primary associated
+    // type and we're in a supported context (for now just generic requirements,
+    // inheritance clause, extension binding).
+    if (!resolution.getOptions().isParameterizedProtocolSupported(ctx.LangOpts)) {
+      diags.diagnose(loc, diag::parameterized_protocol_not_supported);
+      return ErrorType::get(ctx);
+    }
 
-      auto *protoDecl = protoType->getDecl();
-      auto assocTypes = protoDecl->getPrimaryAssociatedTypes();
-      if (assocTypes.empty()) {
-        diags.diagnose(loc, diag::protocol_does_not_have_primary_assoc_type,
-                       protoType);
+    auto *protoDecl = protoType->getDecl();
+    auto assocTypes = protoDecl->getPrimaryAssociatedTypes();
+    if (assocTypes.empty()) {
+      diags.diagnose(loc, diag::protocol_does_not_have_primary_assoc_type,
+                     protoType);
 
-        return ErrorType::get(ctx);
-      }
-
-      auto genericArgs = generic->getGenericArgs();
+      return ErrorType::get(ctx);
+    }
 
-      if (genericArgs.size() != assocTypes.size()) {
-        diags.diagnose(loc,
-                       diag::parameterized_protocol_type_argument_count_mismatch,
-                       protoType, genericArgs.size(), assocTypes.size(),
-                       (genericArgs.size() < assocTypes.size()) ? 1 : 0);
+    auto genericArgs = generic->getGenericArgs();
 
-        return ErrorType::get(ctx);
-      }
+    if (genericArgs.size() != assocTypes.size()) {
+      diags.diagnose(loc,
+                     diag::parameterized_protocol_type_argument_count_mismatch,
+                     protoType, genericArgs.size(), assocTypes.size(),
+                     (genericArgs.size() < assocTypes.size()) ? 1 : 0);
 
-      auto genericResolution =
-        resolution.withOptions(adjustOptionsForGenericArgs(options));
+      return ErrorType::get(ctx);
+    }
 
-      SmallVector<Type, 2> argTys;
-      for (auto *genericArg : genericArgs) {
-        Type argTy = genericResolution.resolveType(genericArg, silParams);
-        if (!argTy || argTy->hasError())
-          return ErrorType::get(ctx);
+    auto genericResolution =
+      resolution.withOptions(adjustOptionsForGenericArgs(options));
 
-        argTys.push_back(argTy);
-      }
+    SmallVector<Type, 2> argTys;
+    for (auto *genericArg : genericArgs) {
+      Type argTy = genericResolution.resolveType(genericArg, silParams);
+      if (!argTy || argTy->hasError())
+        return ErrorType::get(ctx);
 
-      return ParameterizedProtocolType::get(ctx, protoType, argTys);
+      argTys.push_back(argTy);
     }
+
+    return ParameterizedProtocolType::get(ctx, protoType, argTys);
   }
 
   // We must either have an unbound generic type, or a generic type alias.

lib/Sema/TypeCheckType.h

@@ -19,6 +19,7 @@
 #include "swift/AST/Type.h"
 #include "swift/AST/Types.h"
 #include "swift/AST/TypeResolutionStage.h"
+#include "swift/Basic/LangOptions.h"
 #include "llvm/ADT/None.h"
 
 namespace swift {
@@ -277,13 +278,17 @@ class TypeResolutionOptions {
   }
 
   /// Whether parameterized protocol types are supported in this context.
-  bool isParameterizedProtocolSupported() const {
+  ///
+  /// FIXME: Remove LangOptions parameter once EnableParameterizedExistentialTypes
+  /// staging flag is gone.
+  bool isParameterizedProtocolSupported(const LangOptions &opts) const {
     switch (context) {
     case Context::Inherited:
     case Context::ExtensionBinding:
     case Context::GenericRequirement:
-    case Context::ExistentialConstraint:
       return true;
+    case Context::ExistentialConstraint:
+      return opts.EnableParameterizedExistentialTypes;
     case Context::None:
     case Context::TypeAliasDecl:
     case Context::GenericTypeAliasDecl:

test/Constraints/opened_existentials.swift

@@ -1,4 +1,4 @@
-// RUN: %target-typecheck-verify-swift -enable-experimental-opened-existential-types -enable-parameterized-protocol-types
+// RUN: %target-typecheck-verify-swift -enable-experimental-opened-existential-types
 
 protocol Q { }
 

test/ModuleInterface/parameterized-protocols.swift

@@ -1,5 +1,5 @@
 // RUN: %empty-directory(%t)
-// RUN: %target-swift-frontend -typecheck -module-name ParameterizedProtocols -emit-module-interface-path %t/ParameterizedProtocols.swiftinterface -enable-parameterized-protocol-types %s
+// RUN: %target-swift-frontend -typecheck -module-name ParameterizedProtocols -emit-module-interface-path %t/ParameterizedProtocols.swiftinterface %s
 // RUN: %FileCheck %s < %t/ParameterizedProtocols.swiftinterface
 
 public protocol HasPrimaryAssociatedTypes<T, U> {

test/Parse/invalid.swift

@@ -67,7 +67,7 @@ func d(_ b: String -> <T>() -> T) {} // expected-error {{expected type for funct
 
 
 // <rdar://problem/22143680> QoI: terrible diagnostic when trying to form a generic protocol
-protocol Animal<Food> {  // expected-error {{protocols do not allow generic parameters; use associated types instead}}
+protocol Animal<Food> {  // expected-error {{an associated type named 'Food' must be declared in the protocol 'Animal' or a protocol it inherits}}
   func feed(_ food: Food) // expected-error {{cannot find type 'Food' in scope}}
 }
 

test/SILGen/existential_parameters.swift renamed to test/SILGen/parameterized_existentials.swift

@@ -1,4 +1,4 @@
-// RUN: %target-swift-emit-silgen -module-name parameterized -enable-parameterized-protocol-types %s | %FileCheck %s
+// RUN: %target-swift-emit-silgen -module-name parameterized -enable-parameterized-existential-types %s | %FileCheck %s
 
 protocol P<T, U, V> {
   associatedtype T

test/SILOptimizer/cast_folding_parameterized_protocol.swift

@@ -1,4 +1,4 @@
-// RUN: %target-swift-frontend %s -emit-sil -enable-parameterized-protocol-types -O -o - | %FileCheck %s
+// RUN: %target-swift-frontend %s -emit-sil -enable-parameterized-existential-types -O -o - | %FileCheck %s
 
 public protocol P<T> {
   associatedtype T

test/type/opaque_parameters.swift

@@ -1,4 +1,4 @@
-// RUN: %target-typecheck-verify-swift -enable-parameterized-protocol-types -disable-availability-checking -requirement-machine-inferred-signatures=on
+// RUN: %target-typecheck-verify-swift -disable-availability-checking -requirement-machine-inferred-signatures=on
 
 protocol P { }
 

test/type/parameterized_existential.swift

@@ -0,0 +1,64 @@
+// RUN: %target-typecheck-verify-swift -requirement-machine-protocol-signatures=on -requirement-machine-inferred-signatures=on -disable-availability-checking -enable-parameterized-existential-types
+
+protocol Sequence<Element> {
+  associatedtype Element
+}
+
+struct ConcreteSequence<Element> : Sequence {}
+
+extension Sequence {
+  func map<Other>(_ transform: (Self.Element) -> Other) -> ConcreteSequence<Other> {
+    return ConcreteSequence<Other>()
+  }
+}
+
+protocol DoubleWide<X, Y> {
+  associatedtype X
+  associatedtype Y
+
+  var x: X { get }
+  var y: Y { get }
+}
+
+extension Int: DoubleWide {
+  typealias X = Int
+  typealias Y = Int
+
+  var x: X { 0 }
+  var y: X { 0 }
+}
+
+struct Collapse<T: DoubleWide>: DoubleWide {
+  typealias X = T
+  typealias Y = T
+
+  var x: X
+  var y: X { self.x }
+}
+
+func test() -> any DoubleWide<some DoubleWide<Int, Int>, some DoubleWide<Int, Int>> { return Collapse<Int>(x: 42) }
+
+func diagonalizeAny(_ x: any Sequence<Int>) -> any Sequence<(Int, Int)> {
+  return x.map { ($0, $0) }
+}
+
+func erase<T>(_ x: ConcreteSequence<T>) -> any Sequence<T> {
+  return x as any Sequence<T>
+}
+
+protocol Sponge<A, B> {
+  associatedtype A
+  associatedtype B
+}
+
+func saturation(_ dry: any Sponge, _ wet: any Sponge<Int, Int>) {
+  _ = dry as any Sponge<Int, Int>
+  // expected-error@-1 {{'any Sponge' is not convertible to 'any Sponge<Int, Int>'}}
+  // expected-note@-2 {{did you mean to use 'as!' to force downcast?}}
+  _ = dry as any Sponge
+
+  _ = wet as any Sponge<Int, Int> // Ok
+  _ = wet as any Sponge // Ok
+  _ = wet as any Sponge<String, String> // expected-error {{'any Sponge<Int, Int>' is not convertible to 'any Sponge<String, String>'}}
+  // expected-note@-1 {{did you mean to use 'as!' to force downcast?}}
+}

test/type/parameterized_protocol.swift

@@ -1,6 +1,6 @@
-// RUN: %target-typecheck-verify-swift -requirement-machine-protocol-signatures=on -requirement-machine-inferred-signatures=on -enable-parameterized-protocol-types -disable-availability-checking
+// RUN: %target-typecheck-verify-swift -requirement-machine-protocol-signatures=on -requirement-machine-inferred-signatures=on -disable-availability-checking
 
-// RUN: not %target-swift-frontend -typecheck %s -debug-generic-signatures -requirement-machine-protocol-signatures=on -enable-parameterized-protocol-types -requirement-machine-inferred-signatures=on -disable-availability-checking 2>&1 | %FileCheck %s
+// RUN: not %target-swift-frontend -typecheck %s -debug-generic-signatures -requirement-machine-protocol-signatures=on -requirement-machine-inferred-signatures=on -disable-availability-checking 2>&1 | %FileCheck %s
 
 
 /// Test some invalid syntax first
@@ -189,12 +189,17 @@ func returnsSequenceOfInt1() -> Sequence<Int> {}
 // expected-error@-1 {{protocol type with type arguments can only be used as a generic constraint}}
 
 func takesSequenceOfInt2(_: any Sequence<Int>) {}
+// expected-error@-1 {{protocol type with type arguments can only be used as a generic constraint}}
 
 func returnsSequenceOfInt2() -> any Sequence<Int> {}
+// expected-error@-1 {{protocol type with type arguments can only be used as a generic constraint}}
 
 func typeExpr() {
   _ = Sequence<Int>.self
   // expected-error@-1 {{protocol type with type arguments can only be used as a generic constraint}}
+
+  _ = any Sequence<Int>.self
+  // expected-error@-1 {{protocol type with type arguments can only be used as a generic constraint}}
 }
 
 /// Not supported as a protocol composition term for now
@@ -203,56 +208,3 @@ protocol SomeProto {}
 
 func protocolCompositionNotSupported(_: SomeProto & Sequence<Int>) {}
 // expected-error@-1 {{non-protocol, non-class type 'Sequence<Int>' cannot be used within a protocol-constrained type}}
-
-/// More regression tests
-
-protocol DoubleWide<X, Y> {
-  associatedtype X
-  associatedtype Y
-
-  var x: X { get }
-  var y: Y { get }
-}
-
-extension Int: DoubleWide {
-  typealias X = Int
-  typealias Y = Int
-
-  var x: X { 0 }
-  var y: X { 0 }
-}
-
-struct Collapse<T: DoubleWide>: DoubleWide {
-  typealias X = T
-  typealias Y = T
-
-  var x: X
-  var y: X { self.x }
-}
-
-func test() -> any DoubleWide<some DoubleWide<Int, Int>, some DoubleWide<Int, Int>> { return Collapse<Int>(x: 42) }
-
-func diagonalizeAny(_ x: any Sequence<Int>) -> any Sequence<(Int, Int)> {
-  return x.map { ($0, $0) }
-}
-
-func erase<T>(_ x: ConcreteSequence<T>) -> any Sequence<T> {
-  return x as any Sequence<T>
-}
-
-protocol Sponge<A, B> {
-  associatedtype A
-  associatedtype B
-}
-
-func saturation(_ dry: any Sponge, _ wet: any Sponge<Int, Int>) {
-  _ = dry as any Sponge<Int, Int>
-  // expected-error@-1 {{'any Sponge' is not convertible to 'any Sponge<Int, Int>'}}
-  // expected-note@-2 {{did you mean to use 'as!' to force downcast?}}
-  _ = dry as any Sponge
-
-  _ = wet as any Sponge<Int, Int> // Ok
-  _ = wet as any Sponge // Ok
-  _ = wet as any Sponge<String, String> // expected-error {{'any Sponge<Int, Int>' is not convertible to 'any Sponge<String, String>'}}
-  // expected-note@-1 {{did you mean to use 'as!' to force downcast?}}
-}

validation-test/compiler_crashers_2_fixed/unsupported_recursive_opaque_conformance.swift

@@ -1,4 +1,4 @@
-// RUN: %target-swift-frontend -disable-availability-checking -emit-ir -enable-parameterized-protocol-types %s
+// RUN: %target-swift-frontend -disable-availability-checking -emit-ir -enable-parameterized-existential-types %s
 
 protocol P<X, Y> {
   associatedtype X : P