Change the signature of materializeForSet to return an

optional callback; retrofit existing implementations.

There's a lot of unpleasant traffic in raw pointers here
which I'm going to try to clean up.

Swift SVN r24123

Author: rjmccall

lib/AST/Decl.cpp

@@ -2821,7 +2821,7 @@ DeclName AbstractFunctionDecl::getEffectiveFullName() const {
     if (auto afd = func->getAccessorStorageDecl()) {
       auto &ctx = getASTContext();
       auto subscript = dyn_cast<SubscriptDecl>(afd);
-      switch (func->getAccessorKind()) {
+      switch (auto accessorKind = func->getAccessorKind()) {
         case AccessorKind::NotAccessor:
           break;
 
@@ -2839,6 +2839,10 @@ DeclName AbstractFunctionDecl::getEffectiveFullName() const {
           SmallVector<Identifier, 4> argNames;
           // The implicit value/buffer parameter.
           argNames.push_back(Identifier());
+          // The callback storage parameter on materializeForSet.
+          if (accessorKind  == AccessorKind::IsMaterializeForSet)
+            argNames.push_back(Identifier());
+          // The subscript index parameters.
           if (subscript) {
             argNames.append(subscript->getFullName().getArgumentNames().begin(),
                             subscript->getFullName().getArgumentNames().end());

lib/AST/Verifier.cpp

@@ -2371,12 +2371,12 @@ struct ASTNodeBase {};
     void checkSourceRanges(Pattern *P) {
       PrettyStackTracePattern debugStack(Ctx, "verifying ranges", P);
 
-      if (!P->getSourceRange().isValid()) {
-        // We don't care about source ranges on implicitly-generated
-        // patterns.
-        if (P->isImplicit())
-          return;
+      // We don't care about source ranges on implicitly-generated
+      // patterns.
+      if (P->isImplicit())
+        return;
 
+      if (!P->getSourceRange().isValid()) {
         Out << "invalid source range for pattern: ";
         P->print(Out);
         Out << "\n";

lib/SILGen/LValue.h

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

lib/SILGen/SILGenApply.cpp

@@ -2715,7 +2715,8 @@ emitMaterializeForSetAccessor(SILLocation loc, SILDeclRef materializeForSet,
                               ArrayRef<Substitution> substitutions,
                               RValueSource &&selfValue,
                               bool isSuper, bool isDirectUse,
-                              RValue &&subscripts, SILValue buffer) {
+                              RValue &&subscripts, SILValue buffer,
+                              SILValue callbackStorage) {
 
   Callee callee = emitSpecializedAccessorFunctionRef(*this, loc,
                                                      materializeForSet,
@@ -2730,37 +2731,36 @@ emitMaterializeForSetAccessor(SILLocation loc, SILDeclRef materializeForSet,
     accessType = cast<AnyFunctionType>(accessType.getResult());
   }
 
-  ManagedValue mbuffer = {
-    B.createAddressToPointer(loc, buffer,
-                             SILType::getRawPointerType(getASTContext())),
-    CleanupHandle::invalid()
-  };
-
-  // (buffer)  or (buffer, indices) ->
+  // (buffer, callbackStorage)  or (buffer, callbackStorage, indices) ->
   RValue args = [&] {
+    SmallVector<ManagedValue, 4> elts;
+
+    auto bufferPtr =
+      B.createAddressToPointer(loc, buffer,
+                               SILType::getRawPointerType(getASTContext()));
+    elts.push_back(ManagedValue::forUnmanaged(bufferPtr));
+
+    elts.push_back(ManagedValue::forLValue(callbackStorage));
+
     if (subscripts) {
-      SmallVector<ManagedValue, 4> elts;
-      elts.push_back(mbuffer);
       std::move(subscripts).getAll(elts);
-      return RValue(elts, accessType.getInput());
-    } else {
-      return RValue(mbuffer, accessType.getInput());
     }
+    return RValue(elts, accessType.getInput());
   }();
   emission.addCallSite(loc, RValueSource(loc, std::move(args)),
                        accessType.getResult());
-  // (buffer, i1)
-  SILValue pointerAndNeedsWriteback = emission.apply().getUnmanagedValue();
+  // (buffer, optionalCallback)
+  SILValue pointerAndOptionalCallback = emission.apply().getUnmanagedValue();
 
   // Project out the materialized address.
-  SILValue address = B.createTupleExtract(loc, pointerAndNeedsWriteback, 0);
+  SILValue address = B.createTupleExtract(loc, pointerAndOptionalCallback, 0);
   address = B.createPointerToAddress(loc, address, buffer.getType());
 
-  // Project out the needsWriteback flag.
-  SILValue needsWriteback =
-    B.createTupleExtract(loc, pointerAndNeedsWriteback, 1);
+  // Project out the optional callback.
+  SILValue optionalCallback =
+    B.createTupleExtract(loc, pointerAndOptionalCallback, 1);
 
-  return { address, needsWriteback };
+  return { address, optionalCallback };
 }
 
 SILDeclRef SILGenFunction::getAddressorDeclRef(AbstractStorageDecl *storage,

lib/SILGen/SILGenFunction.h

@@ -722,7 +722,7 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
                                 RValueSource &&optionalSelfValue,
                                 bool isSuper, bool isDirectAccessorUse,
                                 RValue &&optionalSubscripts,
-                                SILValue buffer);
+                                SILValue buffer, SILValue callbackStorage);
 
   SILDeclRef getAddressorDeclRef(AbstractStorageDecl *decl,
                                  AccessKind accessKind,