SILGen: Stop using "scalar" PreparedArguments except for ArgumentShuffleExpr

For anything else, we can decompose the argument list on the spot.

Note that builtins that are implemented as EarlyEmitters now take a
the argument list as a PreparedArguments instead of a single Expr.

Since the PreparedArguments can still be a scalar with an
ArgumentShuffleExpr, we have to jump through some hoops to turn
it into a list of argument Exprs. This will all go away soon.

Author: slavapestov

lib/SILGen/ArgumentSource.cpp

@@ -261,6 +261,22 @@ void ArgumentSource::dump(raw_ostream &out, unsigned indent) const {
   llvm_unreachable("bad kind");
 }
 
+PreparedArguments::PreparedArguments(
+    ArrayRef<AnyFunctionType::Param> params,
+    Expr *arg) : PreparedArguments(params, /*scalar*/ isa<ArgumentShuffleExpr>(arg)) {
+  if (isa<ArgumentShuffleExpr>(arg))
+    addArbitrary(arg);
+  else 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);
+  }
+}
+
 void PreparedArguments::emplaceEmptyArgumentList(SILGenFunction &SGF) {
   emplace({}, /*scalar*/ false);
   assert(isValid());

lib/SILGen/ArgumentSource.h

@@ -273,6 +273,9 @@ class PreparedArguments {
     emplace(params, isScalar);
   }
 
+  // Decompse an argument list expression.
+  PreparedArguments(ArrayRef<AnyFunctionType::Param> params, Expr *arg);
+
   // Move-only.
   PreparedArguments(const PreparedArguments &) = delete;
   PreparedArguments &operator=(const PreparedArguments &) = delete;

lib/SILGen/SILGenApply.cpp

@@ -2774,6 +2774,7 @@ class ArgEmitter {
       assert(argSources.size() == 1);
       emitTopLevel(std::move(argSources[0]), origFormalType);
     } else {
+      maybeEmitForeignErrorArgument();
       for (auto i : indices(argSources)) {
         emitSingleArg(std::move(argSources[i]),
                       origFormalType.getFunctionParamType(i));
@@ -4643,12 +4644,9 @@ CallEmission::applySpecializedEmitter(SpecializedEmitter &specializedEmitter,
     // We should be able to enforce that these arguments are
     // always still expressions.
     PreparedArguments args = std::move(uncurriedSites[0]).forward();
-    assert(args.isScalar());
-    Expr *argument = std::move(std::move(args).getSources()[0]).asKnownExpr();
-
     ManagedValue resultMV =
         emitter(SGF, uncurriedLoc, callee.getSubstitutions(),
-                argument, uncurriedContext);
+                std::move(args), uncurriedContext);
     firstLevelResult.value =
         RValue(SGF, uncurriedLoc, formalResultType, resultMV);
     return firstLevelResult;
@@ -4875,10 +4873,7 @@ CallEmission CallEmission::forApplyExpr(SILGenFunction &SGF, ApplyExpr *e) {
     SmallVector<AnyFunctionType::Param, 8> params;
     AnyFunctionType::decomposeInput(arg->getType(), params);
 
-    // FIXME: Split up the argument expression here instead of passing
-    // scalar=true.
-    PreparedArguments preparedArgs(params, /*scalar*/true);
-    preparedArgs.addArbitrary(arg);
+    PreparedArguments preparedArgs(params, arg);
 
     emission.addCallSite(apply, std::move(preparedArgs),
                          apply->getType()->getCanonicalType(),
@@ -6069,8 +6064,7 @@ SILGenFunction::prepareSubscriptIndices(SubscriptDecl *subscript,
 
   // Prepare the unevaluated index expression.
   auto substParams = substFnType->getParams();
-  PreparedArguments args(substParams, /*isScalar=*/true);
-  args.addArbitrary(indexExpr);
+  PreparedArguments args(substParams, indexExpr);
 
   // Now, force it to be evaluated.
   SmallVector<ManagedValue, 4> argValues;

lib/SILGen/SILGenBuiltin.cpp

@@ -12,6 +12,7 @@
 
 #include "SpecializedEmitter.h"
 
+#include "ArgumentSource.h"
 #include "Cleanup.h"
 #include "Initialization.h"
 #include "LValue.h"
@@ -45,42 +46,40 @@ static bool isTrivialShuffle(ArgumentShuffleExpr *shuffle) {
 ///
 /// Because these are builtin operations, we can make some structural
 /// assumptions about the expression used to call them.
-static ArrayRef<Expr*> decomposeArguments(SILGenFunction &SGF,
-                                          Expr *arg,
-                                          unsigned expectedCount) {
-  assert(expectedCount >= 2);
-  assert(arg->getType()->is<TupleType>());
-  assert(arg->getType()->castTo<TupleType>()->getNumElements()
-           == expectedCount);
-
-  // The use of owned parameters can trip up CSApply enough to introduce
-  // a trivial tuple shuffle here.
-  arg = arg->getSemanticsProvidingExpr();
-  if (auto shuffle = dyn_cast<ArgumentShuffleExpr>(arg)) {
-    if (isTrivialShuffle(shuffle))
-      arg = shuffle->getSubExpr();
-  }
+static Optional<SmallVector<Expr*, 2>>
+decomposeArguments(SILGenFunction &SGF,
+                   SILLocation loc,
+                   PreparedArguments &&args,
+                   unsigned expectedCount) {
+  SmallVector<Expr*, 2> result;
+  auto sources = std::move(args).getSources();
+
+  if (sources.size() == expectedCount) {
+    for (auto &&source : sources)
+      result.push_back(std::move(source).asKnownExpr());
+    return result;
+  } else if (sources.size() == 1) {
+    auto *arg = std::move(sources[0]).asKnownExpr();
+
+    // The use of owned parameters can trip up CSApply enough to introduce
+    // a trivial tuple shuffle here.
+    if (auto shuffle = dyn_cast<ArgumentShuffleExpr>(arg)) {
+      if (isTrivialShuffle(shuffle))
+        arg = shuffle->getSubExpr();
+    }
 
-  auto tuple = dyn_cast<TupleExpr>(arg);
-  if (tuple && tuple->getElements().size() == expectedCount) {
-    return tuple->getElements();
+    auto tuple = dyn_cast<TupleExpr>(arg);
+    if (tuple && tuple->getElements().size() == expectedCount) {
+      for (auto elt : tuple->getElements())
+        result.push_back(elt);
+      return result;
+    }
   }
 
-  SGF.SGM.diagnose(arg, diag::invalid_sil_builtin,
+  SGF.SGM.diagnose(loc, diag::invalid_sil_builtin,
                    "argument to builtin should be a literal tuple");
 
-  auto tupleTy = arg->getType()->castTo<TupleType>();
-
-  // This is well-typed but may cause code to be emitted redundantly.
-  auto &ctxt = SGF.getASTContext();
-  SmallVector<Expr*, 4> args;
-  for (auto index : indices(tupleTy->getElementTypes())) {
-    Expr *projection = new (ctxt) TupleElementExpr(arg, SourceLoc(),
-                                                   index, SourceLoc(),
-                                          tupleTy->getElementType(index));
-    args.push_back(projection);
-  }
-  return ctxt.AllocateCopy(args);
+  return None;
 }
 
 static ManagedValue emitBuiltinRetain(SILGenFunction &SGF,
@@ -252,9 +251,13 @@ static ManagedValue emitBuiltinAssign(SILGenFunction &SGF,
 static ManagedValue emitBuiltinInit(SILGenFunction &SGF,
                                     SILLocation loc,
                                     SubstitutionMap substitutions,
-                                    Expr *tuple,
+                                    PreparedArguments &&preparedArgs,
                                     SGFContext C) {
-  auto args = decomposeArguments(SGF, tuple, 2);
+  auto argsOrError = decomposeArguments(SGF, loc, std::move(preparedArgs), 2);
+  if (!argsOrError)
+    return ManagedValue::forUnmanaged(SGF.emitEmptyTuple(loc));
+
+  auto args = *argsOrError;
 
   CanType formalType =
     substitutions.getReplacementTypes()[0]->getCanonicalType();
@@ -421,23 +424,29 @@ static ManagedValue emitBuiltinBridgeFromRawPointer(SILGenFunction &SGF,
 static ManagedValue emitBuiltinAddressOf(SILGenFunction &SGF,
                                          SILLocation loc,
                                          SubstitutionMap substitutions,
-                                         Expr *argument,
+                                         PreparedArguments &&preparedArgs,
                                          SGFContext C) {
-  auto rawPointerTy = SILType::getRawPointerType(SGF.getASTContext());
+  SILType rawPointerType = SILType::getRawPointerType(SGF.getASTContext());
+
+  auto argsOrError = decomposeArguments(SGF, loc, std::move(preparedArgs), 1);
+  if (!argsOrError)
+    return SGF.emitUndef(rawPointerType);
+
+  auto argument = (*argsOrError)[0];
+
   // If the argument is inout, try forming its lvalue. This builtin only works
   // if it's trivially physically projectable.
   auto inout = cast<InOutExpr>(argument->getSemanticsProvidingExpr());
   auto lv = SGF.emitLValue(inout->getSubExpr(), SGFAccessKind::ReadWrite);
   if (!lv.isPhysical() || !lv.isLoadingPure()) {
     SGF.SGM.diagnose(argument->getLoc(), diag::non_physical_addressof);
-    return SGF.emitUndef(rawPointerTy);
+    return SGF.emitUndef(rawPointerType);
   }
 
   auto addr = SGF.emitAddressOfLValue(argument, std::move(lv))
                  .getLValueAddress();
 
   // Take the address argument and cast it to RawPointer.
-  SILType rawPointerType = SILType::getRawPointerType(SGF.F.getASTContext());
   SILValue result = SGF.B.createAddressToPointer(loc, addr,
                                                  rawPointerType);
   return ManagedValue::forUnmanaged(result);
@@ -447,23 +456,29 @@ static ManagedValue emitBuiltinAddressOf(SILGenFunction &SGF,
 static ManagedValue emitBuiltinAddressOfBorrow(SILGenFunction &SGF,
                                                SILLocation loc,
                                                SubstitutionMap substitutions,
-                                               Expr *argument,
+                                               PreparedArguments &&preparedArgs,
                                                SGFContext C) {
-  auto rawPointerTy = SILType::getRawPointerType(SGF.getASTContext());
+  SILType rawPointerType = SILType::getRawPointerType(SGF.getASTContext());
+
+  auto argsOrError = decomposeArguments(SGF, loc, std::move(preparedArgs), 1);
+  if (!argsOrError)
+    return SGF.emitUndef(rawPointerType);
+
+  auto argument = (*argsOrError)[0];
+
   SILValue addr;
   // Try to borrow the argument at +0. We only support if it's
   // naturally emitted borrowed in memory.
   auto borrow = SGF.emitRValue(argument, SGFContext::AllowGuaranteedPlusZero)
      .getAsSingleValue(SGF, argument);
   if (!borrow.isPlusZero() || !borrow.getType().isAddress()) {
     SGF.SGM.diagnose(argument->getLoc(), diag::non_borrowed_indirect_addressof);
-    return SGF.emitUndef(rawPointerTy);
+    return SGF.emitUndef(rawPointerType);
   }
 
   addr = borrow.getValue();
 
   // Take the address argument and cast it to RawPointer.
-  SILType rawPointerType = SILType::getRawPointerType(SGF.F.getASTContext());
   SILValue result = SGF.B.createAddressToPointer(loc, addr,
                                                  rawPointerType);
   return ManagedValue::forUnmanaged(result);

lib/SILGen/SILGenExpr.cpp

@@ -2415,7 +2415,7 @@ loadIndexValuesForKeyPathComponent(SILGenFunction &SGF, SILLocation loc,
     indexParams.emplace_back(SGF.F.mapTypeIntoContext(elt.first));
   }
 
-  PreparedArguments indexValues(indexParams, /*scalar*/ indexes.size() == 1);
+  PreparedArguments indexValues(indexParams, /*scalar*/ false);
   if (indexes.empty()) {
     assert(indexValues.isValid());
     return indexValues;

lib/SILGen/SpecializedEmitter.h

@@ -32,6 +32,7 @@ class ManagedValue;
 class SGFContext;
 class SILGenFunction;
 class SILGenModule;
+class PreparedArguments;
 
 /// Some kind of specialized emitter for a builtin function.
 class SpecializedEmitter {
@@ -41,7 +42,7 @@ class SpecializedEmitter {
   using EarlyEmitter = ManagedValue (SILGenFunction &,
                                      SILLocation,
                                      SubstitutionMap,
-                                     Expr *argument,
+                                     PreparedArguments &&args,
                                      SGFContext);
 
   /// A special function for emitting a call after the arguments