Merge pull request swiftlang#36315 from slavapestov/uncurried-cleanup

SILGen: Eliminate 'uncurriedSites' from SILGenApply.cpp

Author: slavapestov

lib/SIL/IR/SILFunctionType.cpp

@@ -3135,7 +3135,7 @@ static bool isImporterGeneratedAccessor(const clang::Decl *clangDecl,
     return false;
 
   // Must be a type member.
-  if (constant.getParameterListCount() != 2)
+  if (!accessor->hasImplicitSelfDecl())
     return false;
 
   // Must be imported from a function.

lib/SILGen/SILGenApply.cpp

@@ -504,24 +504,6 @@ class Callee {
     return SubstFormalInterfaceType;
   }
 
-  unsigned getParameterListCount() const {
-    switch (kind) {
-    case Kind::IndirectValue:
-      return 1;
-
-    case Kind::StandaloneFunction:
-    case Kind::StandaloneFunctionDynamicallyReplaceableImpl:
-    case Kind::EnumElement:
-    case Kind::ClassMethod:
-    case Kind::SuperMethod:
-    case Kind::WitnessMethod:
-    case Kind::DynamicMethod:
-      return Constant.getParameterListCount();
-    }
-
-    llvm_unreachable("Unhandled Kind in switch.");
-  }
-
   bool requiresSelfValueForDispatch() const {
     switch (kind) {
     case Kind::IndirectValue:
@@ -847,22 +829,23 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
     selfParam = std::move(theSelfParam);
   }
 
-  bool isSelfApplyOfMethod(ApplyExpr *e) {
-    if (auto *selfApply = dyn_cast<ApplyExpr>(e->getFn())) {
-      if (auto *declRefExpr = dyn_cast<DeclRefExpr>(selfApply->getFn()))
-        return declRefExpr->getDecl()->getNumCurryLevels() == 2;
-
-      if (isa<OtherConstructorDeclRefExpr>(selfApply->getFn()))
-        return true;
-    }
-
-    return false;
+  bool isMethodSelfApply(Expr *e) {
+    return (isa<SelfApplyExpr>(e) &&
+            !isa<AutoClosureExpr>(
+              cast<SelfApplyExpr>(e)->getFn()));
   }
 
   void decompose(ApplyExpr *e) {
+    if (isMethodSelfApply(e)) {
+      selfApply = e;
+
+      visit(selfApply->getFn());
+      return;
+    }
+
     callSite = e;
 
-    if (isSelfApplyOfMethod(e)) {
+    if (isMethodSelfApply(e->getFn())) {
       selfApply = cast<ApplyExpr>(e->getFn());
 
       if (selfApply->isSuper()) {
@@ -3659,10 +3642,11 @@ namespace {
 class CallEmission {
   SILGenFunction &SGF;
 
-  std::vector<CallSite> uncurriedSites;
+  Optional<CallSite> selfArg;
+  Optional<CallSite> callSite;
+
   Callee callee;
   FormalEvaluationScope initialWritebackScope;
-  unsigned expectedSiteCount;
   bool implicitlyAsync;
 
 public:
@@ -3671,7 +3655,6 @@ class CallEmission {
                FormalEvaluationScope &&writebackScope)
       : SGF(SGF), callee(std::move(callee)),
         initialWritebackScope(std::move(writebackScope)),
-        expectedSiteCount(callee.getParameterListCount()),
         implicitlyAsync(false) {}
 
   /// A factory method for decomposing the apply expr \p e into a call
@@ -3682,8 +3665,8 @@ class CallEmission {
   /// unevaluated arguments and their formal type.
   void addCallSite(CallSite &&site) {
     // Append to the main argument list if we have uncurry levels remaining.
-    assert(uncurriedSites.size() < expectedSiteCount);
-    uncurriedSites.push_back(std::move(site));
+    assert(!callSite.hasValue());
+    callSite = std::move(site);
   }
 
   /// Add a level of function application by passing in its possibly
@@ -3694,12 +3677,14 @@ class CallEmission {
   }
 
   void addSelfParam(SILLocation loc,
-                    ArgumentSource &&selfArg,
+                    ArgumentSource &&self,
                     AnyFunctionType::Param selfParam) {
+    assert(!selfArg.hasValue());
+
     PreparedArguments preparedSelf(llvm::ArrayRef<AnyFunctionType::Param>{selfParam});
-    preparedSelf.addArbitrary(std::move(selfArg));
+    preparedSelf.addArbitrary(std::move(self));
 
-    addCallSite(loc, std::move(preparedSelf));
+    selfArg = CallSite(loc, std::move(preparedSelf));
   }
 
   /// Is this a fully-applied enum element constructor call?
@@ -3860,8 +3845,6 @@ SILGenFunction::emitBeginApply(SILLocation loc, ManagedValue fn,
 }
 
 RValue CallEmission::applyFirstLevelCallee(SGFContext C) {
-  assert(uncurriedSites.size() == expectedSiteCount);
-
   // Check for a specialized emitter.
   if (auto emitter = callee.getSpecializedEmitter(SGF.SGM)) {
     return applySpecializedEmitter(emitter.getValue(), C);
@@ -3882,9 +3865,6 @@ RValue CallEmission::applyNormalCall(SGFContext C) {
   auto formalType = callee.getSubstFormalType();
   auto origFormalType = callee.getOrigFormalType();
 
-  bool isCurried = (uncurriedSites.size() < callee.getParameterListCount());
-  assert(!isCurried);
-
   // Get the callee type information.
   auto calleeTypeInfo = callee.getTypeInfo(SGF);
 
@@ -3904,17 +3884,17 @@ RValue CallEmission::applyNormalCall(SGFContext C) {
   calleeTypeInfo.origResultType = origFormalType.getFunctionResultType();
   calleeTypeInfo.substResultType = formalType.getResult();
 
-  if (uncurriedSites.size() == 2) {
+  if (selfArg.hasValue() && callSite.hasValue()) {
     calleeTypeInfo.origResultType =
       calleeTypeInfo.origResultType->getFunctionResultType();
     calleeTypeInfo.substResultType =
       cast<FunctionType>(calleeTypeInfo.substResultType).getResult();
   }
 
   ResultPlanPtr resultPlan = ResultPlanBuilder::computeResultPlan(
-      SGF, calleeTypeInfo, uncurriedSites.back().Loc, uncurriedContext);
+      SGF, calleeTypeInfo, callSite->Loc, uncurriedContext);
 
-  ArgumentScope argScope(SGF, uncurriedSites.back().Loc);
+  ArgumentScope argScope(SGF, callSite->Loc);
 
   // Emit the arguments.
   SmallVector<ManagedValue, 4> uncurriedArgs;
@@ -3970,7 +3950,7 @@ RValue CallEmission::applyEnumElementConstructor(SGFContext C) {
   // construction.
   EnumElementDecl *element = callee.getEnumElementDecl();
 
-  SILLocation uncurriedLoc = uncurriedSites[0].Loc;
+  SILLocation uncurriedLoc = selfArg->Loc;
 
   origFormalType = origFormalType.getFunctionResultType();
   CanType formalResultType = formalType.getResult();
@@ -3980,21 +3960,20 @@ RValue CallEmission::applyEnumElementConstructor(SGFContext C) {
   emitPseudoFunctionArguments(SGF,
                               AbstractionPattern(formalType),
                               formalType, metatypeVal,
-                              std::move(uncurriedSites[0]).forward());
+                              std::move(*selfArg).forward());
   assert(metatypeVal.size() == 1);
 
 
   // Get the payload argument.
   ArgumentSource payload;
   if (element->hasAssociatedValues()) {
-    assert(uncurriedSites.size() == 2);
     SmallVector<ManagedValue, 4> argVals;
     auto resultFnType = cast<FunctionType>(formalResultType);
 
     emitPseudoFunctionArguments(SGF,
                                 AbstractionPattern(resultFnType),
                                 resultFnType, argVals,
-                                std::move(uncurriedSites[1]).forward());
+                                std::move(*callSite).forward());
 
     auto payloadTy = AnyFunctionType::composeInput(SGF.getASTContext(),
                                                   resultFnType.getParams(),
@@ -4004,7 +3983,7 @@ RValue CallEmission::applyEnumElementConstructor(SGFContext C) {
     formalResultType = cast<FunctionType>(formalResultType).getResult();
     origFormalType = origFormalType.getFunctionResultType();
   } else {
-    assert(uncurriedSites.size() == 1);
+    assert(!callSite.hasValue());
   }
 
   ManagedValue resultMV = SGF.emitInjectEnum(
@@ -4038,13 +4017,13 @@ CallEmission::applySpecializedEmitter(SpecializedEmitter &specializedEmitter,
   if (specializedEmitter.isEarlyEmitter()) {
     auto emitter = specializedEmitter.getEarlyEmitter();
 
-    assert(uncurriedSites.size() == 1);
+    assert(!selfArg.hasValue());
     assert(!formalType->getExtInfo().isThrowing());
-    SILLocation uncurriedLoc = uncurriedSites[0].Loc;
+    SILLocation uncurriedLoc = callSite->Loc;
 
     // We should be able to enforce that these arguments are
     // always still expressions.
-    PreparedArguments args = std::move(uncurriedSites[0]).forward();
+    PreparedArguments args = std::move(*callSite).forward();
     ManagedValue resultMV =
         emitter(SGF, uncurriedLoc, callee.getSubstitutions(),
                 std::move(args), uncurriedContext);
@@ -4054,7 +4033,7 @@ CallEmission::applySpecializedEmitter(SpecializedEmitter &specializedEmitter,
   Optional<ResultPlanPtr> resultPlan;
   Optional<ArgumentScope> argScope;
   Optional<CalleeTypeInfo> calleeTypeInfo;
-  SILLocation loc = uncurriedSites[0].Loc;
+  SILLocation loc = callSite->Loc;
   SILFunctionConventions substConv(substFnType, SGF.SGM.M);
 
   // If we have a named builtin and have an indirect out parameter, compute a
@@ -4148,18 +4127,18 @@ ApplyOptions CallEmission::emitArgumentsForNormalApply(
   SmallVector<SmallVector<ManagedValue, 4>, 2> args;
   SmallVector<DelayedArgument, 2> delayedArgs;
 
-  args.reserve(uncurriedSites.size());
+  args.reserve(selfArg.hasValue() ? 2 : 1);
   {
     ParamLowering paramLowering(substFnType, SGF);
 
     assert((!foreign.error && !foreign.async)
-           || uncurriedSites.size() == 1
-           || (uncurriedSites.size() == 2 && substFnType->hasSelfParam()));
+           || !selfArg.hasValue()
+           || (selfArg.hasValue() && substFnType->hasSelfParam()));
 
-    if (uncurriedSites.back().isNoThrows()) {
+    if (callSite->isNoThrows()) {
       options |= ApplyFlags::DoesNotThrow;
     }
-    if (uncurriedSites.back().isNoAsync()) {
+    if (callSite->isNoAsync()) {
       options |= ApplyFlags::DoesNotAwait;
     }
 
@@ -4172,27 +4151,30 @@ ApplyOptions CallEmission::emitArgumentsForNormalApply(
     }
 
     // Collect the arguments to the uncurried call.
-    for (auto &site : uncurriedSites) {
-      uncurriedLoc = site.Loc;
+    if (selfArg.hasValue()) {
       args.push_back({});
-
-      bool isParamSite = &site == &uncurriedSites.back();
 
-      auto siteForeign = isParamSite
-        // Claim the foreign error and/or async argument(s) with the method
-        // formal params.
-        ? CalleeTypeInfo::ForeignInfo{foreign.error, foreign.async, {}}
-        // Claim the foreign "self" with the self param.
-        : CalleeTypeInfo::ForeignInfo{{}, {}, foreign.self};
-
-      std::move(site).emit(SGF, origFormalType, substFnType, paramLowering,
-                           args.back(), delayedArgs,
-                           siteForeign);
+      // Claim the foreign "self" with the self param.
+      auto siteForeign = CalleeTypeInfo::ForeignInfo{{}, {}, foreign.self};
+      std::move(*selfArg).emit(SGF, origFormalType, substFnType, paramLowering,
+                               args.back(), delayedArgs,
+                               siteForeign);
 
       origFormalType = origFormalType.getFunctionResultType();
     }
+
+    args.push_back({});
+
+    // Claim the foreign error and/or async argument(s) with the method
+    // formal params.
+    auto siteForeign =
+        CalleeTypeInfo::ForeignInfo{foreign.error, foreign.async, {}};
+    std::move(*callSite).emit(SGF, origFormalType, substFnType, paramLowering,
+                              args.back(), delayedArgs,
+                              siteForeign);
   }
-  assert(uncurriedLoc);
+
+  uncurriedLoc = callSite->Loc;
 
   // Emit any delayed arguments: formal accesses to inout arguments, etc.
   if (!delayedArgs.empty()) {