[Clang importer] Make sure an unavailable superclass init doesn't override an available import-as-member-init.

More generally, an unavailable initializer shouldn't stomp on an
available initializer, because it's possible that (for example) a
designated initializer will be unavailable but a factory initializer
will be available, so one still construct objects of that type.
Fixes rdar://problem/26238032.

Author: DougGregor

lib/ClangImporter/ClangImporter.cpp

@@ -1650,30 +1650,7 @@ static bool hasErrorMethodNameCollision(ClangImporter::Implementation &importer,
   // been marked NS_SWIFT_UNAVAILABLE, because it's actually marked unavailable,
   // or because it was deprecated before our API sunset. We can handle
   // "conflicts" where one form is unavailable.
-  // FIXME: Somewhat duplicated from Implementation::importAttributes.
-  clang::AvailabilityResult availability = conflict->getAvailability();
-  if (availability != clang::AR_Unavailable &&
-      importer.DeprecatedAsUnavailableFilter) {
-    for (auto *attr : conflict->specific_attrs<clang::AvailabilityAttr>()) {
-      if (attr->getPlatform()->getName() == "swift") {
-        availability = clang::AR_Unavailable;
-        break;
-      }
-      if (importer.PlatformAvailabilityFilter &&
-          !importer.PlatformAvailabilityFilter(attr->getPlatform()->getName())){
-        continue;
-      }
-      clang::VersionTuple version = attr->getDeprecated();
-      if (version.empty())
-        continue;
-      if (importer.DeprecatedAsUnavailableFilter(version.getMajor(),
-                                                 version.getMinor())) {
-        availability = clang::AR_Unavailable;
-        break;
-      }
-    }
-  }
-  return availability != clang::AR_Unavailable;
+  return !importer.isUnavailableInSwift(conflict);
 }
 
 /// Determine the optionality of the given Objective-C method.
@@ -2809,7 +2786,8 @@ auto ClangImporter::Implementation::importFullName(
         (isa<clang::TypeDecl>(D) ||
          (isa<clang::ObjCInterfaceDecl>(D) &&
           !hasOrInheritsSwiftBridgeAttr(cast<clang::ObjCInterfaceDecl>(D))) ||
-         isa<clang::ObjCProtocolDecl>(D))) {
+         isa<clang::ObjCProtocolDecl>(D)) &&
+        !isUnavailableInSwift(D)) {
       // Find the original declaration, from which we can determine
       // the owning module.
       const clang::Decl *owningD = D->getCanonicalDecl();

lib/ClangImporter/ImportDecl.cpp

@@ -3856,6 +3856,14 @@ namespace {
                                CtorInitializerKind kind) {
       CtorInitializerKind existingKind = existingCtor->getInitKind();
 
+      // If one constructor is unavailable in Swift and the other is
+      // not, keep the available one.
+      bool existingIsUnavailable =
+        existingCtor->getAttrs().isUnavailable(Impl.SwiftContext);
+      bool newIsUnavailable = Impl.isUnavailableInSwift(objcMethod);
+      if (existingIsUnavailable != newIsUnavailable)
+        return existingIsUnavailable;
+
       // If the new kind is the same as the existing kind, stick with
       // the existing constructor.
       if (existingKind == kind)
@@ -6167,6 +6175,35 @@ void ClangImporter::Implementation::importAttributes(
   }
 }
 
+bool ClangImporter::Implementation::isUnavailableInSwift(
+    const clang::Decl *decl) {
+  // FIXME: Somewhat duplicated from importAttributes(), but this is a
+  // more direct path.
+  if (decl->getAvailability() == clang::AR_Unavailable) return true;
+
+  // Apply the deprecated-as-unavailable filter.
+  if (!DeprecatedAsUnavailableFilter) return false;
+
+  for (auto *attr : decl->specific_attrs<clang::AvailabilityAttr>()) {
+    if (attr->getPlatform()->getName() == "swift")
+      return true;
+
+    if (PlatformAvailabilityFilter &&
+        !PlatformAvailabilityFilter(attr->getPlatform()->getName())){
+      continue;
+    }
+
+    clang::VersionTuple version = attr->getDeprecated();
+    if (version.empty())
+      continue;
+    if (DeprecatedAsUnavailableFilter(version.getMajor(),
+                                      version.getMinor()))
+      return true;
+  }
+
+  return false;
+}
+
 Decl *
 ClangImporter::Implementation::importDeclImpl(const clang::NamedDecl *ClangDecl,
                                               bool useSwift2Name,

lib/ClangImporter/ImporterImpl.h

@@ -1096,6 +1096,10 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
                             bool isStatic,
                             ClangNode ClangN);
 
+  /// Determine whether the given declaration is considered
+  /// 'unavailable' in Swift.
+  bool isUnavailableInSwift(const clang::Decl *decl);
+
   /// \brief Add "Unavailable" annotation to the swift declaration.
   void markUnavailable(ValueDecl *decl, StringRef unavailabilityMsg);
 

test/IDE/Inputs/custom-modules/ImportAsMemberClass.h

@@ -19,4 +19,17 @@ __attribute__((swift_name("SomeClass.applyOptions(self:_:)")))
 void IAMSomeClassApplyOptions(IAMSomeClass * _Nonnull someClass, 
                               IAMSomeClassOptions options);
 
+@interface UnavailableDefaultInit : NSObject
+-(instancetype)init __attribute__((availability(swift,unavailable)));
+@end
+
+@interface UnavailableDefaultInitSub : UnavailableDefaultInit
+@end
+
+__attribute__((swift_name("UnavailableDefaultInit.init()")))
+UnavailableDefaultInit * _Nonnull MakeUnavailableDefaultInit(void);
+
+__attribute__((swift_name("UnavailableDefaultInitSub.init()")))
+UnavailableDefaultInitSub * _Nonnull MakeUnavailableDefaultInitSub(void);
+
 #endif

test/IDE/import_as_member_objc.swift

@@ -67,3 +67,9 @@ FooErr.mutateSomeStaticState()
 let someClassOpts: SomeClass.Options = .fuzzyDice
 let someClass = SomeClass(value: 3.14159)
 someClass.applyOptions(someClassOpts)
+
+class SomeSub : UnavailableDefaultInitSub { }
+
+// Handle default initializers.
+let udi1 = UnavailableDefaultInit()
+let udis1 = UnavailableDefaultInitSub()