Merge pull request #15084 from DougGregor/runtime-conformance-null-descriptor-4.2

[4.2] [Runtime] Don't use NULL as a conformance cache key.

Author: DougGregor

stdlib/public/runtime/ProtocolConformance.cpp

@@ -166,7 +166,9 @@ namespace {
     const ProtocolDescriptor *Proto;
 
     ConformanceCacheKey(const void *type, const ProtocolDescriptor *proto)
-      : Type(type), Proto(proto) {}
+        : Type(type), Proto(proto) {
+      assert(type);
+    }
   };
 
   struct ConformanceCacheEntry {
@@ -331,6 +333,15 @@ struct ConformanceCacheResult {
   }
 };
 
+/// Retrieve the type key from the given metadata, to be used when looking
+/// into the conformance cache.
+static const void *getConformanceCacheTypeKey(const Metadata *type) {
+  if (auto description = type->getNominalTypeDescriptor())
+    return description;
+
+  return type;
+}
+
 /// Search for a witness table in the ConformanceCache.
 static
 ConformanceCacheResult
@@ -385,10 +396,10 @@ searchInConformanceCache(const Metadata *type,
     // For generic and resilient types, nondependent conformances
     // are keyed by the nominal type descriptor rather than the
     // metadata, so try that.
-    const auto *description = type->getNominalTypeDescriptor();
+    auto typeKey = getConformanceCacheTypeKey(type);
 
     // Hash and lookup the type-protocol pair in the cache.
-    if (auto *Value = C.findCached(description, protocol)) {
+    if (auto *Value = C.findCached(typeKey, protocol)) {
       if (Value->isSuccessful())
         return ConformanceCacheResult::cachedSuccess(Value->getWitnessTable());
 
@@ -435,7 +446,7 @@ bool isRelatedType(const Metadata *type, const void *candidate,
     if (!candidateIsMetadata) {
       const auto *description = type->getNominalTypeDescriptor();
       auto candidateDescription =
-      static_cast<const NominalTypeDescriptor *>(candidate);
+        static_cast<const NominalTypeDescriptor *>(candidate);
       if (description && description->isEqual(candidateDescription))
         return true;
     }
@@ -564,7 +575,7 @@ swift::swift_conformsToProtocol(const Metadata * const type,
         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(type->getNominalTypeDescriptor(), P,
+          C.cacheSuccess(getConformanceCacheTypeKey(type), P,
                          record.getStaticWitnessTable());
           break;
 

test/Interpreter/SDK/objc_dynamic_subclass_protocol_lookup.swift

@@ -0,0 +1,81 @@
+// RUN: %target-run-simple-swift
+// REQUIRES: executable_test
+
+
+// REQUIRES: objc_interop
+
+import StdlibUnittest
+import Foundation
+
+protocol P { }
+protocol Q { }
+
+class Supermodel : NSObject { }
+
+class Model1 : Supermodel {
+  @objc dynamic var name = ""
+}
+
+class Model2 : NSObject, Q {
+  @objc dynamic var name = ""
+}
+
+
+extension Supermodel: P { }
+
+var kvoContext = 0
+
+class Observer: NSObject {
+  let model1 = Model1()
+  let model2 = Model2()
+
+  override init() {
+    super.init()
+    model1.addObserver(self, forKeyPath: "name", options: [], context: &kvoContext)
+    model2.addObserver(self, forKeyPath: "name", options: [], context: &kvoContext)
+  }
+
+  deinit {
+    model1.removeObserver(self, forKeyPath: "name")
+    model2.removeObserver(self, forKeyPath: "name")
+  }
+}
+
+let allTests = TestSuite("Dynamic subclasses conformance lookups")
+
+allTests.test("Lookup via dynamic subclasses") {
+  let observer = Observer()
+
+  // Check via "AnyObject"
+  let model1obj: AnyObject = observer.model1
+  let model2obj: AnyObject = observer.model2
+
+  expectTrue(model1obj is P)
+  expectFalse(model1obj is Q)
+  expectFalse(model2obj is P)
+  expectTrue(model2obj is Q)
+
+  expectNotNil(model1obj as? P)
+  expectNil(model1obj as? Q)
+  expectNil(model2obj as? P)
+  expectNotNil(model2obj as? Q)
+  
+  // Check via "Any"
+  let model1: Any = observer.model1
+  let model2: Any = observer.model2
+
+  expectTrue(model1 is P)
+  expectFalse(model1 is Q)
+  expectFalse(model2 is P)
+  expectTrue(model2 is Q)
+
+  expectNotNil(model1 as? P)
+  expectNil(model1 as? Q)
+  expectNil(model2 as? P)
+  expectNotNil(model2 as? Q)
+  
+  print(model1)
+  print(model2)
+}
+
+runAllTests()