[SIL] Adopt ArgumentList

Author: hamishknight

lib/SILGen/ArgumentSource.cpp

@@ -251,18 +251,11 @@ void ArgumentSource::dump(raw_ostream &out, unsigned indent) const {
   llvm_unreachable("bad kind");
 }
 
-PreparedArguments::PreparedArguments(
-    ArrayRef<AnyFunctionType::Param> params,
-    Expr *arg) : PreparedArguments(params) {
-  if (auto *PE = dyn_cast<ParenExpr>(arg))
-    addArbitrary(PE->getSubExpr());
-  else if (auto *TE = dyn_cast<TupleExpr>(arg)) {
-    for (auto *elt : TE->getElements())
-      addArbitrary(elt);
-  } else {
-    // FIXME: All ApplyExprs should have a ParenExpr or TupleExpr as their argument
-    addArbitrary(arg);
-  }
+PreparedArguments::PreparedArguments(ArrayRef<AnyFunctionType::Param> params,
+                                     ArgumentList *argList)
+    : PreparedArguments(params) {
+  for (auto arg : *argList)
+    addArbitrary(arg.getExpr());
 }
 
 PreparedArguments

lib/SILGen/ArgumentSource.h

@@ -296,8 +296,9 @@ class PreparedArguments {
     emplace(params);
   }
 
-  // Decompse an argument list expression.
-  PreparedArguments(ArrayRef<AnyFunctionType::Param> params, Expr *arg);
+  // Create from an argument list.
+  PreparedArguments(ArrayRef<AnyFunctionType::Param> params,
+                    ArgumentList *argList);
 
   // Move-only.
   PreparedArguments(const PreparedArguments &) = delete;

lib/SILGen/LValue.h

@@ -279,7 +279,7 @@ class LogicalPathComponent : public PathComponent {
     AbstractStorageDecl *Storage;
     bool IsSuper;
     const PreparedArguments *Indices;
-    Expr *IndexExprForDiagnostics;
+    ArgumentList *ArgListForDiagnostics;
   };
 
   /// Get the storage accessed by this component.
@@ -459,7 +459,7 @@ class LValue {
                           AccessStrategy accessStrategy,
                           CanType formalRValueType,
                           PreparedArguments &&indices,
-                          Expr *indexExprForDiagnostics);
+                          ArgumentList *argListForDiagnostics);
 
   void addMemberVarComponent(SILGenFunction &SGF, SILLocation loc,
                              VarDecl *var,
@@ -481,7 +481,7 @@ class LValue {
                                    AccessStrategy accessStrategy,
                                    CanType formalRValueType,
                                    PreparedArguments &&indices,
-                                   Expr *indexExprForDiagnostics,
+                                   ArgumentList *argListForDiagnostics,
                                    bool isOnSelfParameter = false,
                                    Optional<ActorIsolation> actorIso = None);
 

lib/SILGen/SILGenApply.cpp

@@ -808,7 +808,7 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
   /// The lvalue or rvalue representing the argument source of self.
   ArgumentSource selfParam;
 
-  ApplyExpr *selfApply = nullptr;
+  SelfApplyExpr *selfApply = nullptr;
   ApplyExpr *callSite = nullptr;
   Expr *sideEffect = nullptr;
 
@@ -831,26 +831,29 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
     selfParam = std::move(theSelfParam);
   }
 
