Merge pull request #59076 from CodaFi/parambulate

[5.7] Enable SE-0353 By Default

Author: CodaFi

CHANGELOG.md

@@ -5,9 +5,42 @@ _**Note:** This is in reverse chronological order, so newer entries are added to
 
 ## Swift 5.7
 
+* [SE-0353][]:
+
+  Protocols with primary associated types can now be used in existential types,
+  enabling same-type constraints on those associated types.
+
+  ```
+  let strings: any Collection<String> = [ "Hello" ]
+  ```
+
+  Note that language features requiring runtime support like dynamic casts
+  (`is`, `as?`, `as!`), as well as generic usages of parameterized existentials
+  in generic types (e.g. `Array<any Collection<Int>>`) involve additional
+  availability checks to use. Back-deploying usages in generic position can be
+  worked around with a generic type-erasing wrapper struct, which is now much
+  simpler to implement:
+
+  ```swift
+  struct AnyCollection<T> {
+    var wrapped: any Collection<T>
+  }
+
+  let arrayOfCollections: [AnyCollection<T>] = [ /**/ ]
+  ```
+  
 * [SE-0329][]:
   New types representing time and clocks were introduced. This includes a protocol `Clock` defining clocks which allow for defining a concept of now and a way to wake up after a given instant. Additionally a new protocol `InstantProtocol` for defining instants in time was added. Furthermore a new protocol `DurationProtocol` was added to define an elapsed duration between two given `InstantProtocol` types. Most commonly the `Clock` types for general use are the `SuspendingClock` and `ContinuousClock` which represent the most fundamental clocks for the system. The `SuspendingClock` type does not progress while the machine is suspended whereas the `ContinuousClock` progresses no matter the state of the machine. 
 
+* [SE-0309][]:
+
+  Protocols with associated types and `Self` requirements can now be used as the
+  types of values with the `any` keyword.
+
+  Protocol methods that return associated types can be called on an `any` type;
+  the result is type-erased to the associated type's upper bound, which is another
+  `any` type having the same constraints as the associated type. For example:
+
   ```swift
     func delayedHello() async throws {
       try await Task.sleep(until: .now + .milliseconds(123), clock: .continuous)

include/swift/Basic/LangOptions.h

@@ -338,10 +338,6 @@ namespace swift {
     /// in calls to generic functions.
     bool EnableOpenedExistentialTypes = 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

@@ -543,10 +543,6 @@ def enable_explicit_existential_types :
   Flag<["-"], "enable-explicit-existential-types">,
   HelpText<"Enable experimental support for explicit existential types">;
 
-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">,
   HelpText<"Enable experimental support for implicitly opened existentials">;

lib/Frontend/CompilerInvocation.cpp

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

lib/Sema/TypeCheckType.cpp

@@ -632,7 +632,7 @@ static Type applyGenericArguments(Type type, TypeResolution resolution,
     // 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)) {
+    if (!resolution.getOptions().isParameterizedProtocolSupported()) {
       diags.diagnose(loc, diag::parameterized_protocol_not_supported);
       return ErrorType::get(ctx);
     }

lib/Sema/TypeCheckType.h

@@ -284,18 +284,14 @@ class TypeResolutionOptions {
   }
 
   /// Whether parameterized protocol types are supported in this context.
-  ///
-  /// FIXME: Remove LangOptions parameter once EnableParameterizedExistentialTypes
-  /// staging flag is gone.
-  bool isParameterizedProtocolSupported(const LangOptions &opts) const {
+  bool isParameterizedProtocolSupported() const {
     switch (context) {
     case Context::Inherited:
     case Context::ExtensionBinding:
     case Context::GenericRequirement:
-      return true;
     case Context::ExistentialConstraint:
     case Context::MetatypeBase:
-      return opts.EnableParameterizedExistentialTypes;
+      return true;
     case Context::None:
     case Context::TypeAliasDecl:
     case Context::GenericTypeAliasDecl:

test/Constraints/existential_metatypes.swift

@@ -90,3 +90,33 @@ func testP3(_ p: P3, something: Something) {
 func testIUOToAny(_ t: AnyObject.Type!) {
   let _: Any = t
 }
+
+protocol P4<T> {
+  associatedtype T
+}
+
+protocol Q4<T> {
+  associatedtype T
+}
+
+protocol PP4<U>: P4<Self.U.T> {
+  associatedtype U: P4<U>
+}
+
+func parameterizedExistentials() {
+  var qp: (any Q4<Int>).Type
+  var pp: (any P4<Int>).Type = qp // expected-error{{cannot convert value of type '(any Q4<Int>).Type' to specified type '(any P4<Int>).Type'}}
+
+  var qt: any Q4<Int>.Type
+  qt = qp // expected-error{{cannot assign value of type '(any Q4<Int>).Type' to type 'any Q4<Int>.Type'}}
+  qp = qt // expected-error{{cannot assign value of type 'any Q4<Int>.Type' to type '(any Q4<Int>).Type'}}
+  var pt: any P4<Int>.Type = qt // expected-error{{cannot convert value of type 'any Q4<Int>.Type' to specified type 'any P4<Int>.Type'}}
+  pt = pp // expected-error{{cannot assign value of type '(any P4<Int>).Type' to type 'any P4<Int>.Type'}}
+  pp = pt // expected-error{{cannot assign value of type 'any P4<Int>.Type' to type '(any P4<Int>).Type'}}
+
+  var ppp: (any PP4<Int>).Type
+  pp = ppp // expected-error{{cannot assign value of type '(any PP4<Int>).Type' to type '(any P4<Int>).Type'}}
+
+  var ppt: any PP4<Int>.Type
+  pt = ppt
+}

test/Constraints/parameterized_existential_metatypes.swift

@@ -1,4 +1,4 @@
-// RUN: %target-swift-frontend -emit-ir %s -swift-version 5  -disable-availability-checking -enable-parameterized-existential-types | %IRGenFileCheck %s
+// RUN: %target-swift-frontend -emit-ir %s -swift-version 5 -disable-availability-checking | %IRGenFileCheck %s
 
 // CHECK-LABEL: @"$sl26existential_shape_metadata2Q0_pyxXPXGMq" = linkonce_odr hidden constant
 // CHECK-SAME:  { i32 {{.*}}sub ([[INT]] ptrtoint (i8** @{{[0-9]+}} to [[INT]])

test/IRGen/existential_shape_metadata.swift

@@ -1,4 +1,4 @@
-// RUN: %target-run-simple-swift(-Xfrontend -enable-parameterized-existential-types -Xfrontend -disable-availability-checking)
+// RUN: %target-run-simple-swift(-Xfrontend -disable-availability-checking)
 // REQUIRES: executable_test
 
 import StdlibUnittest