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}}
 }