Use ClassDecl::ForeignKind to model Clang's objc_runtime_visible.

jrose-apple · jrose-apple · commit 3b6e40c0308b · 2016-06-30T11:20:58.000-07:00
We're now correctly checking for inheritance, adding @objc methods, and adding @objc protocols for both CF types and objc_runtime_visible classes (those without visible symbols). The latter is used for some of the types in Dispatch, which has exposed some of the classes that were considered implementation details on past OSs. We still don't properly implement using 'as?' to check conformance to a Swift protocol for a CF or objc_runtime_visible type, but we can do that later. rdar://problem/26850367
diff --git a/include/swift/AST/Decl.h b/include/swift/AST/Decl.h
@@ -3315,10 +3315,6 @@ class ClassDecl : public NominalTypeDecl {
   /// the Objective-C runtime.
   StringRef getObjCRuntimeName(llvm::SmallVectorImpl<char> &buffer) const;
 
-  /// Determine whether the class is only visible to the Objective-C runtime
-  /// and not to the linker.
-  bool isOnlyObjCRuntimeVisible() const;
-
   /// Returns the appropriate kind of entry point to generate for this class,
   /// based on its attributes.
   ///
diff --git a/include/swift/AST/DiagnosticsSema.def b/include/swift/AST/DiagnosticsSema.def
@@ -1166,10 +1166,14 @@ NOTE(types_not_equal_requirement,none,
 ERROR(non_class_cannot_conform_to_class_protocol,none,
       "non-class type %0 cannot conform to class protocol %1",
       (Type, Type))
-ERROR(foreign_class_cannot_conform_to_objc_protocol,none,
+ERROR(cf_class_cannot_conform_to_objc_protocol,none,
       "Core Foundation class %0 cannot conform to @objc protocol %1 because "
       "Core Foundation types are not classes in Objective-C",
       (Type, Type))
+ERROR(objc_runtime_visible_cannot_conform_to_objc_protocol,none,
+      "class %0 cannot conform to @objc protocol %1 because "
+      "the class is only visible via the Objective-C runtime",
+      (Type, Type))
 ERROR(protocol_has_missing_requirements,none,
       "type %0 cannot conform to protocol %1 because it has requirements that "
       "cannot be satisfied", (Type, Type))
@@ -1577,8 +1581,11 @@ ERROR(inheritance_from_final_class,none,
 ERROR(inheritance_from_unspecialized_objc_generic_class,none,
       "inheritance from a generic Objective-C class %0 must bind "
       "type parameters of %0 to specific concrete types", (Identifier))
+ERROR(inheritance_from_cf_class,none,
+      "cannot inherit from Core Foundation type %0", (Identifier))
 ERROR(inheritance_from_objc_runtime_visible_class,none,
-      "inheritance from an Objective-C class %0 only visible via the runtime", (Identifier))
+      "cannot inherit from class %0 because it is only visible via the "
+      "Objective-C runtime", (Identifier))
 
 
 // Enums
@@ -2606,8 +2613,6 @@ ERROR(objc_in_extension_context,none,
       "members of constrained extensions cannot be declared @objc", ())
 ERROR(objc_in_generic_extension,none,
       "@objc is not supported within extensions of generic classes", ())
-ERROR(objc_in_objc_runtime_visible,none,
-      "@objc is not supported within extensions of classes only visible via the Objective-C runtime", ())
 
 ERROR(objc_for_generic_class,none,
       "generic subclasses of '@objc' classes cannot have an explicit '@objc' "
@@ -2728,6 +2733,11 @@ ERROR(objc_invalid_on_failing_init,none,
       "%" OBJC_ATTR_SELECT "0 because 'nil' indicates failure to Objective-C",
       (unsigned))
 
+ERROR(objc_in_objc_runtime_visible,none,
+      "%0 cannot be %" OBJC_ATTR_SELECT "1 because class %2 is only visible "
+      "via the Objective-C runtime",
+      (DescriptiveDeclKind, unsigned, Identifier))
+
 ERROR(objc_override_method_selector_mismatch,none,
       "Objective-C method has a different selector from the "
       "method it overrides (%0 vs. %1)", (ObjCSelector, ObjCSelector))
diff --git a/lib/AST/Decl.cpp b/lib/AST/Decl.cpp
@@ -2398,19 +2398,6 @@ StringRef ClassDecl::getObjCRuntimeName(
   return mangleObjCRuntimeName(this, buffer);
 }
 
-bool ClassDecl::isOnlyObjCRuntimeVisible() const {
-  auto clangDecl = getClangDecl();
-  if (!clangDecl) return false;
-
-  auto objcClass = dyn_cast<clang::ObjCInterfaceDecl>(clangDecl);
-  if (!objcClass) return false;
-
-  if (auto def = objcClass->getDefinition())
-    objcClass = def;
-
-  return objcClass->hasAttr<clang::ObjCRuntimeVisibleAttr>();
-}
-
 ArtificialMainKind ClassDecl::getArtificialMainKind() const {
   if (getAttrs().hasAttribute<UIApplicationMainAttr>())
     return ArtificialMainKind::UIApplicationMain;
diff --git a/lib/ClangImporter/ImportDecl.cpp b/lib/ClangImporter/ImportDecl.cpp
@@ -5660,8 +5660,7 @@ namespace {
           nsObjectTy->getClassOrBoundGenericClass();
 
         auto result = createRootClass(nsObjectDecl->getDeclContext());
-        // FIXME: Should use RuntimeOnly.
-        result->setForeignClassKind(ClassDecl::ForeignKind::CFType);
+        result->setForeignClassKind(ClassDecl::ForeignKind::RuntimeOnly);
         return result;
       }
 
@@ -5732,6 +5731,8 @@ namespace {
 
       if (declaredNative)
         markMissingSwiftDecl(result);
+      if (decl->getAttr<clang::ObjCRuntimeVisibleAttr>())
+        result->setForeignClassKind(ClassDecl::ForeignKind::RuntimeOnly);
 
       // If this Objective-C class has a supertype, import it.
       SmallVector<TypeLoc, 4> inheritedTypes;
diff --git a/lib/IRGen/GenCast.cpp b/lib/IRGen/GenCast.cpp
@@ -163,9 +163,10 @@ llvm::Value *irgen::emitClassDowncast(IRGenFunction &IGF, llvm::Value *from,
       break;
     }
 
-  // If the destination type is a foreign class or a non-specific
+  // If the destination type is a CF type or a non-specific
   // class-bounded archetype, use the most general cast entrypoint.
-  } else if (toType.is<ArchetypeType>() || destClass->isForeign()) {
+  } else if (toType.is<ArchetypeType>() ||
+             destClass->getForeignClassKind()==ClassDecl::ForeignKind::CFType) {
     metadataRef = IGF.emitTypeMetadataRef(toType.getSwiftRValueType());
 
     switch (mode) {
diff --git a/lib/IRGen/GenDecl.cpp b/lib/IRGen/GenDecl.cpp
@@ -2272,6 +2272,7 @@ Address IRGenModule::getAddrOfObjCClassRef(ClassDecl *theClass) {
 llvm::Constant *IRGenModule::getAddrOfObjCClass(ClassDecl *theClass,
                                                 ForDefinition_t forDefinition) {
   assert(ObjCInterop && "getting address of ObjC class in no-interop mode");
+  assert(!theClass->isForeign());
   LinkEntity entity = LinkEntity::forObjCClass(theClass);
   DebugTypeInfo DbgTy(theClass, ObjCClassPtrTy,
                       getPointerSize(), getPointerAlignment());
@@ -2285,6 +2286,7 @@ llvm::Constant *IRGenModule::getAddrOfObjCClass(ClassDecl *theClass,
 llvm::Constant *IRGenModule::getAddrOfObjCMetaclass(ClassDecl *theClass,
                                                 ForDefinition_t forDefinition) {
   assert(ObjCInterop && "getting address of ObjC metaclass in no-interop mode");
+  assert(!theClass->isForeign());
   LinkEntity entity = LinkEntity::forObjCMetaclass(theClass);
   DebugTypeInfo DbgTy(theClass, ObjCClassPtrTy,
                       getPointerSize(), getPointerAlignment());
diff --git a/lib/IRGen/GenMeta.cpp b/lib/IRGen/GenMeta.cpp
@@ -292,10 +292,8 @@ llvm::Constant *irgen::tryEmitConstantHeapMetadataRef(IRGenModule &IGM,
     if (doesClassMetadataRequireDynamicInitialization(IGM, theDecl))
       return nullptr;
 
-  // Otherwise, just respect genericity and Objective-C runtime visibility.
-  } else if ((theDecl->isGenericContext()
-              && !isTypeErasedGenericClass(theDecl))
-             || theDecl->isOnlyObjCRuntimeVisible()) {
+  // Otherwise, just respect genericity.
+  } else if (theDecl->isGenericContext() && !isTypeErasedGenericClass(theDecl)){
     return nullptr;
   }
 
@@ -331,13 +329,15 @@ llvm::Value *irgen::emitObjCHeapMetadataRef(IRGenFunction &IGF,
                                             bool allowUninitialized) {
   // If the class is visible only through the Objective-C runtime, form the
   // appropriate runtime call.
-  if (theClass->isOnlyObjCRuntimeVisible()) {
+  if (theClass->getForeignClassKind() == ClassDecl::ForeignKind::RuntimeOnly) {
     SmallString<64> scratch;
     auto className =
         IGF.IGM.getAddrOfGlobalString(theClass->getObjCRuntimeName(scratch));
     return IGF.Builder.CreateCall(IGF.IGM.getLookUpClassFn(), className);
   }
 
+  assert(!theClass->isForeign());
+
   Address classRef = IGF.IGM.getAddrOfObjCClassRef(theClass);
   auto classObject = IGF.Builder.CreateLoad(classRef);
   if (allowUninitialized) return classObject;
@@ -5438,7 +5438,6 @@ IRGenModule::getAddrOfForeignTypeMetadataCandidate(CanType type) {
   if (auto classType = dyn_cast<ClassType>(type)) {
     assert(!classType.getParent());
     auto classDecl = classType->getDecl();
-    // FIXME: Differentiate between the different kinds of foreign classes.
     assert(classDecl->isForeign());
 
     ForeignClassMetadataBuilder builder(*this, classDecl);
diff --git a/lib/Sema/TypeCheckDecl.cpp b/lib/Sema/TypeCheckDecl.cpp
@@ -1934,8 +1934,8 @@ static Optional<ObjCReason> shouldMarkAsObjC(TypeChecker &TC,
   // as @objc, don't diagnose.
   Type contextTy = VD->getDeclContext()->getDeclaredTypeInContext();
   if (auto classDecl = contextTy->getClassOrBoundGenericClass()) {
-    // One cannot define @objc members of Objective-C runtime visible classes.
-    if (classDecl->isOnlyObjCRuntimeVisible())
+    // One cannot define @objc members of any foreign classes.
+    if (classDecl->isForeign())
       return None;
 
     if (classDecl->checkObjCAncestry() != ObjCClassKind::NonObjC)
@@ -3722,9 +3722,17 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
                       Super->getName());
         }
 
-        if (Super->isOnlyObjCRuntimeVisible()) {
+        switch (Super->getForeignClassKind()) {
+        case ClassDecl::ForeignKind::Normal:
+          break;
+        case ClassDecl::ForeignKind::CFType:
+          TC.diagnose(CD, diag::inheritance_from_cf_class,
+                      Super->getName());
+          break;
+        case ClassDecl::ForeignKind::RuntimeOnly:
           TC.diagnose(CD, diag::inheritance_from_objc_runtime_visible_class,
                       Super->getName());
+          break;
         }
       }
 
diff --git a/lib/Sema/TypeCheckProtocol.cpp b/lib/Sema/TypeCheckProtocol.cpp
@@ -3950,15 +3950,26 @@ checkConformsToProtocol(TypeChecker &TC,
   // Foreign classes cannot conform to objc protocols.
   if (Proto->isObjC() &&
       !Proto->isSpecificProtocol(KnownProtocolKind::AnyObject)) {
-    if (auto clas = canT->getClassOrBoundGenericClass())
-      if (clas->getForeignClassKind() != ClassDecl::ForeignKind::Normal) {
-        // FIXME: Customize the error message for different foreign class kinds.
-        TC.diagnose(ComplainLoc,
-                    diag::foreign_class_cannot_conform_to_objc_protocol,
+    if (auto clas = canT->getClassOrBoundGenericClass()) {
+      Optional<decltype(diag::cf_class_cannot_conform_to_objc_protocol)>
+          diagKind;
+      switch (clas->getForeignClassKind()) {
+      case ClassDecl::ForeignKind::Normal:
+        break;
+      case ClassDecl::ForeignKind::CFType:
+        diagKind = diag::cf_class_cannot_conform_to_objc_protocol;
+        break;
+      case ClassDecl::ForeignKind::RuntimeOnly:
+        diagKind = diag::objc_runtime_visible_cannot_conform_to_objc_protocol;
+        break;
+      }
+      if (diagKind) {
+        TC.diagnose(ComplainLoc, diagKind.getValue(),
                     T, Proto->getDeclaredType());
         conformance->setInvalid();
         return conformance;
       }
+    }
   }
 
   // If the protocol contains missing requirements, it can't be conformed to
diff --git a/lib/Sema/TypeCheckType.cpp b/lib/Sema/TypeCheckType.cpp
@@ -2648,14 +2648,6 @@ static bool checkObjCInExtensionContext(TypeChecker &tc,
         return true;
       }
 
-      // Cannot define @objc members of an Objective-C runtime visible class,
-      // because doing so would create a category.
-      if (CD->isOnlyObjCRuntimeVisible()) {
-        if (diagnose)
-          tc.diagnose(value, diag::objc_in_objc_runtime_visible);
-        return true;
-      }
-
       extendedTy = CD->getSuperclass();
     }
   }
@@ -2699,15 +2691,28 @@ static bool checkObjCInForeignClassContext(TypeChecker &TC,
   if (!clas)
     return false;
 
-  if (clas->getForeignClassKind() == ClassDecl::ForeignKind::Normal)
+  switch (clas->getForeignClassKind()) {
+  case ClassDecl::ForeignKind::Normal:
     return false;
 
-  if (Diagnose) {
-    // FIXME: Customize diagnostic here for various foreign class kinds.
-    TC.diagnose(VD->getLoc(), diag::objc_invalid_on_foreign_class,
-                getObjCDiagnosticAttrKind(Reason));
-    describeObjCReason(TC, VD, Reason);
+  case ClassDecl::ForeignKind::CFType:
+    if (Diagnose) {
+      TC.diagnose(VD, diag::objc_invalid_on_foreign_class,
+                  getObjCDiagnosticAttrKind(Reason));
+      describeObjCReason(TC, VD, Reason);
+    }
+    break;
+
+  case ClassDecl::ForeignKind::RuntimeOnly:
+    if (Diagnose) {
+      TC.diagnose(VD, diag::objc_in_objc_runtime_visible,
+                  VD->getDescriptiveKind(), getObjCDiagnosticAttrKind(Reason),
+                  clas->getName());
+      describeObjCReason(TC, VD, Reason);
+    }
+    break;
   }
+
   return true;
 }
 
diff --git a/test/ClangModules/cf.swift b/test/ClangModules/cf.swift
@@ -1,4 +1,4 @@
-// RUN: %target-swift-frontend -parse -verify -import-cf-types -I %S/Inputs/custom-modules %s
+// RUN: %target-swift-frontend -disable-objc-attr-requires-foundation-module -parse -verify -import-cf-types -I %S/Inputs/custom-modules %s
 
 // REQUIRES: objc_interop
 
@@ -149,3 +149,14 @@ func testNonConstVoid() {
   let value: Unmanaged<CFNonConstVoidRef> = CFNonConstBottom()!
   assertUnmanaged(value)
 }
+
+class NuclearFridge: CCRefrigerator {} // expected-error {{cannot inherit from Core Foundation type 'CCRefrigerator'}}
+extension CCRefrigerator {
+  @objc func foo() {} // expected-error {{method cannot be marked @objc because Core Foundation types are not classes in Objective-C}}
+  func bar() {} // okay, implicitly non-objc
+}
+
+protocol SwiftProto {}
+@objc protocol ObjCProto {}
+extension CCRefrigerator: ObjCProto {} // expected-error {{Core Foundation class 'CCRefrigerator' cannot conform to @objc protocol 'ObjCProto' because Core Foundation types are not classes in Objective-C}}
+extension CCRefrigerator: SwiftProto {}
diff --git a/test/ClangModules/objc_runtime_visible.swift b/test/ClangModules/objc_runtime_visible.swift
@@ -5,7 +5,18 @@
 import ObjCRuntimeVisible
 
 extension A {
-  @objc func foo() { } // expected-error{{@objc is not supported within extensions of classes only visible via the Objective-C runtime}}
+  @objc func foo() { } // expected-error{{instance method cannot be marked @objc because class 'A' is only visible via the Objective-C runtime}}
+  func bar() {} // okay, implicitly non-objc
 }
 
-class B : A { } // expected-error{{inheritance from an Objective-C class 'A' only visible via the runtime}}
+func test(x: AnyObject) {
+  _ = x.bar() // expected-error {{value of type 'AnyObject' has no member 'bar'}}
+}
+
+class B : A { } // expected-error{{cannot inherit from class 'A' because it is only visible via the Objective-C runtime}}
+
+protocol SwiftProto {}
+@objc protocol ObjCProto {}
+
+extension A: ObjCProto {} // expected-error {{class 'A' cannot conform to @objc protocol 'ObjCProto' because the class is only visible via the Objective-C runtime}}
+extension A: SwiftProto {} // okay
diff --git a/test/Interpreter/Inputs/objc_runtime_visible.h b/test/Interpreter/Inputs/objc_runtime_visible.h
@@ -0,0 +1,9 @@
+@import Foundation;
+
+__attribute__((visibility("hidden")))
+__attribute__((objc_runtime_visible))
+@interface HiddenClass : NSObject
+@property (readonly, nonnull) NSString *name;
+@end
+
+HiddenClass * _Nonnull createHidden() NS_RETURNS_RETAINED;
diff --git a/test/Interpreter/Inputs/objc_runtime_visible.m b/test/Interpreter/Inputs/objc_runtime_visible.m
@@ -0,0 +1,11 @@
+#import "objc_runtime_visible.h"
+
+@implementation HiddenClass
+- (NSString *)name {
+  return @"Beatrice";
+}
+@end
+
+HiddenClass *createHidden() {
+  return [[HiddenClass alloc] init];
+}
diff --git a/test/Interpreter/SDK/cf_extensions.swift b/test/Interpreter/SDK/cf_extensions.swift
diff --git a/test/Interpreter/objc_runtime_visible.swift b/test/Interpreter/objc_runtime_visible.swift
