Implement support for Clang's objc_runtime_visible attribute.

When a Clang-defined Objective-C class has the objc_runtime_visible
attribute, use objc_lookUpClass to get the Objective-C class object
rather than referencing the symbol directly. Also, ban subclassing of
Objective-C-runtime-visible classes as well as @objc on members of
extensions of such classes.

As a drive-by needed for this test, make
ClassDecl::getObjCRuntimeName() respect the Clang objc_runtime_name
attribute.

Fixes rdar://problem/25494454.

Author: DougGregor

include/swift/AST/Decl.h

@@ -3278,6 +3278,10 @@ 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.
   ///

include/swift/AST/DiagnosticsSema.def

@@ -1456,9 +1456,11 @@ ERROR(circular_class_inheritance,none,
 NOTE(class_here,none,
      "class %0 declared here", (Identifier))
 ERROR(inheritance_from_final_class,none,
-"inheritance from a final class %0", (Identifier))
+      "inheritance from a final class %0", (Identifier))
 ERROR(inheritance_from_objc_generic_class,none,
-"inheritance from a generic Objective-C class %0", (Identifier))
+      "inheritance from a generic Objective-C class %0", (Identifier))
+ERROR(inheritance_from_objc_runtime_visible_class,none,
+      "inheritance from an Objective-C class %0 only visible via the runtime", (Identifier))
 
 
 // Enums
@@ -2486,6 +2488,9 @@ 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' "
       "attribute because they are not directly visible from Objective-C", ())

include/swift/Runtime/RuntimeFunctions.def

@@ -841,6 +841,12 @@ FUNCTION(GetObjectClass, object_getClass, C_CC,
          ARGS(ObjCPtrTy),
          ATTRS(NoUnwind, ReadOnly))
 
+// Class objc_lookUpClass(const char *name);
+FUNCTION(LookUpClass, objc_lookUpClass, C_CC,
+         RETURNS(ObjCClassPtrTy),
+         ARGS(Int8PtrTy),
+         ATTRS(NoUnwind, ReadNone))
+
 // Metadata *swift_getObjectType(id object);
 //
 // Since this is intended to look through dynamic subclasses, it's

lib/AST/Decl.cpp

@@ -37,6 +37,7 @@
 #include "swift/Basic/Fallthrough.h"
 
 #include "clang/Basic/CharInfo.h"
+#include "clang/AST/Attr.h"
 #include "clang/AST/DeclObjC.h"
 
 #include <algorithm>
