SILGen: Introduce MaterializedLValue abstraction

This is used when materializing an LValue to share state between
the read and write phases of the access, replacing the 'temporary'
and 'extraInfo' parameters that were previously being passed around.

It adds two new fields, origSelfType and genericSig, which will be
used in an upcoming patch to actually apply the callback with the
current generic signature.

This will finally allow us to make use of materializeForSet
implementations in protocol extensions, which is a prerequisite
for enabling resilient default implementations of property and
subscript requirements.

Author: slavapestov

lib/SILGen/LValue.h

@@ -258,8 +258,9 @@ class LogicalPathComponent : public PathComponent {
   ///
   /// \param base - always an address, but possibly an r-value
   virtual void writeback(SILGenFunction &gen, SILLocation loc,
-                         ManagedValue base, ManagedValue temporary,
-                         ArrayRef<SILValue> otherInfo, bool isFinal);
+                         ManagedValue base,
+                         MaterializedLValue materialized,
+                         bool isFinal);
 };
 
 inline LogicalPathComponent &PathComponent::asLogical() {

lib/SILGen/SILGenApply.cpp

@@ -4378,7 +4378,7 @@ SILGenFunction::getMaterializeForSetDeclRef(AbstractStorageDecl *storage,
                     /*foreign*/ false);
 }
 
