[distributed] a number of ctor infra cleanups

1. We're no longer synthesizing the local
init. All designated inits of a dist actor
must have exactly one ActorTransport parameter.
This parameter is used in the init's prologue
to initialize some of its members.

2. We're synthesizing a factory function for
the resolve initialization, instead of an
actor-member named `init` to serve that
purpose.

As such, much of the earlier infrastructure
is no longer needed, etc.

Author: kavon

include/swift/AST/Decl.h

@@ -7003,18 +7003,6 @@ class ConstructorDecl : public AbstractFunctionDecl {
   /// \endcode
   bool isObjCZeroParameterWithLongSelector() const;
 
-  /// Checks if the initializer is a distributed actor's 'local' initializer:
-  /// ```
-  /// init(transport: ActorTransport)
-  /// ```
-  bool isDistributedActorLocalInit() const;
-
-  /// Checks if the initializer is a distributed actor's 'resolve' initializer:
-  /// ```
-  /// init(resolve address: ActorAddress, using transport: ActorTransport)
-  /// ```
-  bool isDistributedActorResolveInit() const;
-
   static bool classof(const Decl *D) {
     return D->getKind() == DeclKind::Constructor;
   }

include/swift/AST/TypeCheckRequests.h

@@ -1955,24 +1955,6 @@ class HasDefaultInitRequest
   bool isCached() const { return true; }
 };
 
-/// Checks whether this type has a distributed actor "local" initializer.
-class HasDistributedActorLocalInitRequest
-    : public SimpleRequest<HasDistributedActorLocalInitRequest, bool(NominalTypeDecl *),
-                           RequestFlags::Cached> {
-public:
-  using SimpleRequest::SimpleRequest;
-
-private:
-  friend SimpleRequest;
-
-  // Evaluation.
-  bool evaluate(Evaluator &evaluator, NominalTypeDecl *decl) const;
-
-public:
-  // Caching.
-  bool isCached() const { return true; }
-};
-
 /// Synthesizes a default initializer for a given type.
 class SynthesizeDefaultInitRequest
     : public SimpleRequest<SynthesizeDefaultInitRequest,

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -100,8 +100,6 @@ SWIFT_REQUEST(TypeChecker, IsDefaultActorRequest,
               Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, IsDistributedActorRequest, bool(NominalTypeDecl *),
               Cached, NoLocationInfo)
