Merge branch 'release/6.0' into pick-6-pick-concurrency-isCurrent-more-fixes

Author: ktoso

CHANGELOG.md

@@ -5,6 +5,40 @@
 
 ## Swift 6.0
 
+* [SE-0427][]:
+  You can now suppress `Copyable` on protocols, generic parameters, 
+  and existentials:
+
+  ```swift
+  // Protocol does not require conformers to be Copyable.
+  protocol Flower: ~Copyable {
+    func bloom()
+  }
+
+  // Noncopyable type
+  struct Marigold: Flower, ~Copyable {
+    func bloom() { print("Marigold blooming!") }
+  }
+
+  // Copyable type
+  struct Hibiscus: Flower {
+    func bloom() { print("Hibiscus blooming!") }
+  }
+
+  func startSeason(_ flower: borrowing some Flower & ~Copyable) {
+    flower.bloom()
+  }
+
+  startSeason(Marigold())
+  startSeason(Hibiscus())
+  ```
+
+  By writing `~Copyable` on a generic type, you're suppressing a default
+  `Copyable` constraint that would otherwise appear on that type. This permits
+  noncopyable types, which have no `Copyable` conformance, to conform to such 
+  protocols and be substituted for those generic types. Full functionality of this
+  feature requires the newer Swift 6 runtime.
+
 * Since its introduction in Swift 5.1 the @TaskLocal property wrapper was used to   
   create and access task-local value bindings. Property wrappers introduce mutable storage,
   which was now properly flagged as potential source of concurrency unsafety.
@@ -10252,6 +10286,7 @@ using the `.dynamicType` member to retrieve the type of an expression should mig
 [SE-0412]: https://github.com/apple/swift-evolution/blob/main/proposals/0412-strict-concurrency-for-global-variables.md
 [SE-0413]: https://github.com/apple/swift-evolution/blob/main/proposals/0413-typed-throws.md
 [SE-0422]: https://github.com/apple/swift-evolution/blob/main/proposals/0422-caller-side-default-argument-macro-expression.md