-std::pair<SILValue, SILValue> SILGenFunction::
+MaterializedLValue SILGenFunction::
 emitMaterializeForSetAccessor(SILLocation loc, SILDeclRef materializeForSet,
                               ArrayRef<Substitution> substitutions,
                               ArgumentSource &&selfValue,
@@ -4400,6 +4400,7 @@ emitMaterializeForSetAccessor(SILLocation loc, SILDeclRef materializeForSet,
   bool hasCaptures = callee.hasCaptures();
   bool hasSelf = (bool)selfValue;
   CanAnyFunctionType accessType = callee.getSubstFormalType();
+  CanAnyFunctionType origAccessType = callee.getOrigFormalType();
 
   CallEmission emission(*this, std::move(callee), std::move(writebackScope));
   // Self ->
@@ -4440,7 +4441,16 @@ emitMaterializeForSetAccessor(SILLocation loc, SILDeclRef materializeForSet,
   // Project out the optional callback.
   SILValue optionalCallback = results[1].getUnmanagedValue();
 
-  return { address, optionalCallback };
+  CanType origSelfType = origAccessType->getInput()
+      ->getRValueInstanceType()
+      ->getCanonicalType();
+  CanGenericSignature genericSig;
+  if (auto genericFnType = dyn_cast<GenericFunctionType>(origAccessType))
+    genericSig = genericFnType.getGenericSignature();
+
+  return MaterializedLValue(ManagedValue::forUnmanaged(address),
+                            origSelfType, genericSig,
+                            optionalCallback, callbackStorage);
 }
 
 SILDeclRef SILGenFunction::getAddressorDeclRef(AbstractStorageDecl *storage,

lib/SILGen/SILGenFunction.h

@@ -268,6 +268,34 @@ enum class CaptureEmission {
   PartialApplication,
 };
 
+/// Represents an LValue opened for mutating access.
+///
+/// This is used by LogicalPathComponent::getMaterialized() and
+/// SILGenFunction::emitMaterializeForSetAccessor().
+struct MaterializedLValue {
+  ManagedValue temporary;
+
+  // Only set if a callback is required
+  CanType origSelfType;
+  CanGenericSignature genericSig;
+  SILValue callback;
+  SILValue callbackStorage;
+
+  MaterializedLValue() {}
+  explicit MaterializedLValue(ManagedValue temporary)
+    : temporary(temporary) {}
+  MaterializedLValue(ManagedValue temporary,
+                     CanType origSelfType,
+                     CanGenericSignature genericSig,
+                     SILValue callback,
+                     SILValue callbackStorage)
+    : temporary(temporary),
+      origSelfType(origSelfType),
+      genericSig(genericSig),
+      callback(callback),
+      callbackStorage(callbackStorage) {}
+};
+
 /// SILGenFunction - an ASTVisitor for producing SIL from function bodies.
 class LLVM_LIBRARY_VISIBILITY SILGenFunction
   : public ASTVisitor<SILGenFunction>
@@ -1071,7 +1099,7 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
 
   SILDeclRef getMaterializeForSetDeclRef(AbstractStorageDecl *decl,
                                          bool isDirectAccessorUse);  
-  std::pair<SILValue, SILValue>
+  MaterializedLValue
   emitMaterializeForSetAccessor(SILLocation loc, SILDeclRef materializeForSet,
                                 ArrayRef<Substitution> substitutions,
                                 ArgumentSource &&optionalSelfValue,

lib/SILGen/SILGenLValue.cpp

@@ -45,8 +45,7 @@ struct LLVM_LIBRARY_VISIBILITY LValueWriteback {
   SILLocation loc;
   std::unique_ptr<LogicalPathComponent> component;
   ManagedValue base;
-  ManagedValue temp;
-  SmallVector<SILValue, 2> ExtraInfo;
+  MaterializedLValue materialized;
   CleanupHandle cleanup;
 
   ~LValueWriteback() {}
@@ -56,13 +55,12 @@ struct LLVM_LIBRARY_VISIBILITY LValueWriteback {
   LValueWriteback() = default;
   LValueWriteback(SILLocation loc,
                   std::unique_ptr<LogicalPathComponent> &&comp,
-                  ManagedValue base, ManagedValue temp,
-                  ArrayRef<SILValue> extraInfo,
+                  ManagedValue base,
+                  MaterializedLValue materialized,
                   CleanupHandle cleanup)
-    : loc(loc), component(std::move(comp)), base(base), temp(temp),
-      cleanup(cleanup) {
-    ExtraInfo.append(extraInfo.begin(), extraInfo.end());
-  }
+    : loc(loc), component(std::move(comp)),
+      base(base), materialized(materialized),
+      cleanup(cleanup) { }
 
   void diagnoseConflict(const LValueWriteback &rhs, SILGenFunction &SGF) const {
     // If the two writebacks we're comparing are of different kinds (e.g.
@@ -82,7 +80,7 @@ struct LLVM_LIBRARY_VISIBILITY LValueWriteback {
 
   void performWriteback(SILGenFunction &gen, bool isFinal) {
     Scope S(gen.Cleanups, CleanupLocation::get(loc));
-    component->writeback(gen, loc, base, temp, ExtraInfo, isFinal);
+    component->writeback(gen, loc, base, materialized, isFinal);
   }
 };
 }
@@ -116,16 +114,16 @@ void SILGenFunction::freeWritebackStack() {
 static void pushWriteback(SILGenFunction &gen,
                           SILLocation loc,
                           std::unique_ptr<LogicalPathComponent> &&comp,
-                          ManagedValue base, ManagedValue temp,
-                          ArrayRef<SILValue> extraInfo) {
+                          ManagedValue base,
+                          MaterializedLValue materialized) {
   assert(gen.InWritebackScope);
 
   // Push a cleanup to execute the writeback consistently.
   auto &stack = gen.getWritebackStack();
   gen.Cleanups.pushCleanup<LValueWritebackCleanup>(stack.size());
   auto cleanup = gen.Cleanups.getTopCleanup();
 
-  stack.emplace_back(loc, std::move(comp), base, temp, extraInfo, cleanup);
+  stack.emplace_back(loc, std::move(comp), base, materialized, cleanup);
 }
 
 //===----------------------------------------------------------------------===//
@@ -244,18 +242,23 @@ ManagedValue LogicalPathComponent::getMaterialized(SILGenFunction &gen,
                                                 std::move(*this));
 
   // Push a writeback for the temporary.
-  pushWriteback(gen, loc, std::move(clonedComponent), base, temporary, {});
+  pushWriteback(gen, loc, std::move(clonedComponent), base,
+                MaterializedLValue(temporary));
   return temporary.borrow();
 }
 
 void LogicalPathComponent::writeback(SILGenFunction &gen, SILLocation loc,
-                                     ManagedValue base, ManagedValue temporary,
-                                     ArrayRef<SILValue> otherInfo, bool isFinal) {
-  assert(otherInfo.empty() && "unexpected otherInfo parameter!");
+                                     ManagedValue base,
+                                     MaterializedLValue materialized,
+                                     bool isFinal) {
+  assert(!materialized.callback &&
+         "unexpected materialized lvalue with callback!");
 
   // Load the value from the temporary unless the type is address-only
   // and this is the final use, in which case we can just consume the
   // value as-is.
+  auto temporary = materialized.temporary;
+
   assert(temporary.getType().isAddress());
   auto &tempTL = gen.getTypeLowering(temporary.getType());
   if (!tempTL.isAddressOnly() || !isFinal) {
@@ -859,52 +862,44 @@ namespace {
 
       auto args = std::move(*this).prepareAccessorArgs(gen, loc, borrowedBase,
                                                        materializeForSet);
-      auto addressAndCallback =
+      MaterializedLValue materialized =
         gen.emitMaterializeForSetAccessor(loc, materializeForSet, substitutions,
                                           std::move(args.base), IsSuper,
                                           IsDirectAccessorUse,
                                           std::move(args.subscripts),
                                           buffer, callbackStorage);
 
-      SILValue address = addressAndCallback.first;
-
       // Mark a value-dependence on the base.  We do this regardless
       // of whether the base is trivial because even a trivial base
       // may be value-dependent on something non-trivial.
       if (base) {
-        address = gen.B.createMarkDependence(loc, address, base.getValue());
+        SILValue temporary = materialized.temporary.getValue();
+        materialized.temporary = ManagedValue::forUnmanaged(
+            gen.B.createMarkDependence(loc, temporary, base.getValue()));
       }
 
-      SILValue extraInfo[] = {
-        addressAndCallback.second,
-        callbackStorage,
-      };
-
       // TODO: maybe needsWriteback should be a thin function pointer
       // to which we pass the base?  That would let us use direct
       // access for stored properties with didSet.
-      pushWriteback(gen, loc, std::move(clonedComponent), base,
-                    ManagedValue::forUnmanaged(address), extraInfo);
+      pushWriteback(gen, loc, std::move(clonedComponent), base, materialized);
 
-      return ManagedValue::forLValue(address);
+      return ManagedValue::forLValue(materialized.temporary.getValue());
     }
 
     void writeback(SILGenFunction &gen, SILLocation loc,
-                   ManagedValue base, ManagedValue temporary,
-                   ArrayRef<SILValue> extraInfo, bool isFinal) override {
-      // If we don't have extraInfo, we don't have to conditionalize
+                   ManagedValue base, MaterializedLValue materialized,
+                   bool isFinal) override {
+      // If we don't have a callback, we don't have to conditionalize
       // the writeback.
-      if (extraInfo.empty()) {
-        LogicalPathComponent::writeback(gen, loc, base, temporary, extraInfo,
+      if (!materialized.callback) {
+        LogicalPathComponent::writeback(gen, loc,
+                                        base, materialized,
                                         isFinal);
         return;
       }
 
-      // Otherwise, extraInfo holds an optional callback and the
+      // Otherwise, 'materialized' holds an optional callback and the
       // callback storage.
-      assert(extraInfo.size() == 2);
-      SILValue optionalCallback = extraInfo[0];
-      SILValue callbackStorage = extraInfo[1];
 
       // Mark the writeback as auto-generated so that we don't get
       // warnings if we manage to devirtualize materializeForSet.
@@ -914,7 +909,7 @@ namespace {
 
       SILBasicBlock *contBB = gen.createBasicBlock();
       SILBasicBlock *writebackBB = gen.createBasicBlock(gen.B.getInsertionBB());
-      gen.B.createSwitchEnum(loc, optionalCallback, /*defaultDest*/ nullptr,
+      gen.B.createSwitchEnum(loc, materialized.callback, /*defaultDest*/ nullptr,
                              { { ctx.getOptionalSomeDecl(), writebackBB },
                                { ctx.getOptionalNoneDecl(), contBB } });
 
@@ -926,8 +921,8 @@ namespace {
           SILType::getPrimitiveObjectType(TupleType::getEmpty(ctx));
 
         SILType callbackSILType = gen.getLoweredType(
-                  optionalCallback->getType().getSwiftRValueType()
-                                            .getAnyOptionalObjectType());
+                  materialized.callback->getType().getSwiftRValueType()
+                                                  .getAnyOptionalObjectType());
 
         // The callback is a BB argument from the switch_enum.
         SILValue callback =
@@ -959,12 +954,14 @@ namespace {
         }
 
         SILValue temporaryPointer =
-          gen.B.createAddressToPointer(loc, temporary.getValue(),
+          gen.B.createAddressToPointer(loc,
+                                       materialized.temporary.getValue(),
                                        SILType::getRawPointerType(ctx));
 
+        // Apply the callback.
         gen.B.createApply(loc, callback, {
                             temporaryPointer,
-                            callbackStorage,
+                            materialized.callbackStorage,
                             baseAddress,
                             baseMetatype
                           }, false);
@@ -1119,8 +1116,9 @@ namespace {
     }
 
     void writeback(SILGenFunction &gen, SILLocation loc,
-                   ManagedValue base, ManagedValue temporary,
-                   ArrayRef<SILValue> otherInfo, bool isFinal) override {
+                   ManagedValue base,
+                   MaterializedLValue materialized,
+                   bool isFinal) override {
       // If this is final, we can consume the owner (stored as
       // 'base').  If it isn't, we actually need to retain it, because
       // we've still got a release active.
@@ -1194,7 +1192,7 @@ namespace {
         std::unique_ptr<LogicalPathComponent>
           component(new UnpinPseudoComponent(getTypeData()));
         pushWriteback(gen, loc, std::move(component), result.second,
-                      ManagedValue(), {});
+                      MaterializedLValue());
         return result.first;
       }
       }