[Runtime] Fix swift_conformsToProtocol crashing on conformances to unavailable classes.

An extension on a class creates a conformance record that's always visible even when that class is not present at runtime. In that case, the type pointer in the conformance record is NULL. The runtime did not like this, and crashed. This fixes it to ignore such records instead.

rdar://problem/54054895

Author: mikeash

stdlib/public/runtime/ProtocolConformance.cpp

@@ -145,14 +145,15 @@ ProtocolConformanceDescriptor::getCanonicalTypeMetadata() const {
 
   case TypeReferenceKind::DirectTypeDescriptor:
   case TypeReferenceKind::IndirectTypeDescriptor: {
-    auto anyType = getTypeDescriptor();
-    if (auto type = dyn_cast<TypeContextDescriptor>(anyType)) {
-      if (!type->isGeneric()) {
-        if (auto accessFn = type->getAccessFunction())
-          return accessFn(MetadataState::Abstract).Value;
+    if (auto anyType = getTypeDescriptor()) {
+      if (auto type = dyn_cast<TypeContextDescriptor>(anyType)) {
+        if (!type->isGeneric()) {
+          if (auto accessFn = type->getAccessFunction())
+            return accessFn(MetadataState::Abstract).Value;
+        }
+      } else if (auto protocol = dyn_cast<ProtocolDescriptor>(anyType)) {
+        return _getSimpleProtocolTypeMetadata(protocol);
       }
-    } else if (auto protocol = dyn_cast<ProtocolDescriptor>(anyType)) {
-      return _getSimpleProtocolTypeMetadata(protocol);
     }
 
     return nullptr;

test/Interpreter/availability_weak_linking.swift

@@ -2,15 +2,18 @@
 // RUN: cp -R %S/Inputs/FakeUnavailableObjCFramework.framework %t
 // RUN: %target-clang -dynamiclib %S/Inputs/FakeUnavailableObjCFramework.m -fmodules -F %t -framework Foundation -o %t/FakeUnavailableObjCFramework.framework/FakeUnavailableObjCFramework
 // RUN: %target-codesign %t/FakeUnavailableObjCFramework.framework/FakeUnavailableObjCFramework
-// RUN: %target-build-swift -F %t %s -o %t/UseWeaklinkedUnavailableObjCFramework
-// RUN: %target-build-swift -O -F %t %s -o %t/UseWeaklinkedUnavailableObjCFramework.opt
+// RUN: %target-build-swift-dylib(%t/%target-library-name(FakeUnavailableSwiftDylib)) -emit-module -emit-module-path %t/FakeUnavailableSwiftDylib.swiftmodule %S/Inputs/FakeUnavailableSwiftDylib.swift
+// RUN: %target-codesign %t/%target-library-name(FakeUnavailableSwiftDylib)
+// RUN: %target-build-swift %t/%target-library-name(FakeUnavailableSwiftDylib) -I %t -F %t %s -o %t/UseWeaklinkedUnavailableObjCFramework
+// RUN: %target-build-swift -O %t/%target-library-name(FakeUnavailableSwiftDylib) -I %t -F %t %s -o %t/UseWeaklinkedUnavailableObjCFramework.opt
 
 // These tests emulate deploying back to an older OS where newer APIs are not
 // available by linking to an Objective-C framework where APIs have been
 // annotated to only be available in the far future (version 1066.0 of all
 // platforms) and then moving the framework aside so that it can't be found
 // at run time.
 // RUN: mv %t/FakeUnavailableObjCFramework.framework %t/FakeUnavailableObjCFramework-MovedAside.framework
+// RUN: mv %t/%target-library-name(FakeUnavailableSwiftDylib) %t/%target-library-name(FakeUnavailableSwiftDylib)-MovedAside
 
 // RUN: %target-codesign %t/UseWeaklinkedUnavailableObjCFramework
 // RUN: %target-codesign %t/UseWeaklinkedUnavailableObjCFramework.opt
@@ -24,6 +27,7 @@ import StdlibUnittest
 
 
 import FakeUnavailableObjCFramework
+import FakeUnavailableSwiftDylib
 import Foundation
 
 // CHECK: Running
@@ -154,6 +158,59 @@ protocol SomeSwiftProtocol { }
 @available(OSX 1066.0, iOS 1066.0, watchOS 1066.0, tvOS 1066.0, *)
 extension UnavailableObjCClass : SomeSwiftProtocol {
 }
+@available(OSX 1066.0, iOS 1066.0, watchOS 1066.0, tvOS 1066.0, *)
+extension UnavailableSwiftClass : SomeSwiftProtocol {
+}
+
+func checkSwiftProtocolConformance() {
+  // Make sure the runtime doesn't crash in the presence of a conformance
+  // record for a class that doesn't exsit at runtime.
+  let x: Any = 42
+  _blackHole(x as? SomeSwiftProtocol)
+}
+
+checkSwiftProtocolConformance()
+
+class ClassConformingToUnavailableSwiftProtocol : UnavailableSwiftProtocol {
+  func someMethod() {
+    print("Executed ClassConformingToUnavailableSwiftProtocol.someMethod()")
+  }
+}
+
+func useClassConformingToUnavailableSwiftProtocol() {
+  let o = ClassConformingToUnavailableSwiftProtocol()
+  o.someMethod()
+
+  if #available(OSX 1066.0, iOS 1066.0, watchOS 1066.0, tvOS 1066.0, *) {
+    let oAsUP: UnavailableSwiftProtocol = o as UnavailableSwiftProtocol
+    oAsUP.someMethod()
+  }
+}
+
+// CHECK-NEXT: Executed ClassConformingToUnavailableSwiftProtocol.someMethod()
+useClassConformingToUnavailableSwiftProtocol()
+
+class ClassThatWillBeExtendedToConformToUnavailableSwiftProtocol {
+}
+
+extension ClassThatWillBeExtendedToConformToUnavailableSwiftProtocol : UnavailableSwiftProtocol {
+  func someMethod() {
+    print("Executed ClassThatWillBeExtendedToConformToUnavailableSwiftProtocol.someMethod()")
+  }
+}
+
+func useClassThatWillBeExtendedToConformToUnavailableSwiftProtocol() {
+  let o = ClassThatWillBeExtendedToConformToUnavailableSwiftProtocol()
+  o.someMethod()
+
+  if #available(OSX 1066.0, iOS 1066.0, watchOS 1066.0, tvOS 1066.0, *) {
+    let oAsUP: UnavailableSwiftProtocol = o as UnavailableSwiftProtocol
+    oAsUP.someMethod()
+  }
+}
+
+// CHECK-NEXT: Executed ClassThatWillBeExtendedToConformToUnavailableSwiftProtocol.someMethod()
+useClassThatWillBeExtendedToConformToUnavailableSwiftProtocol()
 
 // CHECK-NEXT: Done
 print("Done")