Merge pull request #8822 from huonw/symbol-list-5

Yet more TBDGen work: mostly classes.

Author: huonw

include/swift/AST/Decl.h

@@ -3311,6 +3311,15 @@ class ClassDecl : public NominalTypeDecl {
   /// might have implicitly @objc members, but will never itself be @objc.
   ObjCClassKind checkObjCAncestry() const;
 
+  /// The type of metaclass to use for an class.
+  enum class MetaclassKind : uint8_t {
+    ObjC,
+    SwiftStub,
+  };
+
+  /// Determine which sort of metaclass to use for this class
+  MetaclassKind getMetaclassKind() const;
+
   /// Retrieve the name to use for this class when interoperating with
   /// the Objective-C runtime.
   StringRef getObjCRuntimeName(llvm::SmallVectorImpl<char> &buffer) const;

lib/AST/Decl.cpp

@@ -2584,6 +2584,13 @@ ObjCClassKind ClassDecl::checkObjCAncestry() const {
   return kind;
 }
 
+ClassDecl::MetaclassKind ClassDecl::getMetaclassKind() const {
+  assert(getASTContext().LangOpts.EnableObjCInterop &&
+         "querying metaclass kind without objc interop");
+  auto objc = checkObjCAncestry() != ObjCClassKind::NonObjC;
+  return objc ? MetaclassKind::ObjC : MetaclassKind::SwiftStub;
+}
+
 /// Mangle the name of a protocol or class for use in the Objective-C
 /// runtime.
 static StringRef mangleObjCRuntimeName(const NominalTypeDecl *nominal,

lib/IRGen/GenDecl.cpp

@@ -2412,48 +2412,27 @@ llvm::Constant *IRGenModule::getAddrOfObjCClass(ClassDecl *theClass,
   return addr;
 }
 
-/// Fetch a global reference to the given Objective-C metaclass.
-/// The result is always a GlobalValue of ObjCClassPtrTy.
-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);
-  auto DbgTy = DebugTypeInfo::getObjCClass(
-      theClass, ObjCClassPtrTy, getPointerSize(), getPointerAlignment());
-  auto addr = getAddrOfLLVMVariable(entity, getPointerAlignment(),
-                                    forDefinition, ObjCClassStructTy, DbgTy);
-  return addr;
-}
+/// Fetch the declaration of a metaclass object. The result is always a
+/// GlobalValue of ObjCClassPtrTy, and is either the Objective-C metaclass or
+/// the Swift metaclass stub, depending on whether the class is published as an
+/// ObjC class.
+llvm::Constant *
+IRGenModule::getAddrOfMetaclassObject(ClassDecl *decl,
+                                      ForDefinition_t forDefinition) {
+  assert((!decl->isGenericContext() || decl->hasClangNode()) &&
+         "generic classes do not have a static metaclass object");
+
+  auto entity = decl->getMetaclassKind() == ClassDecl::MetaclassKind::ObjC
+                    ? LinkEntity::forObjCMetaclass(decl)
+                    : LinkEntity::forSwiftMetaclassStub(decl);
 
-/// Fetch the declaration of the metaclass stub for the given class type.
-/// The result is always a GlobalValue of ObjCClassPtrTy.
-llvm::Constant *IRGenModule::getAddrOfSwiftMetaclassStub(ClassDecl *theClass,
-                                                ForDefinition_t forDefinition) {
-  assert(ObjCInterop && "getting address of metaclass stub in no-interop mode");
-  LinkEntity entity = LinkEntity::forSwiftMetaclassStub(theClass);
   auto DbgTy = DebugTypeInfo::getObjCClass(
-      theClass, ObjCClassPtrTy, getPointerSize(), getPointerAlignment());
+      decl, ObjCClassPtrTy, getPointerSize(), getPointerAlignment());
   auto addr = getAddrOfLLVMVariable(entity, getPointerAlignment(),
                                     forDefinition, ObjCClassStructTy, DbgTy);
   return addr;
 }
 