@@ -2286,6 +2287,11 @@ static StringRef mangleObjCRuntimeName(const NominalTypeDecl *nominal,
 
 StringRef ClassDecl::getObjCRuntimeName(
                        llvm::SmallVectorImpl<char> &buffer) const {
+  // If there is a Clang declaration, use it's runtime name.
+  if (auto objcClass
+        = dyn_cast_or_null<clang::ObjCInterfaceDecl>(getClangDecl()))
+    return objcClass->getObjCRuntimeNameAsString();
+
   // If there is an 'objc' attribute with a name, use that name.
   if (auto objc = getAttrs().getAttribute<ObjCAttr>()) {
     if (auto name = objc->getName())
@@ -2296,6 +2302,19 @@ 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;

lib/IRGen/GenMeta.cpp

@@ -256,8 +256,9 @@ llvm::Constant *irgen::tryEmitConstantHeapMetadataRef(IRGenModule &IGM,
     if (doesClassMetadataRequireDynamicInitialization(IGM, theDecl))
       return nullptr;
 
-  // Otherwise, just respect genericity.
-  } else if (theDecl->isGenericContext()) {
+  // Otherwise, just respect genericity and Objective-C runtime visibility.
+  } else if (theDecl->isGenericContext() ||
+             theDecl->isOnlyObjCRuntimeVisible()) {
     return nullptr;
   }
 
@@ -291,6 +292,15 @@ irgen::tryEmitConstantTypeMetadataRef(IRGenModule &IGM, CanType type,
 llvm::Value *irgen::emitObjCHeapMetadataRef(IRGenFunction &IGF,
                                             ClassDecl *theClass,
                                             bool allowUninitialized) {
+  // If the class is visible only through the Objective-C runtime, form the
+  // appropriate runtime call.
+  if (theClass->isOnlyObjCRuntimeVisible()) {
+    SmallString<64> scratch;
+    auto className =
+        IGF.IGM.getAddrOfGlobalString(theClass->getObjCRuntimeName(scratch));
+    return IGF.Builder.CreateCall(IGF.IGM.getLookUpClassFn(), className);
+  }
+
   auto classObject = IGF.IGM.getAddrOfObjCClass(theClass, NotForDefinition);
   if (allowUninitialized) return classObject;
 

lib/Sema/TypeCheckDecl.cpp

@@ -2090,9 +2090,14 @@ static Optional<ObjCReason> shouldMarkAsObjC(TypeChecker &TC,
   // make it implicitly @objc. However, if the declaration cannot be represented
   // as @objc, don't diagnose.
   Type contextTy = VD->getDeclContext()->getDeclaredTypeInContext();
-  if (auto classDecl = contextTy->getClassOrBoundGenericClass())
+  if (auto classDecl = contextTy->getClassOrBoundGenericClass()) {
+    // One cannot define @objc members of Objective-C runtime visible classes.
+    if (classDecl->isOnlyObjCRuntimeVisible())
+      return None;
+
     if (classDecl->checkObjCAncestry() != ObjCClassKind::NonObjC)
       return ObjCReason::DoNotDiagnose;
+  }
 
   return None;
 }
@@ -3835,6 +3840,11 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
           TC.diagnose(CD, diag::inheritance_from_objc_generic_class,
                       Super->getName());
         }
+
+        if (Super->isOnlyObjCRuntimeVisible()) {
+          TC.diagnose(CD, diag::inheritance_from_objc_runtime_visible_class,
+                      Super->getName());
+        }
       }
 
       checkAccessibility(TC, CD);

lib/Sema/TypeCheckType.cpp

@@ -2494,7 +2494,8 @@ static bool isParamListRepresentableInObjC(TypeChecker &TC,
 }
 
 /// Check whether the given declaration occurs within a constrained
-/// extension, or an extension of a class with generic ancestry, and
+/// extension, or an extension of a class with generic ancestry, or an
+/// extension of an Objective-C runtime visible class, and
 /// therefore is not representable in Objective-C.
 static bool checkObjCInExtensionContext(TypeChecker &tc,
                                         const ValueDecl *value,
@@ -2521,11 +2522,19 @@ static bool checkObjCInExtensionContext(TypeChecker &tc,
 
       if (!CD->hasClangNode() && CD->getGenericParams()) {
         if (diagnose) {
-          tc.diagnose(value->getLoc(), diag::objc_in_generic_extension);
+          tc.diagnose(value, diag::objc_in_generic_extension);
         }
         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();
     }
   }

test/IRGen/objc_runtime_visible.sil

@@ -0,0 +1,22 @@
+// REQUIRES: objc_interop
+
+// RUN: %target-swift-frontend -I %S/../Inputs/custom-modules %s -emit-ir | FileCheck %s
+
+sil_stage raw
+
+import Builtin
+import Swift
+import SwiftShims
+import ObjCRuntimeVisible
+
+// CHECK: [[CLASS_NAME:@.*]] = private unnamed_addr constant [22 x i8] c"MyRuntimeVisibleClass\00"
+
+// CHECK: define %objc_class* @getClassA() #0 {
+sil @getClassA : $@convention(thin) () -> @objc_metatype A.Type {
+bb0:
+  // CHECK: call %objc_class* @objc_lookUpClass(i8* getelementptr inbounds ([22 x i8], [22 x i8]* [[CLASS_NAME]], i64 0, i64 0))
+  %0 = metatype $@objc_metatype A.Type
+
+  // CHECK-NEXT:  ret %objc_class*
+  return %0 : $@objc_metatype A.Type
+}

test/Inputs/custom-modules/ObjCRuntimeVisible.h

@@ -0,0 +1,8 @@
+@interface Root
++(Class)class;
+@end
+
+__attribute__((objc_runtime_visible))
+__attribute__((objc_runtime_name("MyRuntimeVisibleClass")))
+@interface A : Root
+@end

test/Inputs/custom-modules/module.map

@@ -0,0 +1,3 @@
+module ObjCRuntimeVisible {
+  header "ObjCRuntimeVisible.h"
+}

test/attr/attr_objc_clang.swift

@@ -1,9 +1,10 @@
-// RUN: %target-parse-verify-swift -sdk %S/Inputs -I %S/Inputs/custom-modules
-// RUN: %target-swift-ide-test -print-ast-typechecked -source-filename %s -sdk %S/Inputs -I %S/Inputs/custom-modules -function-definitions=true -prefer-type-repr=false -print-implicit-attrs=true -explode-pattern-binding-decls=true -disable-objc-attr-requires-foundation-module  | FileCheck %s
+// RUN: %target-parse-verify-swift -sdk %S/Inputs -I %S/Inputs/custom-modules -I %S/../Inputs/custom-modules
+// RUN: %target-swift-ide-test -print-ast-typechecked -source-filename %s -sdk %S/Inputs -I %S/Inputs/custom-modules -I %S/../Inputs/custom-modules -function-definitions=true -prefer-type-repr=false -print-implicit-attrs=true -explode-pattern-binding-decls=true -disable-objc-attr-requires-foundation-module  | FileCheck %s
 
 // REQUIRES: objc_interop
 
 import AttrObjc_FooClangModule
+import ObjCRuntimeVisible
 
 @objc
 class infer_instanceVar1 {
@@ -35,3 +36,8 @@ func ==(lhs: ObjC_Class1, rhs: ObjC_Class1) -> Bool {
 func ==(lhs: ObjC_Class2, rhs: ObjC_Class2) -> Bool {
   return true
 }
+
+extension A {
+  // CHECK: {{^}} func foo()
+  func foo() { }
+}