Switch subscript index emission to use SILGenApply. NFC.

As always, most of the work here went into working around the AST
representations of parameter and argument lists.

Author: rjmccall

lib/SILGen/ArgumentSource.cpp

@@ -409,3 +409,67 @@ void ArgumentSource::dump(raw_ostream &out, unsigned indent) const {
   }
   llvm_unreachable("bad kind");
 }
+
+void PreparedArguments::emplaceEmptyArgumentList(SILGenFunction &SGF) {
+  emplace(CanType(TupleType::getEmpty(SGF.getASTContext())), /*scalar*/ false);
+  assert(isValid());
+}
+
+PreparedArguments
+PreparedArguments::copy(SILGenFunction &SGF, SILLocation loc) const {
+  if (isNull()) return PreparedArguments();
+
+  assert(isValid());
+  PreparedArguments result(getFormalType(), isScalar());
+  for (auto &elt : Arguments) {
+    assert(elt.isRValue());
+    result.add(elt.getKnownRValueLocation(),
+               elt.asKnownRValue().copy(SGF, loc));
+  }
+  assert(isValid());
+  return result;
+}
+
+bool PreparedArguments::isObviouslyEqual(const PreparedArguments &other) const {
+  if (isNull() != other.isNull())
+    return false;
+  if (isNull())
+    return true;
+
+  assert(isValid() && other.isValid());
+  if (Arguments.size() != other.Arguments.size())
+    return false;
+  for (auto i : indices(Arguments)) {
+    if (!Arguments[i].isObviouslyEqual(other.Arguments[i]))
+      return false;
+  }
+  return true;
+}
+
+bool ArgumentSource::isObviouslyEqual(const ArgumentSource &other) const {
+  if (StoredKind != other.StoredKind)
+    return false;
+
+  switch (StoredKind) {
+  case Kind::Invalid:
+    llvm_unreachable("argument source is invalid");
+  case Kind::RValue:
+    return asKnownRValue().isObviouslyEqual(other.asKnownRValue());
+  case Kind::LValue:
+    return false; // TODO?
+  case Kind::Expr:
+    return false; // TODO?
+  case Kind::Tuple: {
+    auto &selfTuple = Storage.get<TupleStorage>(StoredKind);
+    auto &otherTuple = other.Storage.get<TupleStorage>(other.StoredKind);
+    if (selfTuple.Elements.size() != otherTuple.Elements.size())
+      return false;
+    for (auto i : indices(selfTuple.Elements)) {
+      if (!selfTuple.Elements[i].isObviouslyEqual(otherTuple.Elements[i]))
+        return false;
+    }
+    return true;
+  }
+  }
+  llvm_unreachable("bad kind");
+}

lib/SILGen/ArgumentSource.h

