SILGen: Allow direct calls to materializeForSet defined in a protocol extension

Now that we apply the callback with the correct generic signature, the
assert can go away. It was being triggered if the protocol extension was
defined in a different resilience domain; otherwise we prefer direct
access anyway.

Note that materializeForSet now has to be able to re-abstract Self when
invoking the callback, since we might have to go from a thin metatype
to a thick metatype.

Author: slavapestov

lib/SILGen/SILGenApply.cpp

@@ -4388,11 +4388,6 @@ emitMaterializeForSetAccessor(SILLocation loc, SILDeclRef materializeForSet,
   // Scope any further writeback just within this operation.
   WritebackScope writebackScope(*this);
 
-  assert(!materializeForSet.getDecl()
-           ->getDeclContext()->getAsProtocolExtensionContext() &&
-         "direct use of materializeForSet from a protocol extension is"
-         " probably a miscompile");
-
   Callee callee = emitSpecializedAccessorFunctionRef(*this, loc,
                                                      materializeForSet,
                                                      substitutions, selfValue,

lib/SILGen/SILGenLValue.cpp

@@ -989,6 +989,11 @@ namespace {
           if (base.getType().isAddress()) {
             baseAddress = base.getValue();
           } else {
+            AbstractionPattern origSelfType(materialized.genericSig,
+                                            materialized.origSelfType);
+            base = gen.emitSubstToOrigValue(loc, base, origSelfType,
+                                            baseFormalType);
+
             baseAddress = gen.emitTemporaryAllocation(loc, base.getType());
             gen.B.createStore(loc, base.getValue(), baseAddress);
           }

test/Inputs/resilient_protocol.swift

@@ -2,3 +2,16 @@
 public protocol OtherResilientProtocol {
 }
 
+var x: Int = 0
+
+extension OtherResilientProtocol {
+  public var propertyInExtension: Int {
+    get { return x }
+    set { x = newValue }
+  }
+
+  public static var staticPropertyInExtension: Int {
+    get { return x }
+    set { x = newValue }
+  }
+}

test/Interpreter/protocol_resilience.swift

@@ -0,0 +1,46 @@
+// RUN: rm -rf %t && mkdir %t
+// RUN: %target-build-swift -emit-library -Xfrontend -enable-resilience -c %S/../Inputs/resilient_protocol.swift -o %t/resilient_protocol.o
+// RUN: %target-build-swift -emit-module -Xfrontend -enable-resilience -c %S/../Inputs/resilient_protocol.swift -o %t/resilient_protocol.o
+// RUN: %target-build-swift %s -Xlinker %t/resilient_protocol.o -I %t -L %t -o %t/main
+// RUN: %target-run %t/main
+// REQUIRES: executable_test
+
+//
+// Note: protocol resilience in the sense of resiliently adding new
+// requirements with default implementations is actually tested in
+// validation-test/Evolution/test_protocol_*.
+//
+// This test just ensures we can call materializeForSet defined in a
+// protocol extension from a different resilience domain.
+//
+
+import StdlibUnittest
+
+// Also import modules which are used by StdlibUnittest internally. This
+// workaround is needed to link all required libraries in case we compile
+// StdlibUnittest with -sil-serialize-all.
+import SwiftPrivate
+#if _runtime(_ObjC)
+import ObjectiveC
+#endif
+
+import resilient_protocol
+
+var ResilientProtocolTestSuite = TestSuite("ResilientProtocol")
+
+func increment(x: inout Int, by: Int) {
+  x += by
+}
+
+struct OtherConformingType : OtherResilientProtocol { }
+
+ResilientProtocolTestSuite.test("PropertyInProtocolExtension") {
+  var o = OtherConformingType()
+
+  increment(&o.propertyInExtension, by: 5)
+  increment(&OtherConformingType.staticPropertyInExtension, by: 7)
+
+  expectEqual(OtherConformingType.staticPropertyInExtension, 12)
+}
+
+runAllTests()

test/SILGen/protocol_resilience.swift

@@ -1,4 +1,6 @@
-// RUN: %target-swift-frontend -emit-silgen -enable-resilience %s | FileCheck %s --check-prefix=CHECK --check-prefix=GLOBAL
+// RUN: %target-swift-frontend -I %S/../Inputs -enable-source-import -emit-silgen -enable-resilience %s | FileCheck %s --check-prefix=CHECK --check-prefix=GLOBAL
+
+import resilient_protocol
 
 prefix operator ~~~ {}
 infix operator <*> {}
@@ -219,6 +221,25 @@ extension ReabstractSelfBase {
 
 final class X : ReabstractSelfRefined {}
 
+func inoutFunc(x: inout Int) {}
+
+// CHECK-LABEL: sil hidden @_TF19protocol_resilience22inoutResilientProtocolFRP18resilient_protocol22OtherResilientProtocol_T_
+func inoutResilientProtocol(x: inout OtherResilientProtocol) {
+  // CHECK: function_ref @_TFE18resilient_protocolPS_22OtherResilientProtocolm19propertyInExtensionSi
+  inoutFunc(&x.propertyInExtension)
+}
+
+struct OtherConformingType : OtherResilientProtocol {}
+
+// CHECK-LABEL: sil hidden @_TF19protocol_resilience22inoutResilientProtocolFRVS_19OtherConformingTypeT_
+func inoutResilientProtocol(x: inout OtherConformingType) {
+  // CHECK: function_ref @_TFE18resilient_protocolPS_22OtherResilientProtocolm19propertyInExtensionSi
+  inoutFunc(&x.propertyInExtension)
+
+  // CHECK: function_ref @_TZFE18resilient_protocolPS_22OtherResilientProtocolm25staticPropertyInExtensionSi
+  inoutFunc(&OtherConformingType.staticPropertyInExtension)
+}
+
 // Protocol is not public -- doesn't need default witness table
 protocol InternalProtocol {
   func f()