Merge branch 'release/5.7' into se-0338-5.7

Author: DougGregor

CHANGELOG.md

@@ -38,9 +38,42 @@ _**Note:** This is in reverse chronological order, so newer entries are added to
   pool, `Sendable` checking will be performed, so the compiler will emit a
   diagnostic in the call to `f` if `c` is not of `Sendable` type.
 
+* [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">;

include/swift/Sema/Constraint.h

@@ -264,6 +264,8 @@ enum class ConversionRestrictionKind {
   ProtocolMetatypeToProtocolClass,
   /// Inout-to-pointer conversion.
   InoutToPointer,
+  /// Converting from `inout` to a C pointer has `PointerToCPointer` semantics.
+  InoutToCPointer,
   /// Array-to-pointer conversion.
   ArrayToPointer,
   /// String-to-pointer conversion.
@@ -303,8 +305,8 @@ enum class ConversionRestrictionKind {
   /// via an implicit Double initializer call passing a CGFloat value.
   CGFloatToDouble,
   /// Implicit conversion between Swift and C pointers:
-  //    - Unsafe[Mutable]RawPointer -> Unsafe[Mutable]Pointer<[U]Int>
-  //    - Unsafe[Mutable]Pointer<Int{8, 16, ...}> <-> Unsafe[Mutable]Pointer<UInt{8, 16, ...}>
+  ///    - Unsafe[Mutable]RawPointer -> Unsafe[Mutable]Pointer<[U]Int>
+  ///    - Unsafe[Mutable]Pointer<Int{8, 16, ...}> <-> Unsafe[Mutable]Pointer<UInt{8, 16, ...}>
   PointerToCPointer,
   // Convert a pack into a type with an equivalent arity.
   // - If the arity of the pack is 1, drops the pack structure <T> => T

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/Parse/ParseType.cpp

@@ -881,13 +881,20 @@ Parser::parseTypeSimpleOrComposition(Diag<> MessageID, ParseTypeReason reason) {
         Tok.isContextualKeyword("any")) {
       auto keyword = Tok.getText();
       auto badLoc = consumeToken();
+                
+      // Suggest moving `some` or `any` in front of the first type unless
+      // the first type is an opaque or existential type.
+      if (opaqueLoc.isValid() || anyLoc.isValid()) {
+        diagnose(badLoc, diag::opaque_mid_composition, keyword)
+            .fixItRemove(badLoc);
+      } else {
+        diagnose(badLoc, diag::opaque_mid_composition, keyword)
+            .fixItRemove(badLoc)
+            .fixItInsert(FirstTypeLoc, keyword.str() + " ");
+      }
 
       const bool isAnyKeyword = keyword.equals("any");
 
-      diagnose(badLoc, diag::opaque_mid_composition, keyword)
-          .fixItRemove(badLoc)
-          .fixItInsert(FirstTypeLoc, keyword.str() + " ");
-
       if (isAnyKeyword) {
         if (anyLoc.isInvalid()) {
           anyLoc = badLoc;

lib/Sema/CSApply.cpp

@@ -6646,7 +6646,8 @@ Expr *ExprRewriter::coerceToType(Expr *expr, Type toType,
       return buildCollectionUpcastExpr(expr, toType, /*bridged=*/false, locator);
     }
 
-    case ConversionRestrictionKind::InoutToPointer: {
+    case ConversionRestrictionKind::InoutToPointer:
+    case ConversionRestrictionKind::InoutToCPointer: {
       bool isOptional = false;
       Type unwrappedTy = toType;
       if (Type unwrapped = toType->getOptionalObjectType()) {
@@ -6664,7 +6665,7 @@ Expr *ExprRewriter::coerceToType(Expr *expr, Type toType,
         result = cs.cacheType(new (ctx) InjectIntoOptionalExpr(result, toType));
       return result;
     }
-    
+
     case ConversionRestrictionKind::ArrayToPointer: {
       bool isOptional = false;
       Type unwrappedTy = toType;

lib/Sema/CSBindings.cpp

@@ -1993,10 +1993,16 @@ bool TypeVariableBinding::attempt(ConstraintSystem &cs) const {
   // without any contextual information, so even though `x` would get
   // bound to result type of the chain, underlying type variable wouldn't
   // be resolved, so we need to propagate holes up the conversion chain.
+  // Also propagate in code completion mode because in some cases code
+  // completion relies on type variable being a potential hole.
   if (TypeVar->getImpl().canBindToHole()) {
-    if (auto objectTy = type->getOptionalObjectType()) {
-      if (auto *typeVar = objectTy->getAs<TypeVariableType>())
-        cs.recordPotentialHole(typeVar);
+    if (srcLocator->directlyAt<OptionalEvaluationExpr>() ||
+        cs.isForCodeCompletion()) {
+      if (auto objectTy = type->getOptionalObjectType()) {
+        if (auto *typeVar = objectTy->getAs<TypeVariableType>()) {
+          cs.recordPotentialHole(typeVar);
+        }
+      }
     }
   }
 

lib/Sema/CSClosure.cpp

@@ -1394,7 +1394,15 @@ class ClosureConstraintApplication
       }
 
       auto caseStmt = cast<CaseStmt>(rawCase.get<Stmt *>());
-      visitCaseStmt(caseStmt);
+      // Body of the `case` statement can contain a `fallthrough`
+      // statement that requires both source and destination
+      // `case` preambles to be type-checked, so bodies of `case`
+      // statements should be visited after preambles.
+      visitCaseStmtPreamble(caseStmt);
+    }
+
+    for (auto *caseStmt : switchStmt->getCases()) {
+      visitCaseStmtBody(caseStmt);
 
       // Check restrictions on '@unknown'.
       if (caseStmt->hasUnknownAttr()) {
@@ -1421,7 +1429,7 @@ class ClosureConstraintApplication
     return doStmt;
   }
 
-  ASTNode visitCaseStmt(CaseStmt *caseStmt) {
+  void visitCaseStmtPreamble(CaseStmt *caseStmt) {
     // Translate the patterns and guard expressions for each case label item.
     for (auto &caseItem : caseStmt->getMutableCaseLabelItems()) {
       SolutionApplicationTarget caseTarget(&caseItem, closure);
@@ -1437,11 +1445,16 @@ class ClosureConstraintApplication
           solution.getType(prev)->mapTypeOutOfContext());
       expected->setInterfaceType(type);
     }
+  }
 
-    // Translate the body.
+  void visitCaseStmtBody(CaseStmt *caseStmt) {
     auto *newBody = visit(caseStmt->getBody()).get<Stmt *>();
     caseStmt->setBody(cast<BraceStmt>(newBody));
+  }
 
+  ASTNode visitCaseStmt(CaseStmt *caseStmt) {
+    visitCaseStmtPreamble(caseStmt);
+    visitCaseStmtBody(caseStmt);
     return caseStmt;
   }
 

lib/Sema/CSDiagnostics.cpp

@@ -6897,6 +6897,7 @@ void NonEphemeralConversionFailure::emitSuggestionNotes() const {
     break;
   }
   case ConversionRestrictionKind::InoutToPointer:
+  case ConversionRestrictionKind::InoutToCPointer:
     // For an arbitrary inout-to-pointer, we can suggest
     // withUnsafe[Mutable][Bytes/Pointer].
     if (auto alternative = getAlternativeKind())