AST: Split off ArgumentShuffleExpr from TupleShuffleExpr

Right now we use TupleShuffleExpr for two completely different things:

- Tuple conversions, where elements can be re-ordered and labels can be
  introduced/eliminated
- Complex argument lists, involving default arguments or varargs

The first case does not allow default arguments or varargs, and the
second case does not allow re-ordering or introduction/elimination
of labels. Furthermore, the first case has a representation limitation
that prevents us from expressing tuple conversions that change the
type of tuple elements.

For all these reasons, it is better if we use two separate Expr kinds
for these purposes. For now, just make an identical copy of
TupleShuffleExpr and call it ArgumentShuffleExpr. In CSApply, use
ArgumentShuffleExpr when forming the arguments to a call, and keep
using TupleShuffleExpr for tuple conversions. Each usage of
TupleShuffleExpr has been audited to see if it should instead look at
ArgumentShuffleExpr.

In sequent commits I plan on redesigning TupleShuffleExpr to correctly
represent all tuple conversions without any unnecessary baggage.

Longer term, we actually want to change the representation of CallExpr
to directly store an argument list; then instead of a single child
expression that must be a ParenExpr, TupleExpr or ArgumentShuffleExpr,
all CallExprs will have a uniform representation and ArgumentShuffleExpr
will go away altogether. This should reduce memory usage and radically
simplify parts of SILGen.

Author: slavapestov

include/swift/AST/Expr.h

@@ -303,6 +303,19 @@ class alignas(8) Expr {
     NumVariadicArgs : 16
   );
 
+  SWIFT_INLINE_BITFIELD_FULL(ArgumentShuffleExpr, ImplicitConversionExpr, 2+16+16+16,
+    TypeImpact : 2,
+    : NumPadBits,
+    NumCallerDefaultArgs : 16,
+    /// This contains an entry for each element in the Expr type.  Each element
+    /// specifies which index from the SubExpr that the destination element gets.
+    /// If the element value is DefaultInitialize, then the destination value
+    /// gets the default initializer for that tuple element value.
+    NumElementMappings : 16,
+    /// The arguments that are packed into the variadic element.
+    NumVariadicArgs : 16
+  );
+
   SWIFT_INLINE_BITFIELD(ForceValueExpr, Expr, 1,
     ForcedIUO : 1
   );
@@ -3098,6 +3111,157 @@ class TupleShuffleExpr final : public ImplicitConversionExpr,
   }
 };
 