@@ -229,7 +229,9 @@ class ArgumentSource {
   RValue &&asKnownRValue(SILGenFunction &SGF) && {
     return std::move(Storage.get<RValueStorage>(StoredKind).Value);
   }
-
+  const RValue &asKnownRValue() const & {
+    return Storage.get<RValueStorage>(StoredKind).Value;
+  }
   SILLocation getKnownRValueLocation() const & {
     return Storage.get<RValueStorage>(StoredKind).Loc;
   }
@@ -239,6 +241,9 @@ class ArgumentSource {
   LValue &&asKnownLValue() && {
     return std::move(Storage.get<LValueStorage>(StoredKind).Value);
   }
+  const LValue &asKnownLValue() const & {
+    return Storage.get<LValueStorage>(StoredKind).Value;
+  }
   SILLocation getKnownLValueLocation() const & {
     return Storage.get<LValueStorage>(StoredKind).Loc;
   }
@@ -310,30 +315,117 @@ class ArgumentSource {
   /// Whether this argument source requires the callee to evaluate.
   bool requiresCalleeToEvaluate() const;
 
+  bool isObviouslyEqual(const ArgumentSource &other) const;
+
   void dump() const;
   void dump(raw_ostream &os, unsigned indent = 0) const;
 
 private:
   /// Private helper constructor for delayed borrowed rvalues.
   ArgumentSource(SILLocation loc, RValue &&rv, Kind kind);
 
-  // Make the non-move accessors private to make it more difficult
+  // Make this non-move accessor private to make it more difficult
   // to accidentally re-emit values.
-  const RValue &asKnownRValue() const & {
-    return Storage.get<RValueStorage>(StoredKind).Value;
+  Expr *asKnownExpr() const & {
+    return Storage.get<Expr*>(StoredKind);
   }
 
-  // Make the non-move accessors private to make it more difficult
-  // to accidentally re-emit values.
-  const LValue &asKnownLValue() const & {
-    return Storage.get<LValueStorage>(StoredKind).Value;
+  RValue getKnownTupleAsRValue(SILGenFunction &SGF, SGFContext C) &&;
+};
+
+class PreparedArguments {
+  // TODO: replace this formal type with an array of parameter types.
+  CanType FormalType;
+  std::vector<ArgumentSource> Arguments;
+  bool IsScalar = false;
+public:
+  PreparedArguments() {}
+  PreparedArguments(CanType formalType, bool isScalar) {
+    emplace(formalType, isScalar);
   }
 
-  Expr *asKnownExpr() const & {
-    return Storage.get<Expr*>(StoredKind);
+  // Move-only.
+  PreparedArguments(const PreparedArguments &) = delete;
+  PreparedArguments &operator=(const PreparedArguments &) = delete;
+
+  PreparedArguments(PreparedArguments &&other)
+    : FormalType(other.FormalType), Arguments(std::move(other.Arguments)),
+      IsScalar(other.IsScalar) {
+    other.FormalType = CanType();
+  }
+  PreparedArguments &operator=(PreparedArguments &&other) {
+    FormalType = other.FormalType;
+    IsScalar = other.IsScalar;
+    Arguments = std::move(other.Arguments);
+    other.FormalType = CanType();
+    return *this;
   }
 
-  RValue getKnownTupleAsRValue(SILGenFunction &SGF, SGFContext C) &&;
+  /// Returns true if this is a null argument list.  Note that this always
+  /// indicates the total absence of an argument list rather than the
+  /// possible presence of an empty argument list.
+  bool isNull() const { return !FormalType; }
+
+  /// Returns true if this is a non-null and completed argument list.
+  bool isValid() const {
+    assert(!isNull());
+    if (IsScalar) {
+      return Arguments.size() == 1;
+    } else if (auto tuple = dyn_cast<TupleType>(FormalType)) {
+      return Arguments.size() == tuple->getNumElements();
+    } else {
+      return Arguments.size() == 1;
+    }
+  }
+
+  /// Return the formal type of this argument list.
+  CanType getFormalType() const {
+    assert(!isNull());
+    return FormalType;
+  }
+
+  /// Is this a single-argument list?  Note that the argument might be a tuple.
+  bool isScalar() const {
+    assert(!isNull());
+    return IsScalar;
+  }
+
+  MutableArrayRef<ArgumentSource> getSources() && {
+    assert(isValid());
+    return Arguments;
+  }
+
+  /// Emplace a (probably incomplete) argument list.
+  void emplace(CanType formalType, bool isScalar) {
+    assert(isNull());
+    assert(!formalType->hasTypeParameter() && "should be a contextual type!");
+    assert(isScalar || isa<TupleType>(formalType));
+    FormalType = formalType;
+    IsScalar = isScalar;
+  }
+
+  /// Emplace an empty argument list.
+  void emplaceEmptyArgumentList(SILGenFunction &SGF);
+
+  /// Add an emitted r-value argument to this argument list.
+  void add(SILLocation loc, RValue &&arg) {
+    assert(!isNull());
+    Arguments.emplace_back(loc, std::move(arg));
+  }
+
+  /// Add an arbitrary argument source to these arguments.
+  ///
+  /// An argument list with an arbtrary argument source can't generally
+  /// be copied.
+  void addArbitrary(ArgumentSource &&arg) {
+    assert(!isNull());
+    Arguments.emplace_back(std::move(arg));
+  }
+
+  /// Copy these prepared arguments.  This propagates null.
+  PreparedArguments copy(SILGenFunction &SGF, SILLocation loc) const;
+
+  bool isObviouslyEqual(const PreparedArguments &other) const;
 };
 
 } // end namespace Lowering

lib/SILGen/LValue.h

@@ -266,7 +266,7 @@ class LogicalPathComponent : public PathComponent {
   struct AccessedStorage {
     AbstractStorageDecl *Storage;
     bool IsSuper;
-    const RValue *Indices;
+    const PreparedArguments *Indices;
     Expr *IndexExprForDiagnostics;
   };
 
@@ -444,7 +444,7 @@ class LValue {
                           bool isSuper,
                           AccessStrategy accessStrategy,
                           CanType formalRValueType,
-                          RValue &&indices,
+                          PreparedArguments &&indices,
                           Expr *indexExprForDiagnostics);
 
   void addMemberVarComponent(SILGenFunction &SGF, SILLocation loc,
@@ -462,8 +462,8 @@ class LValue {
                                    bool isSuper,
                                    AccessStrategy accessStrategy,
                                    CanType formalRValueType,
-                                   RValue &&indices,
-                                   Expr *indexExprForDiagnostics = nullptr);
+                                   PreparedArguments &&indices,
+                                   Expr *indexExprForDiagnostics);
 
   /// Add a subst-to-orig reabstraction component.  That is, given
   /// that this l-value trafficks in values following the substituted

lib/SILGen/RValue.cpp

@@ -39,7 +39,7 @@ static unsigned getTupleSize(CanType t) {
   return 1;
 }
 
-static unsigned getRValueSize(AbstractionPattern pattern, CanType formalType) {
+unsigned RValue::getRValueSize(AbstractionPattern pattern, CanType formalType) {
   if (pattern.isTuple()) {
     unsigned count = 0;
     auto formalTupleType = cast<TupleType>(formalType);
@@ -54,7 +54,7 @@ static unsigned getRValueSize(AbstractionPattern pattern, CanType formalType) {
 }
 
 /// Return the number of rvalue elements in the given canonical type.
-static unsigned getRValueSize(CanType type) {
+unsigned RValue::getRValueSize(CanType type) {
   if (auto tupleType = dyn_cast<TupleType>(type)) {
     unsigned count = 0;
     for (auto eltType : tupleType.getElementTypes())
@@ -367,7 +367,7 @@ static void copyOrInitValuesInto(Initialization *init,
   ManagedValue scalar = implodeTupleValues<KIND>(values, SGF, type, loc);
 
   // This will have just used up the first values in the list, pop them off.
-  values = values.slice(getRValueSize(type));
+  values = values.slice(RValue::getRValueSize(type));
 
   init->copyOrInitValueInto(SGF, loc, scalar, isInit);
   init->finishInitialization(SGF);
@@ -635,9 +635,10 @@ getElementRange(CanTupleType tupleType, unsigned eltIndex) {
   assert(eltIndex < tupleType->getNumElements());
   unsigned begin = 0;
   for (unsigned i = 0; i < eltIndex; ++i) {
-    begin += getRValueSize(tupleType.getElementType(i));
+    begin += RValue::getRValueSize(tupleType.getElementType(i));
   }
-  unsigned end = begin + getRValueSize(tupleType.getElementType(eltIndex));
+  unsigned end =
+    begin + RValue::getRValueSize(tupleType.getElementType(eltIndex));
   return { begin, end };
 }
 

lib/SILGen/RValue.h

@@ -172,6 +172,9 @@ class RValue {
   static RValue forInContext() {
     return RValue(InContext);
   }
+
+  static unsigned getRValueSize(CanType substType);
+  static unsigned getRValueSize(AbstractionPattern origType, CanType substType);
 
   /// Create an RValue to which values will be subsequently added using
   /// addElement(), with the level of tuple expansion in the input specified

lib/SILGen/SILGen.cpp

@@ -1285,7 +1285,9 @@ void SILGenModule::tryEmitPropertyDescriptor(AbstractStorageDecl *decl) {
 
   if (!decl->exportsPropertyDescriptor())
     return;
-  
+
+  PrettyStackTraceDecl stackTrace("emitting property descriptor for", decl);
+
   Type baseTy;
   if (decl->getDeclContext()->isTypeContext()) {
     // TODO: Static properties should eventually be referenceable as