Runtime: Fix dynamic casts to support resilient protocols

If a protocol witness table requires instantiation, the runtime
needs to call the witness table accessor when looking up the
conformance in swift_conformsToProtocol().

We had a bit of code for this already, but it wasn't fully
hooked up. Change IRGen to emit a reference to the witness table
accessor rather than the witness table itself if the witness
table needs instantiation, and add support to the runtime for
calling the accessor.

Author: slavapestov

include/swift/ABI/MetadataValues.h

@@ -170,7 +170,7 @@ struct TypeMetadataRecordFlags {
   constexpr TypeMetadataRecordFlags(int_type Data) : Data(Data) {}
 
   constexpr TypeMetadataRecordKind getTypeKind() const {
-    return TypeMetadataRecordKind((Data >> TypeKindShift) & TypeKindMask);
+    return TypeMetadataRecordKind((Data & TypeKindMask) >> TypeKindShift);
   }
   constexpr TypeMetadataRecordFlags withTypeKind(
                                         TypeMetadataRecordKind ptk) const {
@@ -199,8 +199,8 @@ struct ProtocolConformanceFlags : public TypeMetadataRecordFlags {
                      (Data & ~TypeKindMask) | (int_type(ptk) << TypeKindShift));
   }
   constexpr ProtocolConformanceReferenceKind getConformanceKind() const {
-    return ProtocolConformanceReferenceKind((Data >> ConformanceKindShift)
-                                     & ConformanceKindMask);
+    return ProtocolConformanceReferenceKind((Data & ConformanceKindMask)
+                                     >> ConformanceKindShift);
   }
   constexpr ProtocolConformanceFlags withConformanceKind(
                                   ProtocolConformanceReferenceKind pck) const {

lib/IRGen/GenDecl.cpp

@@ -2174,17 +2174,27 @@ llvm::Constant *IRGenModule::emitProtocolConformances() {
                   getPointerAlignment(), ProtocolDescriptorStructTy);
     auto typeEntity = getTypeEntityInfo(*this,
                                     conformance->getType()->getCanonicalType());
-    auto flags = typeEntity.flags
-        .withConformanceKind(ProtocolConformanceReferenceKind::WitnessTable);
-
-    // If the conformance is in this object's table, then the witness table
-    // should also be in this object file, so we can always directly reference
-    // it.
-    // TODO: Should use accessor kind for lazy conformances
-    // TODO: Produce a relative reference to a private generator function
-    // if the witness table requires lazy initialization, instantiation, or
-    // conditional conformance checking.
-    auto witnessTableVar = getAddrOfWitnessTable(conformance);
+    auto flags = typeEntity.flags;
+
+    llvm::Constant *witnessTableVar;
+
+    if (!isResilient(conformance->getProtocol(),
+                     ResilienceExpansion::Maximal)) {
+      flags = flags.withConformanceKind(
+          ProtocolConformanceReferenceKind::WitnessTable);
+
+      // If the conformance is in this object's table, then the witness table
+      // should also be in this object file, so we can always directly reference
+      // it.
+      witnessTableVar = getAddrOfWitnessTable(conformance);
+    } else {
+      flags = flags.withConformanceKind(
+          ProtocolConformanceReferenceKind::WitnessTableAccessor);
+
+      witnessTableVar = getAddrOfWitnessTableAccessFunction(
+          conformance, ForDefinition);
+    }
+
     auto witnessTableRef =
       ConstantReference(witnessTableVar, ConstantReference::Direct);
 

stdlib/public/runtime/ProtocolConformance.cpp

@@ -637,15 +637,11 @@ swift::swift_conformsToProtocol(const Metadata *type,
           C.cacheFailure(metadata, P);
         }
 
-      // If the record provides a nondependent witness table for all instances
-      // of a generic type, cache it for the generic pattern.
       // TODO: "Nondependent witness table" probably deserves its own flag.
       // An accessor function might still be necessary even if the witness table
       // can be shared.
       } else if (record.getTypeKind()
-                   == TypeMetadataRecordKind::UniqueNominalTypeDescriptor
-                 && record.getConformanceKind()
-                   == ProtocolConformanceReferenceKind::WitnessTable) {
+                   == TypeMetadataRecordKind::UniqueNominalTypeDescriptor) {
 
         auto R = record.getNominalTypeDescriptor();
         auto P = record.getProtocol();
@@ -658,7 +654,20 @@ swift::swift_conformsToProtocol(const Metadata *type,
           continue;
 
         // Store the type-protocol pair in the cache.
-        C.cacheSuccess(R, P, record.getStaticWitnessTable());
+        switch (record.getConformanceKind()) {
+        case ProtocolConformanceReferenceKind::WitnessTable:
+          // If the record provides a nondependent witness table for all
+          // instances of a generic type, cache it for the generic pattern.
+          C.cacheSuccess(R, P, record.getStaticWitnessTable());
+          break;
+
+        case ProtocolConformanceReferenceKind::WitnessTableAccessor:
+          // If the record provides a dependent witness table accessor,
+          // cache the result for the instantiated type metadata.
+          C.cacheSuccess(type, P, record.getWitnessTable(type));
+          break;
+
+        }
       }
     }
   }

test/Inputs/resilient_protocol.swift

@@ -15,3 +15,9 @@ extension OtherResilientProtocol {
     set { x = newValue }
   }
 }
+
+public protocol ResilientBaseProtocol {
+  func requirement() -> Int
+}
+
+public protocol ResilientDerivedProtocol : ResilientBaseProtocol {}

test/Interpreter/protocol_resilience.swift

@@ -10,9 +10,6 @@
 // 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
 
@@ -27,6 +24,8 @@ func increment(_ x: inout Int, by: Int) {
 
 struct OtherConformingType : OtherResilientProtocol { }
 
+// Ensure we can call materializeForSet defined in a protocol extension
+// from a different resilience domain.
 ResilientProtocolTestSuite.test("PropertyInProtocolExtension") {
   var o = OtherConformingType()
 
@@ -36,4 +35,22 @@ ResilientProtocolTestSuite.test("PropertyInProtocolExtension") {
   expectEqual(OtherConformingType.staticPropertyInExtension, 12)
 }
 
+struct DerivedConformingType : ResilientDerivedProtocol {
+  func requirement() -> Int { return 42 }
+}
+
+// Ensure dynamic casts to resilient types work.
+func callBaseRequirement(t: ResilientBaseProtocol) -> Int {
+  return t.requirement()
+}
+
+@_semantics("optimize.sil.never")
+func castToDerivedProtocol<T>(t: T) -> Int {
+  return callBaseRequirement(t: t as! ResilientDerivedProtocol)
+}
+
+ResilientProtocolTestSuite.test("DynamicCastToResilientProtocol") {
+  expectEqual(castToDerivedProtocol(t: DerivedConformingType()), 42)
+}
+
 runAllTests()