+/// ArgumentShuffleExpr - This represents a "complex" argument list of an
+/// ApplyExpr, with default arguments or varargs.
+///
+/// If hasScalarSource() is true, the subexpression should be treated
+/// as if it were implicitly injected into a single-element tuple
+/// type.  Otherwise, the subexpression is known to have a tuple type.
+class ArgumentShuffleExpr final : public ImplicitConversionExpr,
+    private llvm::TrailingObjects<ArgumentShuffleExpr, Expr *, int, unsigned> {
+  friend TrailingObjects;
+
+  size_t numTrailingObjects(OverloadToken<Expr *>) const {
+    return Bits.ArgumentShuffleExpr.NumCallerDefaultArgs;
+  }
+  size_t numTrailingObjects(OverloadToken<int>) const {
+    return Bits.ArgumentShuffleExpr.NumElementMappings;
+  }
+  size_t numTrailingObjects(OverloadToken<unsigned>) const {
+    return Bits.ArgumentShuffleExpr.NumVariadicArgs;
+  }
+
+public:
+  enum : int {
+    /// The element mapping value indicating that a field of the destination
+    /// tuple should be default-initialized.
+    DefaultInitialize = -1,
+    /// The element mapping is part of the variadic field.
+    Variadic = -2,
+    /// The element mapping value indicating that the field of the
+    /// destination tuple should be default-initialized with an expression
+    /// provided by the caller.
+    /// FIXME: Yet another indication that ArgumentShuffleExpr uses the wrong
+    /// formulation.
+    CallerDefaultInitialize = -3
+  };
+
+  enum TypeImpact {
+    /// The source value is a tuple which is destructured and modified to
+    /// create the result, which is a tuple.
+    ///
+    /// Example: (x: Int) => (x: Int, y: Int = 0).
+    TupleToTuple,
+
+    /// The source value is a tuple which is destructured and modified to
+    /// create the result, which is a scalar because it has one element and
+    /// no labels.
+    ///
+    /// Example: () -> (_: Int = 0)
+    /// Another example: (Int, Int) => (_: Int...)
+    TupleToScalar,
+
+    /// The source value is an individual value (possibly one with tuple
+    /// type) which is inserted into a particular position in the result,
+    /// which is a tuple.
+    ///
+    /// Example: (Int) -> (_: Int, y: Int = 0)
+    ScalarToTuple
+
+    // (ArgumentShuffleExpr are never created for a scalar-to-scalar conversion.)
+  };
+
+private:
+  /// If we're doing a varargs shuffle, this is the array type to build.
+  Type VarargsArrayTy;
+
+  /// If there are any default arguments, the owning function
+  /// declaration.
+  ConcreteDeclRef DefaultArgsOwner;
+
+  ArgumentShuffleExpr(Expr *subExpr, ArrayRef<int> elementMapping,
+                      TypeImpact typeImpact,
+                      ConcreteDeclRef defaultArgsOwner,
+                      ArrayRef<unsigned> VariadicArgs,
+                      Type VarargsArrayTy,
+                      ArrayRef<Expr *> CallerDefaultArgs,
+                      Type ty)
+    : ImplicitConversionExpr(ExprKind::ArgumentShuffle, subExpr, ty),
+      VarargsArrayTy(VarargsArrayTy), DefaultArgsOwner(defaultArgsOwner) {
+    Bits.ArgumentShuffleExpr.TypeImpact = typeImpact;
+    Bits.ArgumentShuffleExpr.NumCallerDefaultArgs = CallerDefaultArgs.size();
+    Bits.ArgumentShuffleExpr.NumElementMappings = elementMapping.size();
+    Bits.ArgumentShuffleExpr.NumVariadicArgs = VariadicArgs.size();
+    std::uninitialized_copy(CallerDefaultArgs.begin(), CallerDefaultArgs.end(),
+                            getTrailingObjects<Expr*>());
+    std::uninitialized_copy(elementMapping.begin(), elementMapping.end(),
+                            getTrailingObjects<int>());
+    std::uninitialized_copy(VariadicArgs.begin(), VariadicArgs.end(),
+                            getTrailingObjects<unsigned>());
+  }
+
+public:
+  static ArgumentShuffleExpr *create(ASTContext &ctx, Expr *subExpr,
+                                     ArrayRef<int> elementMapping,
+                                     TypeImpact typeImpact,
+                                     ConcreteDeclRef defaultArgsOwner,
+                                     ArrayRef<unsigned> VariadicArgs,
+                                     Type VarargsArrayTy,
+                                     ArrayRef<Expr *> CallerDefaultArgs,
+                                     Type ty);
+
+  ArrayRef<int> getElementMapping() const {
+    return {getTrailingObjects<int>(),
+            static_cast<size_t>(Bits.ArgumentShuffleExpr.NumElementMappings)};
+  }
+
+  /// What is the type impact of this shuffle?
+  TypeImpact getTypeImpact() const {
+    return TypeImpact(Bits.ArgumentShuffleExpr.TypeImpact);
+  }
+
+  bool isSourceScalar() const {
+    return getTypeImpact() == ScalarToTuple;
+  }
+
+  bool isResultScalar() const {
+    return getTypeImpact() == TupleToScalar;
+  }
+
+  Type getVarargsArrayType() const {
+    assert(!VarargsArrayTy.isNull());
+    return VarargsArrayTy;
+  }
+  Type getVarargsArrayTypeOrNull() const {
+    return VarargsArrayTy;
+  }
+
+  /// Retrieve the argument indices for the variadic arguments.
+  ArrayRef<unsigned> getVariadicArgs() const {
+    return {getTrailingObjects<unsigned>(),
+            static_cast<size_t>(Bits.ArgumentShuffleExpr.NumVariadicArgs)};
+  }
+
+  /// Retrieve the owner of the default arguments.
+  ConcreteDeclRef getDefaultArgsOwner() const { return DefaultArgsOwner; }
+
+  /// Retrieve the caller-defaulted arguments.
+  ArrayRef<Expr *> getCallerDefaultArgs() const {
+    return {getTrailingObjects<Expr*>(),
+            static_cast<size_t>(Bits.ArgumentShuffleExpr.NumCallerDefaultArgs)};
+  }
+
+  /// Retrieve the caller-defaulted arguments.
+  MutableArrayRef<Expr *> getCallerDefaultArgs() {
+    return {getTrailingObjects<Expr*>(),
+            static_cast<size_t>(Bits.ArgumentShuffleExpr.NumCallerDefaultArgs)};
+  }
+
+  static bool classof(const Expr *E) {
+    return E->getKind() == ExprKind::ArgumentShuffle;
+  }
+};
+
 /// LoadExpr - Turn an l-value into an r-value by performing a "load"
 /// operation.  This operation may actually be a logical operation,
 /// i.e. one implemented using a call to a potentially user-defined