-SWIFT_REQUEST(TypeChecker, HasDistributedActorLocalInitRequest,
-              bool(NominalTypeDecl *), Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, IsDistributedFuncRequest, bool(FuncDecl *),
               Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, GlobalActorInstanceRequest,

lib/AST/Decl.cpp

@@ -8060,45 +8060,6 @@ bool ConstructorDecl::isObjCZeroParameterWithLongSelector() const {
   return params->get(0)->getInterfaceType()->isVoid();
 }
 
-bool ConstructorDecl::isDistributedActorLocalInit() const {
-  auto name = getName();
-  auto argumentNames = name.getArgumentNames();
-
-  if (argumentNames.size() != 1)
-    return false;
-
-  auto &C = getASTContext();
-  if (argumentNames[0] != C.Id_transport)
-    return false;
-
-  auto *params = getParameters();
-  assert(params->size() == 1);
-
-  auto transportType = C.getActorTransportDecl()->getDeclaredInterfaceType();
-  return params->get(0)->getInterfaceType()->isEqual(transportType);
-}
-
-// TODO: remove resolve init in favor of resolve function?
-bool ConstructorDecl::isDistributedActorResolveInit() const {
-  auto name = getName();
-  auto argumentNames = name.getArgumentNames();
-
-  if (argumentNames.size() != 2)
-    return false;
-
-  auto &C = getASTContext();
-  if (argumentNames[0] != C.Id_resolve ||
-      argumentNames[1] != C.Id_using)
-    return false;
-
-  auto *params = getParameters();
-  auto identityType = C.getAnyActorIdentityDecl()->getDeclaredInterfaceType();
-  auto transportType = C.getActorTransportDecl()->getDeclaredInterfaceType();
-
-  return params->get(0)->getInterfaceType()->isEqual(identityType) &&
-         params->get(1)->getInterfaceType()->isEqual(transportType);
-}
-
 
 DestructorDecl::DestructorDecl(SourceLoc DestructorLoc, DeclContext *Parent)
   : AbstractFunctionDecl(DeclKind::Destructor, Parent,

lib/Sema/CodeSynthesis.cpp

@@ -1464,24 +1464,6 @@ HasDefaultInitRequest::evaluate(Evaluator &evaluator,
   return areAllStoredPropertiesDefaultInitializable(evaluator, decl);
 }
 
-bool
-HasDistributedActorLocalInitRequest::evaluate(Evaluator &evaluator,
-                                                     NominalTypeDecl *nominal) const {
-  if (auto *decl = dyn_cast<ClassDecl>(nominal)) {
-    if (!decl->isDistributedActor())
-      return false;
-
-    for (auto *member : decl->getMembers())
-      if (auto ctor = dyn_cast<ConstructorDecl>(member))
-        if (ctor->isDistributedActorLocalInit())
-          return true;
-  }
-
-  // areAllStoredPropertiesDefaultInitializable(evaluator, decl);
-
-  return false;
-}
-
 /// Synthesizer callback for a function body consisting of "return".
 static std::pair<BraceStmt *, bool>
 synthesizeSingleReturnFunctionBody(AbstractFunctionDecl *afd, void *) {

lib/Sema/CodeSynthesisDistributedActor.cpp

@@ -1,8 +1,8 @@
-//===--- CodeSynthesis.cpp - Type Checking for Declarations ---------------===//
+//===--- CodeSynthesisDistributedActor.cpp --------------------------------===//
 //
 // This source file is part of the Swift.org open source project
 //
-// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Copyright (c) 2014 - 2021 Apple Inc. and the Swift project authors
 // Licensed under Apache License v2.0 with Runtime Library Exception
 //
 // See https://swift.org/LICENSE.txt for license information
@@ -12,21 +12,15 @@
 
 #include "TypeCheckDistributed.h"
 
-#include "CodeSynthesis.h"
 
 #include "TypeChecker.h"
-#include "TypeCheckDecl.h"
-#include "TypeCheckObjC.h"
 #include "TypeCheckType.h"
 #include "swift/AST/ASTPrinter.h"
 #include "swift/AST/Availability.h"
 #include "swift/AST/Expr.h"
 #include "swift/AST/GenericEnvironment.h"
 #include "swift/AST/Initializer.h"
 #include "swift/AST/ParameterList.h"
-#include "swift/AST/PrettyStackTrace.h"
-#include "swift/AST/ProtocolConformance.h"
-#include "swift/AST/SourceFile.h"
 #include "swift/AST/TypeCheckRequests.h"
 #include "swift/Basic/Defer.h"
 #include "swift/ClangImporter/ClangModule.h"
@@ -40,6 +34,76 @@ using namespace swift;
 /******************************* INITIALIZERS *********************************/
 /******************************************************************************/
 
+/// Synthesizes the
+///
+/// \verbatim
+/// actor A {
+///   static resolve(_ address: ActorAddress,
+///                  using transport: ActorTransport) throws -> Self
+/// }
+/// \endverbatim
+///
+/// factory function in the AST, with an empty body. It's body is
+/// expected to be filled-in during SILGen.
+static void addFactoryResolveFunction(ClassDecl *decl) {
+  assert(decl->isDistributedActor());
+  auto &ctx = decl->getASTContext();
+
+  {
+    auto &C = ctx;
+    auto conformanceDC = decl;
+
+    // Expected type: (Self) -> (ActorAddress, ActorTransport) -> (Self)
+    //
+    // Param: (resolve address: AnyActorAddress)
+    auto addressType = C.getAnyActorIdentityDecl()->getDeclaredInterfaceType();
+    auto *idParamDecl = new (C) ParamDecl(
+        SourceLoc(), SourceLoc(), C.Id_resolve,
+        SourceLoc(), C.Id_id, conformanceDC);
+    idParamDecl->setImplicit();
+    idParamDecl->setSpecifier(ParamSpecifier::Default);
+    idParamDecl->setInterfaceType(addressType);
+
+    // Param: (using transport: ActorTransport)
+    auto transportType = C.getActorTransportDecl()->getDeclaredInterfaceType();
+    auto *transportParamDecl = new (C) ParamDecl(
+        SourceLoc(), SourceLoc(), C.Id_using,
+        SourceLoc(), C.Id_transport, conformanceDC);
+    transportParamDecl->setImplicit();
+    transportParamDecl->setSpecifier(ParamSpecifier::Default);
+    transportParamDecl->setInterfaceType(transportType);
+
+    auto *paramList = ParameterList::create(
+        C,
+        /*LParenLoc=*/SourceLoc(),
+        /*params=*/{idParamDecl, transportParamDecl},
+        /*RParenLoc=*/SourceLoc()
+        );
+
+    // Func name: init(resolve:using:)
+    DeclName name(C, DeclBaseName::createConstructor(), paramList);
+
+    auto *initDecl =
+        new (C) ConstructorDecl(name, SourceLoc(),
+                                /*Failable=*/false, SourceLoc(),
+                                /*Async=*/false, SourceLoc(),
+                                /*Throws=*/true, SourceLoc(),
+                                paramList,
+                                /*GenericParams=*/nullptr, conformanceDC);
+    initDecl->setImplicit();
+    // TODO: determine how to mark this as being synthesized by SILGen.
+//    initDecl->setSynthesized();
+//    initDecl->setBodySynthesizer(&createDistributedActor_init_resolve_body);
+
+    auto *nonIsoAttr = new (C) NonisolatedAttr(/*IsImplicit*/true);
+    initDecl->getAttrs().add(nonIsoAttr);
+
+    initDecl->copyFormalAccessFrom(decl, /*sourceIsParentContext=*/true);
+
+    decl->addMember(initDecl);
+  }
+}
+
 /// Synthesizes an empty body of the `init(transport:)` initializer as:
 ///
 /// ```
@@ -449,6 +513,7 @@ void swift::addImplicitDistributedActorMembersToClass(ClassDecl *decl) {
   if (!swift::ensureDistributedModuleLoaded(decl))
     return;
 
+  addFactoryResolveFunction(decl);
   addImplicitDistributedActorStoredProperties(decl);
   addImplicitRemoteActorFunctions(decl);
 //  addImplicitResignIdentity(decl);

lib/Sema/TypeCheckDecl.cpp

@@ -445,14 +445,6 @@ InitKindRequest::evaluate(Evaluator &evaluator, ConstructorDecl *decl) const {
       }
     }
 
-    // the init(transport:) initializer of a distributed actor is special, as
-    // it ties the actors lifecycle with the transport. As such, it must always
-    // be invoked by any other initializer, just like a designated initializer.
-    if (auto clazz = dyn_cast<ClassDecl>(decl->getDeclContext())) {
-      if (clazz->isDistributedActor() && decl->isDistributedActorLocalInit())
-        return CtorInitializerKind::Designated;
-    }
-
     if (decl->getDeclContext()->getExtendedProtocolDecl()) {
       return CtorInitializerKind::Convenience;
     }

lib/Sema/TypeCheckStmt.cpp

@@ -17,6 +17,7 @@
 #include "TypeChecker.h"
 #include "TypeCheckAvailability.h"
 #include "TypeCheckConcurrency.h"
+#include "TypeCheckDistributed.h"
 #include "TypeCheckType.h"
 #include "MiscDiagnostics.h"
 #include "swift/Subsystems.h"
@@ -2038,7 +2039,6 @@ TypeCheckFunctionBodyRequest::evaluate(Evaluator &evaluator,
   // Class constructor checking.
   if (auto *ctor = dyn_cast<ConstructorDecl>(AFD)) {
     if (auto classDecl = ctor->getDeclContext()->getSelfClassDecl()) {
-      // checkActorConstructor(classDecl, ctor);
       checkClassConstructorBody(classDecl, ctor, body);
     }
   }

stdlib/public/Distributed/DistributedActor.swift

@@ -36,7 +36,6 @@ public protocol AnyActor: AnyObject {}
 public protocol DistributedActor:
     AnyActor,
     Identifiable, Hashable, Codable {
-
     /// Resolves the passed in `identity` against the `transport`, returning
     /// either a local or remote actor reference.
     ///
@@ -74,23 +73,6 @@ public protocol DistributedActor:
     nonisolated var id: AnyActorIdentity { get }
 }
 
-@available(SwiftStdlib 5.5, *)
-extension DistributedActor {
-
-  public static func resolve<Identity>(_ identity: Identity, using transport: ActorTransport)
-      throws -> Self where Identity: ActorIdentity {
-    switch try transport.resolve(AnyActorIdentity(identity), as: Self.self) {
-    case .resolved(let instance):
-      return instance
-
-    case .makeProxy:
-      // FIXME: this needs actual implementation of distributedActorRemoteCreate
-      let remote: Any = distributedActorRemoteCreate(identity: identity, transport: transport)
-      return remote as! Self
-    }
-  }
-}
-
 // ==== Hashable conformance ---------------------------------------------------
 
 @available(SwiftStdlib 5.5, *)