+[SE-0427]: https://github.com/apple/swift-evolution/blob/main/proposals/0427-noncopyable-generics.md
 [#64927]: <https://github.com/apple/swift/issues/64927>
 [#42697]: <https://github.com/apple/swift/issues/42697>
 [#42728]: <https://github.com/apple/swift/issues/42728>

include/swift/AST/DeclContext.h

@@ -82,6 +82,7 @@ namespace swift {
   class SerializedTopLevelCodeDecl;
   class StructDecl;
   class AccessorDecl;
+  class ClosureExpr;
 
   template <typename T>
   struct AvailableDuringLoweringDeclFilter;
@@ -504,6 +505,14 @@ class alignas(1 << DeclContextAlignInBits) DeclContext
         const_cast<DeclContext *>(this)->getInnermostSkippedFunctionContext();
   }
 
+  /// Returns the innermost context that is a ClosureExpr, which defines how
+  /// self behaves, unless within a type context that redefines self.
+  LLVM_READONLY
+  ClosureExpr *getInnermostClosureForSelfCapture();
+  const ClosureExpr *getInnermostClosureForSelfCapture() const {
+    return const_cast<DeclContext *>(this)->getInnermostClosureForSelfCapture();
+  }
+
   /// Returns the semantic parent of this context.  A context has a
   /// parent if and only if it is not a module context.
   DeclContext *getParent() const {

include/swift/AST/DistributedDecl.h

@@ -102,6 +102,29 @@ Type getDistributedActorSystemResultHandlerType(NominalTypeDecl *system);
 /// Get the 'ActorID' type of a specific distributed actor system.
 Type getDistributedActorSystemActorIDType(NominalTypeDecl *system);
 
+/// Retrieve a protocol conformance to the `Actor` protocol for a
+/// distributed actor type that is described via a substitution map for
+/// the generic signature `<T: DistributedActor>`.
+///
+/// The protocol conformance is a special one that is currently
+/// only used by the `distributedActorAsAnyActor` builtin.
+NormalProtocolConformance *
+getDistributedActorAsActorConformance(ASTContext &C);
+
+ProtocolConformanceRef
+getDistributedActorAsActorConformanceRef(ASTContext &C);
+
+/// Find the extension that defines the methods necessary for creating the
+/// the DistributedActor-as-Actor conformance.
+ExtensionDecl *
+findDistributedActorAsActorExtension(
+    ProtocolDecl *distributedActorProto, ModuleDecl *module);
+
+bool isDistributedActorAsLocalActorComputedProperty(VarDecl *var);
+
+/// Get the ``DistributedActor/asLocalActor`` computed property.
+VarDecl *getDistributedActorAsLocalActorComputedProperty(ModuleDecl *module);
+
 /// Check if the `allRequirements` represent *exactly* the
 /// `Encodable & Decodable` (also known as `Codable`) requirement.
 ///

include/swift/AST/Expr.h

@@ -4380,7 +4380,7 @@ struct CaptureListEntry {
   explicit CaptureListEntry(PatternBindingDecl *PBD);
 
   VarDecl *getVar() const;
-  bool isSimpleSelfCapture() const;
+  bool isSimpleSelfCapture(bool excludeWeakCaptures = true) const;
 };
 
 /// CaptureListExpr - This expression represents the capture list on an explicit

include/swift/AST/Stmt.h

@@ -709,9 +709,13 @@ class alignas(1 << PatternAlignInBits) StmtConditionElement {
   }
 
   /// Whether or not this conditional stmt rebinds self with a `let self`
-  /// or `let self = self` condition. If `requireLoadExpr` is `true`,
-  /// additionally requires that the RHS of the self condition is a `LoadExpr`.
-  bool rebindsSelf(ASTContext &Ctx, bool requireLoadExpr = false) const;
+  /// or `let self = self` condition.
+  ///  - If `requiresCaptureListRef` is `true`, additionally requires that the
+  ///    RHS of the self condition references a var defined in a capture list.
+  ///  - If `requireLoadExpr` is `true`, additionally requires that the RHS of
+  ///    the self condition is a `LoadExpr`.
+  bool rebindsSelf(ASTContext &Ctx, bool requiresCaptureListRef = false,
+                   bool requireLoadExpr = false) const;
 
   SourceLoc getStartLoc() const;
   SourceLoc getEndLoc() const;
@@ -817,9 +821,13 @@ class LabeledConditionalStmt : public LabeledStmt {
   StmtCondition *getCondPointer() { return &Cond; }
 
   /// Whether or not this conditional stmt rebinds self with a `let self`
-  /// or `let self = self` condition. If `requireLoadExpr` is `true`,
-  /// additionally requires that the RHS of the self condition is a `LoadExpr`.
-  bool rebindsSelf(ASTContext &Ctx, bool requireLoadExpr = false) const;
+  /// or `let self = self` condition.
+  ///  - If `requiresCaptureListRef` is `true`, additionally requires that the
+  ///    RHS of the self condition references a var defined in a capture list.
+  ///  - If `requireLoadExpr` is `true`, additionally requires that the RHS of
+  ///    the self condition is a `LoadExpr`.
+  bool rebindsSelf(ASTContext &Ctx, bool requiresCaptureListRef = false,
+                   bool requireLoadExpr = false) const;
 
   static bool classof(const Stmt *S) {
     return S->getKind() >= StmtKind::First_LabeledConditionalStmt &&

include/swift/AST/TypeCheckRequests.h

@@ -1138,6 +1138,25 @@ class CanSynthesizeDistributedActorCodableConformanceRequest :
     bool isCached() const { return true; }
 };
 
+/// Get a special conformance of the DistributedActor protocol to the Actor protocol.
+class GetDistributedActorAsActorConformanceRequest
+    : public SimpleRequest<GetDistributedActorAsActorConformanceRequest,
+                           NormalProtocolConformance *(ProtocolDecl *),
+                           RequestFlags::Cached> {
+  public:
+    using SimpleRequest::SimpleRequest;
+
+private:
+    friend SimpleRequest;
+
+    NormalProtocolConformance *
+    evaluate(Evaluator &evaluator, ProtocolDecl *distributedActorProto) const;
+
+  public:
+    // Caching
+    bool isCached() const { return true; }
+};
+
 /// Retrieve the implicit conformance for the given distributed actor type to
 /// the Codable protocol protocol.
 ///

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -118,11 +118,14 @@ SWIFT_REQUEST(TypeChecker, CheckDistributedFunctionRequest,
 SWIFT_REQUEST(TypeChecker, IsDistributedActorRequest, bool(NominalTypeDecl *),
               Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, GetDistributedActorImplicitCodableRequest,
-               NormalProtocolConformance *(NominalTypeDecl *, KnownProtocolKind),
-               Cached, NoLocationInfo)
+              NormalProtocolConformance *(NominalTypeDecl *, KnownProtocolKind),
+              Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, CanSynthesizeDistributedActorCodableConformanceRequest,
-               bool (NominalTypeDecl *),
-               Cached, NoLocationInfo)
+              bool (NominalTypeDecl *),
+              Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, GetDistributedActorAsActorConformanceRequest,
+              NormalProtocolConformance *(ProtocolDecl *),
+              Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, GetDistributedActorSystemRemoteCallFunctionRequest,
               AbstractFunctionDecl *(NominalTypeDecl *, bool),
               Cached, NoLocationInfo)

include/swift/Sema/ConstraintSystem.h

@@ -4406,7 +4406,7 @@ class ConstraintSystem {
   /// \param UseDC The context of the access.  Some variables have different
   ///   types depending on where they are used.
   ///
-  /// \param memberLocator The locator anchored at this value reference, when
+  /// \param locator The locator anchored at this value reference, when
   /// it is a member reference.
   ///
   /// \param wantInterfaceType Whether we want the interface type, if available.
@@ -4424,7 +4424,7 @@ class ConstraintSystem {
   /// \param UseDC The context of the access.  Some variables have different
   ///   types depending on where they are used.
   ///
-  /// \param memberLocator The locator anchored at this value reference, when
+  /// \param locator The locator anchored at this value reference, when
   /// it is a member reference.
   ///
   /// \param wantInterfaceType Whether we want the interface type, if available.

lib/AST/DeclContext.cpp

@@ -263,6 +263,25 @@ DeclContext *DeclContext::getInnermostSkippedFunctionContext() {
   return nullptr;
 }
 
+ClosureExpr *DeclContext::getInnermostClosureForSelfCapture() {
+  auto dc = this;
+  if (auto closure = dyn_cast<ClosureExpr>(dc)) {
+    return closure;
+  }
+
+  // Stop searching if we find a type decl, since types always
+  // redefine what 'self' means, even when nested inside a closure.
+  if (dc->isTypeContext()) {
+    return nullptr;
+  }
+
+  if (auto parent = dc->getParent()) {
+    return parent->getInnermostClosureForSelfCapture();
+  }
+
+  return nullptr;
+}
+
 DeclContext *DeclContext::getParentForLookup() const {
   if (isa<ExtensionDecl>(this)) {
     // If we are inside an extension, skip directly

lib/AST/DistributedDecl.cpp

@@ -61,7 +61,7 @@
 using namespace swift;
 
 /******************************************************************************/
-/************* Implicit Distributed Actor Codable Conformance *****************/
+/******************* Distributed Actor Conformances ***************************/
 /******************************************************************************/
 
 bool swift::canSynthesizeDistributedActorCodableConformance(NominalTypeDecl *actor) {
@@ -76,6 +76,68 @@ bool swift::canSynthesizeDistributedActorCodableConformance(NominalTypeDecl *act
       false);
 }
 
+ExtensionDecl *
+swift::findDistributedActorAsActorExtension(
+    ProtocolDecl *distributedActorProto, ModuleDecl *module) {
+  ASTContext &C = distributedActorProto->getASTContext();
+  auto name = C.getIdentifier("__actorUnownedExecutor");
+  auto results = distributedActorProto->lookupDirect(
+      name, SourceLoc(),
+      NominalTypeDecl::LookupDirectFlags::IncludeAttrImplements);
+  for (auto result : results) {
+    if (auto var = dyn_cast<VarDecl>(result)) {
+      return dyn_cast<ExtensionDecl>(var->getDeclContext());
+    }
+  }
+
+  return nullptr;
+}
+
+bool swift::isDistributedActorAsLocalActorComputedProperty(VarDecl *var) {
+  auto &C = var->getASTContext();
+  return var->getName() == C.Id_asLocalActor &&
+         var->getDeclContext()->getSelfProtocolDecl() &&
+         var->getDeclContext()->getSelfProtocolDecl()->isSpecificProtocol(
+             KnownProtocolKind::DistributedActor);
+}
+
+VarDecl *
+swift::getDistributedActorAsLocalActorComputedProperty(ModuleDecl *module) {
+  auto &C = module->getASTContext();
+  auto DA = C.getDistributedActorDecl();
+  auto extension = findDistributedActorAsActorExtension(DA, module);
+
+  if (!extension)
+    return nullptr;
+
+  for (auto decl : extension->getMembers()) {
+    if (auto var = dyn_cast<VarDecl>(decl)) {
+      if (isDistributedActorAsLocalActorComputedProperty(var)) {
+        return var;
+      }
+    }
+  }
+
+  return nullptr;
+}
+
+ProtocolConformanceRef
+swift::getDistributedActorAsActorConformanceRef(ASTContext &C) {
+  auto distributedActorAsActorConformance =
+      getDistributedActorAsActorConformance(C);
+
+  auto actorProto = C.getProtocol(KnownProtocolKind::Actor);
+  return ProtocolConformanceRef(actorProto, distributedActorAsActorConformance);
+}
+NormalProtocolConformance *
+swift::getDistributedActorAsActorConformance(ASTContext &C) {
+  auto distributedActorProtocol = C.getProtocol(KnownProtocolKind::DistributedActor);
+
+  return evaluateOrDefault(
+      C.evaluator,
+      GetDistributedActorAsActorConformanceRequest{distributedActorProtocol},
+      nullptr);
+}
 
 /******************************************************************************/
 /************** Distributed Actor System Associated Types *********************/

lib/AST/Expr.cpp

@@ -1353,22 +1353,29 @@ VarDecl *CaptureListEntry::getVar() const {
   return PBD->getSingleVar();
 }
 
-bool CaptureListEntry::isSimpleSelfCapture() const {
+bool CaptureListEntry::isSimpleSelfCapture(bool excludeWeakCaptures) const {
   auto *Var = getVar();
   auto &ctx = Var->getASTContext();
 
   if (Var->getName() != ctx.Id_self)
     return false;
 
-  if (auto *attr = Var->getAttrs().getAttribute<ReferenceOwnershipAttr>())
-    if (attr->get() == ReferenceOwnership::Weak)
-      return false;
-
   if (PBD->getPatternList().size() != 1)
     return false;
 
   auto *expr = PBD->getInit(0);
 
+  if (auto *attr = Var->getAttrs().getAttribute<ReferenceOwnershipAttr>()) {
+    if (attr->get() == ReferenceOwnership::Weak && excludeWeakCaptures) {
+      return false;
+    }
+  }
+
+  // Look through any ImplicitConversionExpr that may contain the DRE
+  if (auto conversion = dyn_cast_or_null<ImplicitConversionExpr>(expr)) {
+    expr = conversion->getSubExpr();
+  }
+
   if (auto *DRE = dyn_cast<DeclRefExpr>(expr)) {
     if (auto *VD = dyn_cast<VarDecl>(DRE->getDecl())) {
       return VD->getName() == ctx.Id_self;

lib/AST/ProtocolConformance.cpp

@@ -1142,9 +1142,40 @@ void NominalTypeDecl::prepareConformanceTable() const {
   }
 }
 
+/// Handle special cased protocol-to-protocol conformances, such as e.g.
+/// DistributedActor-to-Actor.
+///
+/// \returns true when the conformance lookup was handled successfully
+static bool lookupSpecialProtocolToProtocolConformance(
+    const ProtocolDecl *thisProtocol, ProtocolDecl *toProtocol,
+    SmallVectorImpl<ProtocolConformance *> &conformances) {
+  auto &C = toProtocol->getASTContext();
+
+  // DistributedActor-to-Actor
+  if (thisProtocol->isSpecificProtocol(KnownProtocolKind::DistributedActor) &&
+      toProtocol->isSpecificProtocol(KnownProtocolKind::Actor)) {
+    if (auto conformance = getDistributedActorAsActorConformance(C)) {
+      conformances.push_back(conformance);
+      return true;
+    }
+  }
+
+  return false;
+}
+
 bool NominalTypeDecl::lookupConformance(
        ProtocolDecl *protocol,
        SmallVectorImpl<ProtocolConformance *> &conformances) const {
+
+  // In general, protocols cannot conform to other protocols, however there are
+  // exceptions, special handle those.
+  if (auto thisProtocol = dyn_cast<ProtocolDecl>(this)) {
+    if (lookupSpecialProtocolToProtocolConformance(thisProtocol, protocol,
+                                                   conformances)) {
+      return true;
+    }
+  }
+
   assert(!isa<ProtocolDecl>(this) &&
          "Self-conformances are only found by the higher-level "
          "ModuleDecl::lookupConformance() entry point");
@@ -1187,7 +1218,7 @@ void NominalTypeDecl::getImplicitProtocols(
 }
 
 void NominalTypeDecl::registerProtocolConformance(
-       NormalProtocolConformance *conformance, bool synthesized) {
+    NormalProtocolConformance *conformance, bool synthesized) {
   prepareConformanceTable();
   auto *dc = conformance->getDeclContext();
   ConformanceTable->registerProtocolConformance(dc, conformance, synthesized);