@@ -3975,7 +4139,7 @@ class ApplyExpr : public Expr {
 
   /// Returns true if \c e could be used as the call's argument. For most \c ApplyExpr
   /// subclasses, this means it is a \c ParenExpr, \c TupleExpr, or 
-  /// \c TupleShuffleExpr.
+  /// \c ArgumentShuffleExpr.
   bool validateArg(Expr *e) const;
 
 protected:
@@ -5355,7 +5519,7 @@ inline bool ApplyExpr::validateArg(Expr *e) const {
   else if (isa<BinaryExpr>(this))
     return isa<TupleExpr>(e);
   else
-    return isa<ParenExpr>(e) || isa<TupleExpr>(e) || isa<TupleShuffleExpr>(e);
+    return isa<ParenExpr>(e) || isa<TupleExpr>(e) || isa<ArgumentShuffleExpr>(e);
 }
 
 inline Expr *const *CollectionExpr::getTrailingObjectsPointer() const {

include/swift/AST/ExprNodes.def

@@ -144,6 +144,7 @@ ABSTRACT_EXPR(Apply, Expr)
 ABSTRACT_EXPR(ImplicitConversion, Expr)
   EXPR(Load, ImplicitConversionExpr)
   EXPR(TupleShuffle, ImplicitConversionExpr)
+  EXPR(ArgumentShuffle, ImplicitConversionExpr)
   EXPR(UnresolvedTypeConversion, ImplicitConversionExpr)
   EXPR(FunctionConversion, ImplicitConversionExpr)
   EXPR(CovariantFunctionConversion, ImplicitConversionExpr)

lib/AST/ASTDumper.cpp

@@ -2153,6 +2153,42 @@ class PrintExpr : public ExprVisitor<PrintExpr> {
     printRec(E->getSubExpr());
     PrintWithColorRAII(OS, ParenthesisColor) << ')';
   }
+  void visitArgumentShuffleExpr(ArgumentShuffleExpr *E) {
+    printCommon(E, "tuple_shuffle_expr");
+    switch (E->getTypeImpact()) {
+    case ArgumentShuffleExpr::ScalarToTuple:
+      OS << " scalar_to_tuple";
+      break;
+    case ArgumentShuffleExpr::TupleToTuple:
+      OS << " tuple_to_tuple";
+      break;
+    case ArgumentShuffleExpr::TupleToScalar:
+      OS << " tuple_to_scalar";
+      break;
+    }
+    OS << " elements=[";
+    for (unsigned i = 0, e = E->getElementMapping().size(); i != e; ++i) {
+      if (i) OS << ", ";
+      OS << E->getElementMapping()[i];
+    }
+    OS << "]";
+    OS << " variadic_sources=[";
+    interleave(E->getVariadicArgs(),
+               [&](unsigned source) {
+                 OS << source;
+               },
+               [&] { OS << ", "; });
+    OS << "]";
+
+    if (auto defaultArgsOwner = E->getDefaultArgsOwner()) {
+      OS << " default_args_owner=";
+      defaultArgsOwner.dump(OS);
+    }
+
+    OS << "\n";
+    printRec(E->getSubExpr());
+    PrintWithColorRAII(OS, ParenthesisColor) << ')';
+  }
   void visitUnresolvedTypeConversionExpr(UnresolvedTypeConversionExpr *E) {
     printCommon(E, "unresolvedtype_conversion_expr") << '\n';
     printRec(E->getSubExpr());

lib/AST/ASTVerifier.cpp

@@ -1709,10 +1709,10 @@ class Verifier : public ASTWalker {
         }
       };
 
-      // If we have a tuple_shuffle, strip it off. We want to visit the
+      // If we have an argument shuffle, strip it off. We want to visit the
       // underlying paren or tuple expr.
-      if (auto *TupleShuffle = dyn_cast<TupleShuffleExpr>(Arg)) {
-        Arg = TupleShuffle->getSubExpr();
+      if (auto *ArgShuffle = dyn_cast<ArgumentShuffleExpr>(Arg)) {
+        Arg = ArgShuffle->getSubExpr();
       }
 
       if (auto *ParentExprArg = dyn_cast<ParenExpr>(Arg)) {
@@ -2047,6 +2047,65 @@ class Verifier : public ASTWalker {
       verifyCheckedBase(E);
     }
 
+    void verifyChecked(ArgumentShuffleExpr *E) {
+      PrettyStackTraceExpr debugStack(Ctx, "verifying ArgumentShuffleExpr", E);
+
+      auto getSubElementType = [&](unsigned i) {
+        if (E->isSourceScalar()) {
+          assert(i == 0);
+          return E->getSubExpr()->getType();
+        } else {
+          return (E->getSubExpr()->getType()->castTo<TupleType>()
+                   ->getElementType(i));
+        }
+      };
+
+      /// Retrieve the ith element type from the resulting tuple type.
+      auto getOuterElementType = [&](unsigned i) -> Type {
+        if (E->isResultScalar()) {
+          assert(i == 0);
+          return E->getType()->getWithoutParens();
+        } else {
+          return E->getType()->castTo<TupleType>()->getElementType(i);
+        }
+      };
+
+      Type varargsType;
+      unsigned callerDefaultArgIndex = 0;
+      for (unsigned i = 0, e = E->getElementMapping().size(); i != e; ++i) {
+        int subElem = E->getElementMapping()[i];
+        if (subElem == ArgumentShuffleExpr::DefaultInitialize)
+          continue;
+        if (subElem == ArgumentShuffleExpr::Variadic) {
+          varargsType = (E->getType()->castTo<TupleType>()
+                          ->getElement(i).getVarargBaseTy());
+          break;
+        }
+        if (subElem == ArgumentShuffleExpr::CallerDefaultInitialize) {
+          auto init = E->getCallerDefaultArgs()[callerDefaultArgIndex++];
+          if (!getOuterElementType(i)->isEqual(init->getType())) {
+            Out << "Type mismatch in ArgumentShuffleExpr\n";
+            abort();
+          }
+          continue;
+        }
+        if (!getOuterElementType(i)->isEqual(getSubElementType(subElem))) {
+          Out << "Type mismatch in ArgumentShuffleExpr\n";
+          abort();
+        }
+      }
+      if (varargsType) {
+        for (auto sourceIdx : E->getVariadicArgs()) {
+          if (!getSubElementType(sourceIdx)->isEqual(varargsType)) {
+            Out << "Vararg type mismatch in ArgumentShuffleExpr\n";
+            abort();
+          }
+        }
+      }
+
+      verifyCheckedBase(E);
+    }
+    
     void verifyChecked(DynamicTypeExpr *E) {
       PrettyStackTraceExpr debugStack(Ctx, "verifying DynamicTypeExpr", E);
 

lib/AST/ASTWalker.cpp

@@ -656,6 +656,23 @@ class Traversal : public ASTVisitor<Traversal, Expr*, Stmt*,
     return E;
   }
 
+  Expr *visitArgumentShuffleExpr(ArgumentShuffleExpr *E) {
+    if (Expr *E2 = doIt(E->getSubExpr())) {
+      E->setSubExpr(E2);
+    } else {
+      return nullptr;
+    }
+
+    for (auto &defaultArg : E->getCallerDefaultArgs()) {
+      if (Expr *newDefaultArg = doIt(defaultArg))
+        defaultArg = newDefaultArg;
+      else
+        return nullptr;
+    }
+
+    return E;
+  }
+
   Expr *visitTryExpr(TryExpr *E) {
     if (Expr *E2 = doIt(E->getSubExpr())) {
       E->setSubExpr(E2);

lib/AST/Expr.cpp

@@ -323,6 +323,7 @@ ConcreteDeclRef Expr::getReferencedDecl() const {
   PASS_THROUGH_REFERENCE(ConstructorRefCall, getFn);
   PASS_THROUGH_REFERENCE(Load, getSubExpr);
   NO_REFERENCE(TupleShuffle);
+  NO_REFERENCE(ArgumentShuffle);
   NO_REFERENCE(UnresolvedTypeConversion);
   PASS_THROUGH_REFERENCE(FunctionConversion, getSubExpr);
   PASS_THROUGH_REFERENCE(CovariantFunctionConversion, getSubExpr);
@@ -637,6 +638,7 @@ bool Expr::canAppendPostfixExpression(bool appendingPostfixOperator) const {
 
   case ExprKind::Load:
   case ExprKind::TupleShuffle:
+  case ExprKind::ArgumentShuffle:
   case ExprKind::UnresolvedTypeConversion:
   case ExprKind::FunctionConversion:
   case ExprKind::CovariantFunctionConversion:
@@ -1349,6 +1351,24 @@ TupleShuffleExpr *TupleShuffleExpr::create(ASTContext &ctx,
                                      VarargsArrayTy, CallerDefaultArgs, ty);
 }
 
+ArgumentShuffleExpr *ArgumentShuffleExpr::create(ASTContext &ctx,
+                                                 Expr *subExpr,
+                                                 ArrayRef<int> elementMapping,
+                                                 TypeImpact typeImpact,
+                                                 ConcreteDeclRef defaultArgsOwner,
+                                                 ArrayRef<unsigned> VariadicArgs,
+                                                 Type VarargsArrayTy,
+                                                 ArrayRef<Expr *> CallerDefaultArgs,
+                                                 Type ty) {
+  auto size = totalSizeToAlloc<Expr*, int, unsigned>(CallerDefaultArgs.size(),
+                                                     elementMapping.size(),
+                                                     VariadicArgs.size());
+  auto mem = ctx.Allocate(size, alignof(ArgumentShuffleExpr));
+  return ::new(mem) ArgumentShuffleExpr(subExpr, elementMapping, typeImpact,
+                                        defaultArgsOwner, VariadicArgs,
+                                        VarargsArrayTy, CallerDefaultArgs, ty);
+}
+
 SourceRange TupleExpr::getSourceRange() const {
   SourceLoc start = SourceLoc();
   SourceLoc end = SourceLoc();