-  bool isMethodSelfApply(Expr *e) {
-    return (isa<SelfApplyExpr>(e) &&
-            !isa<AutoClosureExpr>(
-              cast<SelfApplyExpr>(e)->getFn()));
+  SelfApplyExpr *getAsMethodSelfApply(Expr *e) {
+    auto *SAE = dyn_cast<SelfApplyExpr>(e);
+    if (!SAE)
+      return nullptr;
+    if (isa<AutoClosureExpr>(SAE->getFn()))
+      return nullptr;
+    return SAE;
   }
 
   void decompose(ApplyExpr *e) {
-    if (isMethodSelfApply(e)) {
-      selfApply = e;
+    if (auto *SAE = getAsMethodSelfApply(e)) {
+      selfApply = SAE;
 
       visit(selfApply->getFn());
       return;
     }
 
     callSite = e;
 
-    if (isMethodSelfApply(e->getFn())) {
-      selfApply = cast<ApplyExpr>(e->getFn());
+    if (auto *SAE = getAsMethodSelfApply(e->getFn())) {
+      selfApply = SAE;
 
-      if (selfApply->getArg()->isSuperExpr()) {
+      if (selfApply->getBase()->isSuperExpr()) {
         applySuper(selfApply);
         return;
       }
@@ -960,14 +963,14 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
 
   void processProtocolMethod(DeclRefExpr *e, AbstractFunctionDecl *afd,
                              ProtocolDecl *proto) {
-    ArgumentSource selfValue = selfApply->getArg();
+    ArgumentSource selfValue = selfApply->getBase();
 
     auto subs = e->getDeclRef().getSubstitutions();
 
     SILDeclRef::Kind kind = SILDeclRef::Kind::Func;
     if (isa<ConstructorDecl>(afd)) {
       if (proto->isObjC()) {
-        SILLocation loc = selfApply->getArg();
+        SILLocation loc = selfApply->getBase();
 
         // For Objective-C initializers, we only have an initializing
         // initializer. We need to allocate the object ourselves.
@@ -1017,8 +1020,8 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
 
       // Required constructors are statically dispatched when the 'self'
       // value is statically derived.
-      assert(selfApply->getArg()->getType()->is<AnyMetatypeType>());
-      if (selfApply->getArg()->isStaticallyDerivedMetatype())
+      assert(selfApply->getBase()->getType()->is<AnyMetatypeType>());
+      if (selfApply->getBase()->isStaticallyDerivedMetatype())
         return false;
     }
 
@@ -1027,7 +1030,7 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
   }
 
   void processClassMethod(DeclRefExpr *e, AbstractFunctionDecl *afd) {
-    ArgumentSource selfArgSource(selfApply->getArg());
+    ArgumentSource selfArgSource(selfApply->getBase());
     setSelfParam(std::move(selfArgSource));
 
     // Directly dispatch to calls of the replaced function inside of
@@ -1036,7 +1039,7 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
     if (SGF.getOptions()
             .EnableDynamicReplacementCanCallPreviousImplementation &&
         isCallToReplacedInDynamicReplacement(SGF, afd, isObjCReplacementCall) &&
-        selfApply->getArg()->isSelfExprOf(
+        selfApply->getBase()->isSelfExprOf(
             cast<AbstractFunctionDecl>(SGF.FunctionDC->getAsDecl()), false)) {
       auto constant = SILDeclRef(afd).asForeign(
           !isObjCReplacementCall && requiresForeignEntryPoint(e->getDecl()));
@@ -1089,7 +1092,7 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
     // Enum case constructor references are open-coded.
     if (auto *eed = dyn_cast<EnumElementDecl>(e->getDecl())) {
       if (selfApply) {
-        ArgumentSource selfArgSource(selfApply->getArg());
+        ArgumentSource selfArgSource(selfApply->getBase());
         setSelfParam(std::move(selfArgSource));
       }
 
@@ -1131,15 +1134,16 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
     // dynamically_replaceable inside of a dynamic_replacement(for:) function.
     ApplyExpr *thisCallSite = (selfApply ? selfApply : callSite);
     bool isObjCReplacementSelfCall = false;
+    auto *unaryArg = thisCallSite->getArgs()->getUnaryExpr();
     bool isSelfCallToReplacedInDynamicReplacement =
         SGF.getOptions()
             .EnableDynamicReplacementCanCallPreviousImplementation &&
         isCallToReplacedInDynamicReplacement(
             SGF, cast<AbstractFunctionDecl>(constant.getDecl()),
             isObjCReplacementSelfCall) &&
         (afd->getDeclContext()->isModuleScopeContext() ||
-         thisCallSite->getArg()->isSelfExprOf(
-             cast<AbstractFunctionDecl>(SGF.FunctionDC->getAsDecl()), false));
+         (unaryArg && unaryArg->isSelfExprOf(
+             cast<AbstractFunctionDecl>(SGF.FunctionDC->getAsDecl()), false)));
 
     if (isSelfCallToReplacedInDynamicReplacement && !isObjCReplacementSelfCall)
       setCallee(Callee::forDirect(
@@ -1152,7 +1156,7 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
 
     if (selfApply) {
       // This is a statically-dispatched method with a 'self' parameter.
-      ArgumentSource selfArgSource(selfApply->getArg());
+      ArgumentSource selfArgSource(selfApply->getBase());
       setSelfParam(std::move(selfArgSource));
     }
 
@@ -1259,9 +1263,9 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
     visit(e->getSubExpr());
   }
 
-  void applySuper(ApplyExpr *apply) {
+  void applySuper(SelfApplyExpr *apply) {
     // Load the 'super' argument.
-    Expr *arg = apply->getArg();
+    Expr *arg = apply->getBase();
     RValue super;
     CanType superFormalType = arg->getType()->getCanonicalType();
 
@@ -1400,7 +1404,7 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
   }
 
   /// Try to emit the given application as initializer delegation.
-  bool applyInitDelegation(ApplyExpr *expr) {
+  bool applyInitDelegation(SelfApplyExpr *expr) {
     // Dig out the constructor we're delegating to.
     Expr *fn = expr->getFn();
     auto ctorRef = dyn_cast<OtherConstructorDeclRefExpr>(
@@ -1439,7 +1443,7 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
     }
 
     // Load the 'self' argument.
-    Expr *arg = expr->getArg();
+    Expr *arg = expr->getBase();
     ManagedValue self;
     CanType selfFormalType = arg->getType()->getCanonicalType();
 
@@ -4273,20 +4277,14 @@ CallEmission CallEmission::forApplyExpr(SILGenFunction &SGF, ApplyExpr *e) {
   }
 
   // Apply arguments from the actual call site.
-  if (apply.callSite) {
-    Expr *arg = apply.callSite->getArg();
-
-    SmallVector<AnyFunctionType::Param, 8> params;
-    AnyFunctionType::decomposeTuple(arg->getType(), params);
-
-    PreparedArguments preparedArgs(params, arg);
-
-    emission.addCallSite(apply.callSite, std::move(preparedArgs),
-                         apply.callSite->isNoThrows(),
-                         apply.callSite->isNoAsync());
+  if (auto *call = apply.callSite) {
+    auto fnTy = call->getFn()->getType()->castTo<FunctionType>();
+    PreparedArguments preparedArgs(fnTy->getParams(), call->getArgs());
+    emission.addCallSite(call, std::move(preparedArgs), call->isNoThrows(),
+                         call->isNoAsync());
 
     // For an implicitly-async call, record the target of the actor hop.
-    if (auto target = apply.callSite->isImplicitlyAsync())
+    if (auto target = call->isImplicitlyAsync())
       emission.setImplicitlyAsync(target);
   }
 
@@ -5629,9 +5627,7 @@ PreparedArguments
 SILGenFunction::prepareSubscriptIndices(SubscriptDecl *subscript,
                                         SubstitutionMap subs,
                                         AccessStrategy strategy,
-                                        Expr *indexExpr) {
-  // FIXME: we should expect an array of index expressions.
-
+                                        ArgumentList *argList) {
   // TODO: use the real abstraction pattern from the accessor(s) in the
   // strategy.
   // Currently we use the substituted type so that we can reconstitute these
@@ -5653,7 +5649,7 @@ SILGenFunction::prepareSubscriptIndices(SubscriptDecl *subscript,
 
   // Prepare the unevaluated index expression.
   auto substParams = substFnType->getParams();
-  PreparedArguments args(substParams, indexExpr);
+  PreparedArguments args(substParams, argList);
 
   // Now, force it to be evaluated.
   SmallVector<ManagedValue, 4> argValues;
@@ -5666,11 +5662,11 @@ SILGenFunction::prepareSubscriptIndices(SubscriptDecl *subscript,
   PreparedArguments result(substParams);
 
   ArrayRef<ManagedValue> remainingArgs = argValues;
-  for (auto substParam : substParams) {
-    auto substParamType = substParam.getParameterType()->getCanonicalType();
+  for (auto i : indices(substParams)) {
+    auto substParamType = substParams[i].getParameterType()->getCanonicalType();
     auto count = RValue::getRValueSize(substParamType);
     RValue elt(*this, remainingArgs.slice(0, count), substParamType);
-    result.add(indexExpr, std::move(elt));
+    result.add(argList->getExpr(i), std::move(elt));
     remainingArgs = remainingArgs.slice(count);
   }
   assert(remainingArgs.empty());
@@ -6178,7 +6174,9 @@ RValue SILGenFunction::emitDynamicSubscriptExpr(DynamicSubscriptExpr *e,
   SILValue base = managedBase.getValue();
 
   // Emit the index.
-  RValue index = emitRValue(e->getIndex());
+  auto *indexExpr = e->getArgs()->getUnaryExpr();
+  assert(indexExpr);
+  RValue index = emitRValue(indexExpr);
 
   // Create the continuation block.
   SILBasicBlock *contBB = createBasicBlock();
@@ -6214,7 +6212,7 @@ RValue SILGenFunction::emitDynamicSubscriptExpr(DynamicSubscriptExpr *e,
     //
     // FIXME: Verify ExtInfo state is correct, not working by accident.
     CanFunctionType::ExtInfo methodInfo;
-    FunctionType::Param indexArg(e->getIndex()->getType()->getCanonicalType());
+    FunctionType::Param indexArg(indexExpr->getType()->getCanonicalType());
     auto methodTy = CanFunctionType::get({indexArg}, valueTy, methodInfo);
     auto foreignMethodTy =
       getPartialApplyOfDynamicMethodFormalType(SGM, member, e->getMember());
@@ -6268,7 +6266,7 @@ RValue SILGenFunction::emitDynamicSubscriptExpr(DynamicSubscriptExpr *e,
 }
 
 SmallVector<ManagedValue, 4> SILGenFunction::emitKeyPathSubscriptOperands(
-    SubscriptDecl *subscript, SubstitutionMap subs, Expr *indexExpr) {
+    SubscriptDecl *subscript, SubstitutionMap subs, ArgumentList *argList) {
   Type interfaceType = subscript->getInterfaceType();
   CanFunctionType substFnType =
       subs ? cast<FunctionType>(interfaceType->castTo<GenericFunctionType>()
@@ -6291,7 +6289,7 @@ SmallVector<ManagedValue, 4> SILGenFunction::emitKeyPathSubscriptOperands(
   auto prepared =
       prepareSubscriptIndices(subscript, subs,
                               // Strategy doesn't matter
-                              AccessStrategy::getStorage(), indexExpr);
+                              AccessStrategy::getStorage(), argList);
   emitter.emitPreparedArgs(std::move(prepared), origFnType);
 
   if (!delayedArgs.empty())

lib/SILGen/SILGenExpr.cpp

@@ -2524,7 +2524,7 @@ visitObjectLiteralExpr(ObjectLiteralExpr *E, SGFContext C) {
   AnyFunctionType *fnTy = decl->getMethodInterfaceType()
                               .subst(init.getSubstitutions())
                               ->getAs<AnyFunctionType>();
-  PreparedArguments args(fnTy->getParams(), E->getArg());
+  PreparedArguments args(fnTy->getParams(), E->getArgs());
   return SGF.emitApplyAllocatingInitializer(SILLocation(E), init,
                                             std::move(args), E->getType(), C);
 }
@@ -3673,7 +3673,7 @@ RValue RValueEmitter::visitKeyPathExpr(KeyPathExpr *E, SGFContext C) {
       auto subscript = cast<SubscriptDecl>(decl);
       auto loweredArgs = SGF.emitKeyPathSubscriptOperands(
           subscript, component.getDeclRef().getSubstitutions(),
-          component.getIndexExpr());
+          component.getSubscriptArgs());
 
       for (auto &arg : loweredArgs) {
         operands.push_back(arg.forward(SGF));

lib/SILGen/SILGenFunction.h

@@ -731,11 +731,10 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
   /// \returns Lowered index arguments.
   /// \param subscript - The subscript decl who's arguments are being lowered.
   /// \param subs - Used to get subscript function type and to substitute generic args.
-  /// \param indexExpr - An expression holding the indices of the
-  /// subscript (either a TupleExpr or a ParenExpr).
+  /// \param argList - The argument list of the subscript.
   SmallVector<ManagedValue, 4>
   emitKeyPathSubscriptOperands(SubscriptDecl *subscript, SubstitutionMap subs,
-                               Expr *indexExpr);
+                               ArgumentList *argList);
 
   /// Convert a block to a native function with a thunk.
   ManagedValue emitBlockToFunc(SILLocation loc,
@@ -1366,7 +1365,7 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
   PreparedArguments prepareSubscriptIndices(SubscriptDecl *subscript,
                                             SubstitutionMap subs,
                                             AccessStrategy strategy,
-                                            Expr *indices);
+                                            ArgumentList *argList);
 
   ArgumentSource prepareAccessorBaseArg(SILLocation loc, ManagedValue base,
                                         CanType baseFormalType,