-/// Fetch the declaration of a metaclass object.  This performs either
-/// getAddrOfSwiftMetaclassStub or getAddrOfObjCMetaclass, depending
-/// on whether the class is published as an ObjC class.
-llvm::Constant *IRGenModule::getAddrOfMetaclassObject(ClassDecl *decl,
-                                                ForDefinition_t forDefinition) {
-  assert((!decl->isGenericContext() || decl->hasClangNode())
-         && "generic classes do not have a static metaclass object");
-  if (decl->checkObjCAncestry() != ObjCClassKind::NonObjC ||
-      decl->hasClangNode()) {
-    return getAddrOfObjCMetaclass(decl, forDefinition);
-  } else {
-    return getAddrOfSwiftMetaclassStub(decl, forDefinition);
-  }
-}
-
 /// Fetch the type metadata access function for a non-generic type.
 llvm::Function *
 IRGenModule::getAddrOfTypeMetadataAccessFunction(CanType type,

lib/IRGen/GenMeta.cpp

@@ -3981,6 +3981,8 @@ static void emitObjCClassSymbol(IRGenModule &IGM,
                                           metadata->getLinkage(),
                                           classSymbol.str(), metadata,
                                           IGM.getModule());
+  alias->setVisibility(metadata->getVisibility());
+
   if (IGM.useDllStorage())
     alias->setDLLStorageClass(metadata->getDLLStorageClass());
 }

lib/IRGen/IRGenModule.h

@@ -955,10 +955,6 @@ private:                            \
   llvm::Constant *getAddrOfObjCClass(ClassDecl *D,
                                      ForDefinition_t forDefinition);
   Address getAddrOfObjCClassRef(ClassDecl *D);
