[Distributed] remove unused code

Author: ktoso

include/swift/SILOptimizer/Utils/DistributedActor.h

@@ -51,14 +51,6 @@ void emitDistributedActorSystemWitnessCall(
     llvm::Optional<std::pair<SILBasicBlock *, SILBasicBlock *>> tryTargets =
         llvm::None);
 
-/// Emit a call to a witness of the passed 'proto' protocol.
-void emitDistributedWitnessCall(
-    SILBuilder &B, SILLocation loc, DeclName methodName,
-    SILValue base, ProtocolDecl *proto, SILType actorType,
-    llvm::ArrayRef<SILValue> args,
-    llvm::Optional<std::pair<SILBasicBlock *, SILBasicBlock *>> tryTargets =
-        llvm::None);
-
 /// Emits code that notifies the distributed actor's actorSystem that the
 /// actor is ready for execution.
 /// \param B the builder to use when emitting the code.

lib/AST/SubstitutionMap.cpp

@@ -44,6 +44,7 @@ SubstitutionMap::Storage::Storage(
   : genericSig(genericSig),
     numConformanceRequirements(genericSig->getNumConformanceRequirements())
 {
+  assert(replacementTypes.size() == getNumReplacementTypes());
   assert(conformances.size() == numConformanceRequirements);
 
   std::copy(replacementTypes.begin(), replacementTypes.end(),

lib/SILGen/SILGenDistributed.cpp

@@ -92,6 +92,7 @@ static void initializeProperty(SILGenFunction &SGF, SILLocation loc,
 /********************* COMMON CONFORMANCE SIL PATTERNS ************************/
 /******************************************************************************/
 
+// FIXME(distributed): should be implemented by getting the SerializationRequirement
 static void getSerializationRequirements(
     SILGenFunction &SGF, ASTContext &ctx, NominalTypeDecl actorDecl,
     SmallVectorImpl<ProtocolDecl *> &requirementProtocolDecls) {
@@ -104,30 +105,15 @@ static void getSerializationRequirements(
   requirementProtocolDecls.push_back(decodableDecl);
 }
 
-// FIXME: this isn't actually implemented
+// FIXME(distributed): this isn't actually implemented
 static void pushSerializationRequirementConformance(
     SILGenFunction &SGF, ASTContext &ctx,
     SILType type,
     SmallVectorImpl<Type> &subTypes,
     SmallVectorImpl<ProtocolConformanceRef> &subConformances) {
   auto &B = SGF.B;
-  auto module = B.getModule().getSwiftModule();
 
-  //        auto resultEncodableTypeConfRef =
-  //            module->lookupConformance(resultType.getASTType(),
-  //                                      encodableRequirementTy);
-  //        assert(!distributedActorConfRef.isInvalid() &&
-  //               "Missing conformance to `SerializationRequirement`");
   subTypes.push_back(type.getASTType());
-  //        subConformances.push_back(resultEncodableTypeConfRef);
-
-  //        auto decodableRequirementTy =
-  //            ctx.getProtocol(KnownProtocolKind::Decodable);
-  //        auto resultDecodableTypeConfRef =
-  //            module->lookupConformance(resultType.getASTType(),
-  //                                      encodableRequirementTy);
-  //        subTypes.push_back(resultType.getASTType());
-  //        subConformances.push_back(resultDecodableTypeConfRef);
 }
 
 /// Push `Type` and `ProtocolConformanceRef` for the `Error` protocol to

lib/SILOptimizer/Utils/DistributedActor.cpp

@@ -210,157 +210,6 @@ void emitDistributedActorSystemWitnessCall(
   }
 }
 
-void emitDistributedWitnessCall(
-    SILBuilder &B, SILLocation loc, DeclName methodName,
-    SILValue base, ProtocolDecl *proto, SILType actorType,
-    llvm::ArrayRef<SILValue> args,
-    llvm::Optional<std::pair<SILBasicBlock *, SILBasicBlock *>> tryTargets) {
-  auto &F = B.getFunction();
-  auto &M = B.getModule();
-  auto &C = F.getASTContext();
-
-  // Dig out the conformance to the passed in protocol.
-  auto astType = base->getType().getASTType();
-  auto *module = M.getSwiftModule();
-  ProtocolConformanceRef confRef;
-
-  // If the base is an existential open it.
-  if (astType->isAnyExistentialType()) {
-    OpenedArchetypeType *opened;
-    astType = astType->openAnyExistentialType(opened)->getCanonicalType();
-    base = B.createOpenExistentialAddr(
-        loc, base, F.getLoweredType(astType),
-        OpenedExistentialAccess::Immutable);
-  }
-
-  if (astType->isTypeParameter() || astType->is<ArchetypeType>()) {
-    confRef = ProtocolConformanceRef(proto);
-  } else {
-    confRef = module->lookupConformance(astType, proto);
-  }
-
-  assert(!confRef.isInvalid() &&
-         "Missing conformance to `DistributedActorSystem`");
-
-  // Dig out the method.
-  auto method = cast<FuncDecl>(proto->getSingleRequirement(methodName));
-  auto methodRef = SILDeclRef(method, SILDeclRef::Kind::Func);
-  auto methodSILTy =
-      M.Types.getConstantInfo(B.getTypeExpansionContext(), methodRef)
-          .getSILType();
-
-  auto witnessMethod = B.createWitnessMethod(
-      loc, astType, confRef, methodRef, methodSILTy);
-
-  // prepare conformance substitutions
-  SubstitutionMap subs;
-  {
-    auto genericSig = method->getGenericSignature();
-    SmallVector<Type, 2> subTypes;
-    SmallVector<ProtocolConformanceRef, 2> subConformances;
-    subTypes.push_back(astType);
-    subConformances.push_back(confRef);
-    if (actorType) {
-      ProtocolDecl *actorProto = C.getProtocol(
-          KnownProtocolKind::DistributedActor);
-      assert(actorProto);
-
-      ProtocolConformanceRef conformance;
-      auto distributedActorConfRef = module->lookupConformance(
-          actorType.getASTType(), actorProto);
-      assert(!distributedActorConfRef.isInvalid() &&
-             "Missing conformance to `DistributedActor`");
-      subTypes.push_back(actorType.getASTType());
-      subConformances.push_back(distributedActorConfRef);
-    }
-
-    subs = SubstitutionMap::get(genericSig, subTypes, subConformances);
-  }
-
-  Optional<SILValue> temporaryActorIDBuffer;
-
-  // If the self parameter is indirect but the actorSystem is a value, put it
-  // into a temporary allocation.
-  auto methodSILFnTy = methodSILTy.castTo<SILFunctionType>();
-  Optional<SILValue> temporaryInvocationBuffer;
-  if (methodSILFnTy->getSelfParameter().isFormalIndirect() &&
-      !base->getType().isAddress()) {
-    auto buf = B.createAllocStack(loc, base->getType(), None);
-    base = B.emitCopyValueOperation(loc, base);
-    B.emitStoreValueOperation(
-        loc, base, buf, StoreOwnershipQualifier::Init);
-    temporaryInvocationBuffer = SILValue(buf);
-  }
-
-  // === Call the method.
-  // --- Push the arguments
-  SmallVector<SILValue, 2> allArgs;
-  auto params = methodSILFnTy->getParameters();
-  for (size_t i = 0; i < args.size(); ++i) {
-    auto arg = args[i];
-    if (params[i].isFormalIndirect() &&
-        !arg->getType().isAddress() &&
-        !dyn_cast<AnyMetatypeType>(arg->getType().getASTType())) {
-      auto buf = B.createAllocStack(loc, arg->getType(), None);
-      auto argCopy = B.emitCopyValueOperation(loc, arg);
-      B.emitStoreValueOperation(
-          loc, argCopy, buf, StoreOwnershipQualifier::Init);
-      temporaryActorIDBuffer = SILValue(buf);
-      allArgs.push_back(*temporaryActorIDBuffer);
-    } else {
-      allArgs.push_back(arg);
-    }
-  }
-  // Push the self argument
-  auto selfArg = temporaryInvocationBuffer ? *temporaryInvocationBuffer : base;
-  allArgs.push_back(selfArg);
-
-  SILInstruction *apply;
-  if (tryTargets) {
-    apply = B.createTryApply(
-        loc, witnessMethod, subs, allArgs, tryTargets->first,
-        tryTargets->second);
-  } else {
-    apply = B.createApply(loc, witnessMethod, subs, allArgs);
-  }
-
-  // Local function to emit a cleanup after the call.
-  auto emitCleanup = [&](llvm::function_ref<void(SILBuilder &builder)> fn) {
-    if (tryTargets) {
-      {
-        SILBuilderWithScope normalBuilder(tryTargets->first, apply);
-        fn(normalBuilder);
-      }
-      {
-        SILBuilderWithScope errorBuilder(tryTargets->second, apply);
-        fn(errorBuilder);
-      }
-    } else {
-      fn(B);
-    }
-  };
-
-  // ==== If we had to create a buffers we need to clean them up
-  // --- Cleanup id buffer
-  if (temporaryActorIDBuffer) {
-    emitCleanup([&](SILBuilder & builder) {
-      auto value = builder.emitLoadValueOperation(
-          loc, *temporaryActorIDBuffer, LoadOwnershipQualifier::Take);
-      builder.emitDestroyValueOperation(loc, value);
-      builder.createDeallocStack(loc, *temporaryActorIDBuffer);
-    });
-  }
-  // --- Cleanup actorSystem buffer
-  if (temporaryInvocationBuffer) {
-    emitCleanup([&](SILBuilder & builder) {
-      auto value = builder.emitLoadValueOperation(
-          loc, *temporaryInvocationBuffer, LoadOwnershipQualifier::Take);
-      builder.emitDestroyValueOperation(loc, value);
-      builder.createDeallocStack(loc, *temporaryInvocationBuffer);
-    });
-  }
-}
-
 void emitActorReadyCall(SILBuilder &B, SILLocation loc, SILValue actor,
                         SILValue actorSystem) {
 

test/Distributed/Runtime/distributed_actor_func_calls_remoteCall_take.swift

@@ -23,7 +23,6 @@ distributed actor Greeter {
   }
 }
 
-
 // ==== Fake Transport ---------------------------------------------------------
 struct ActorAddress: Sendable, Hashable, Codable {
   let address: String