-  llvm::Constant *getAddrOfObjCMetaclass(ClassDecl *D,
-                                         ForDefinition_t forDefinition);
-  llvm::Constant *getAddrOfSwiftMetaclassStub(ClassDecl *D,
-                                              ForDefinition_t forDefinition);
   llvm::Constant *getAddrOfMetaclassObject(ClassDecl *D,
                                            ForDefinition_t forDefinition);
   llvm::Function *getAddrOfSILFunction(SILFunction *f,

lib/TBDGen/TBDGen.cpp

@@ -199,9 +199,12 @@ void TBDGenVisitor::visitNominalTypeDecl(NominalTypeDecl *NTD) {
 
   addSymbol(LinkEntity::forNominalTypeDescriptor(NTD));
 
-  addSymbol(LinkEntity::forTypeMetadata(declaredType,
-                                        TypeMetadataAddress::AddressPoint,
-                                        /*isPattern=*/false));
+  // Generic types do not get metadata directly, only through the function.
+  if (!NTD->isGenericContext()) {
+    addSymbol(LinkEntity::forTypeMetadata(declaredType,
+                                          TypeMetadataAddress::AddressPoint,
+                                          /*isPattern=*/false));
+  }
   addSymbol(LinkEntity::forTypeMetadataAccessFunction(declaredType));
 
   // There are symbols associated with any protocols this type conforms to.
@@ -211,6 +214,11 @@ void TBDGenVisitor::visitNominalTypeDecl(NominalTypeDecl *NTD) {
     if (!needsWTable)
       continue;
 
+    // Only normal conformances get symbols; the others get any public symbols
+    // from their parent normal conformance.
+    if (conformance->getKind() != ProtocolConformanceKind::Normal)
+      continue;
+
     addSymbol(LinkEntity::forDirectProtocolWitnessTable(conformance));
     addSymbol(LinkEntity::forProtocolWitnessTableAccessFunction(conformance));
   }
@@ -230,9 +238,20 @@ void TBDGenVisitor::visitClassDecl(ClassDecl *CD) {
     return;
 
   auto &ctxt = CD->getASTContext();
-
-  if (ctxt.LangOpts.EnableObjCInterop) {
-    addSymbol(LinkEntity::forSwiftMetaclassStub(CD));
+  auto isGeneric = CD->isGenericContext();
+  auto objCCompatible = ctxt.LangOpts.EnableObjCInterop && !isGeneric;
+  auto isObjC = objCCompatible && CD->isObjC();
+
+  // Metaclasses and ObjC class (duh) are a ObjC thing, and so are not needed in
+  // build artifacts/for classes which can't touch ObjC.
+  if (objCCompatible) {
+    if (isObjC)
+      addSymbol(LinkEntity::forObjCClass(CD));
+
+    if (CD->getMetaclassKind() == ClassDecl::MetaclassKind::ObjC)
+      addSymbol(LinkEntity::forObjCMetaclass(CD));
+    else
+      addSymbol(LinkEntity::forSwiftMetaclassStub(CD));
   }
 
   // Some members of classes get extra handling, beyond members of struct/enums,
@@ -243,17 +262,21 @@ void TBDGenVisitor::visitClassDecl(ClassDecl *CD) {
       continue;
 
     auto var = dyn_cast<VarDecl>(value);
-    auto hasFieldOffset = var && var->hasStorage() && !var->isStatic();
+    auto hasFieldOffset =
+        !isGeneric && var && var->hasStorage() && !var->isStatic();
     if (hasFieldOffset) {
-      // These fields are always direct.
-      addSymbol(LinkEntity::forFieldOffset(var, /*isIndirect=*/false));
+      // Field are only direct if the class's internals are completely known.
+      auto isIndirect = !CD->hasFixedLayout();
+      addSymbol(LinkEntity::forFieldOffset(var, isIndirect));
     }
 
     // The non-allocating forms of the constructors and destructors.
     if (auto ctor = dyn_cast<ConstructorDecl>(value)) {
       addSymbol(SILDeclRef(ctor, SILDeclRef::Kind::Initializer));
     } else if (auto dtor = dyn_cast<DestructorDecl>(value)) {
-      addSymbol(SILDeclRef(dtor, SILDeclRef::Kind::Destroyer));
+      // ObjC classes don't have a symbol for their destructor.
+      if (!isObjC)
+        addSymbol(SILDeclRef(dtor, SILDeclRef::Kind::Destroyer));
     }
   }
 
@@ -272,4 +295,7 @@ void swift::enumeratePublicSymbols(FileUnit *file, StringSet &symbols,
   TBDGenVisitor visitor(symbols, linkInfo, file->getParentModule());
   for (auto d : decls)
     visitor.visit(d);
+
+  if (file->hasEntryPoint())
+    symbols.insert("main");
 }

test/IRGen/objc_class_export.swift

@@ -63,7 +63,7 @@
 // -- TODO: The OBJC_CLASS symbol should reflect the qualified runtime name of
 //    Foo.
 // CHECK: @_T017objc_class_export3FooCN = hidden alias %swift.type, bitcast (i64* getelementptr inbounds ({{.*}} @_T017objc_class_export3FooCMf, i32 0, i32 2) to %swift.type*)
-// CHECK: @"OBJC_CLASS_$__TtC17objc_class_export3Foo" = alias %swift.type, %swift.type* @_T017objc_class_export3FooCN
+// CHECK: @"OBJC_CLASS_$__TtC17objc_class_export3Foo" = hidden alias %swift.type, %swift.type* @_T017objc_class_export3FooCN
 
 import gizmo
 

test/TBD/Input/objc_class_header.h

@@ -0,0 +1,2 @@
+@protocol ObjCProtocol
+@end

test/TBD/class.swift

@@ -76,6 +76,30 @@ open class OpenStatics {
     }
 }
 
+open class OpenGeneric<T, U, V> {
+  public var publicVar: T
+  internal var internalVar: U
+  private var privateVar: V
+
+  public var publicVarConcrete: Int = 0
+  internal var internalVarConcrete: Int = 0
+  private var privateVarConcrete: Int = 0
+
+  public init<S>(t: T, u: U, v: V, _: S) {
+    publicVar = t
+    internalVar = u
+    privateVar = v
+  }
+
+  public func publicGeneric<A>(_: A) {}
+  internal func internalGeneric<A>(_: A) {}
+  private func privateGeneric<A>(_: A) {}
+
+  public static func publicStaticGeneric<A>(_: A) {}
+  internal static func internalStaticGeneric<A>(_: A) {}
+  private static func privateStaticGeneric<A>(_: A) {}
+}
+
 public class PublicNothing {}
 
 public class PublicInit {
@@ -152,6 +176,30 @@ public class PublicStatics {
     }
 }
 
+public class PublicGeneric<T, U, V> {
+  public var publicVar: T
+  internal var internalVar: U
+  private var privateVar: V
+
+  public var publicVarConcrete: Int = 0
+  internal var internalVarConcrete: Int = 0
+  private var privateVarConcrete: Int = 0
+
+  public init<S>(t: T, u: U, v: V, _: S) {
+    publicVar = t
+    internalVar = u
+    privateVar = v
+  }
+
+  public func publicGeneric<A>(_: A) {}
+  internal func internalGeneric<A>(_: A) {}
+  private func privateGeneric<A>(_: A) {}
+
+  public static func publicStaticGeneric<A>(_: A) {}
+  internal static func internalStaticGeneric<A>(_: A) {}
+  private static func privateStaticGeneric<A>(_: A) {}
+}
+
 
 internal class InternalNothing {}
 
@@ -210,6 +258,26 @@ internal class InternalStatics {
     }
 }
 
+internal class InternalGeneric<T, U, V> {
+  internal var internalVar: U
+  private var privateVar: V
+
+  internal var internalVarConcrete: Int = 0
+  private var privateVarConcrete: Int = 0
+
+  internal init<S>(t: T, u: U, v: V, _: S) {
+    internalVar = u
+    privateVar = v
+  }
+
+  internal func internalGeneric<A>(_: A) {}
+  private func privateGeneric<A>(_: A) {}
+
+  internal static func internalStaticGeneric<A>(_: A) {}
+  private static func privateStaticGeneric<A>(_: A) {}
+}
+
+
 private class PrivateNothing {}
 
 private class PrivateInit {
@@ -249,3 +317,17 @@ private class PrivateStatics {
         set {}
     }
 }
+
+private class PrivateGeneric<T, U, V> {
+  private var privateVar: V
+
+  private var privateVarConcrete: Int = 0
+
+  private init<S>(t: T, u: U, v: V, _: S) {
+    privateVar = v
+  }
+
+  private func privateGeneric<A>(_: A) {}
+
+  private static func privateStaticGeneric<A>(_: A) {}
+}

test/TBD/class_objc.swift

@@ -0,0 +1,29 @@
+// RUN: %target-swift-frontend -c -parse-as-library -module-name test -import-objc-header %S/Input/objc_class_header.h -validate-tbd-against-ir %s
+
+// REQUIRES: objc_interop
+
+import Foundation
+
+public class PublicEmpty: NSObject {}
+
+public class PublicSubPublicEmpty: PublicEmpty {}
+internal class InternalSubPublicEmpty: PublicEmpty {}
+private class PrivateSubPublicEmpty: PublicEmpty {}
+
+
+internal class InternalEmpty: NSObject {}
+
+internal class InternalSubInternalEmpty: InternalEmpty {}
+private class PrivateSubInternalEmpty: InternalEmpty {}
+
+
+private class PrivateEmpty: NSObject {}
+
+private class PrivateSubPrivateEmpty: PrivateEmpty {}
+
+
+public class PublicInheritObjCProtocol: NSObject, ObjCProtocol {}
+
+internal class InternalInheritObjCProtocol: NSObject, ObjCProtocol {}
+
+private class PrivateInheritObjCProtocol: NSObject, ObjCProtocol {}

test/TBD/main.swift

@@ -0,0 +1,3 @@
+// RUN: %target-swift-frontend -c -module-name test -validate-tbd-against-ir %s
+
+// Top-level code (i.e. implicit `main`) should be handled