Merge pull request swiftlang#16748 from huonw/tbdgen

[TBDGen] Cover more symbols

Author: huonw

lib/TBDGen/TBDGen.cpp

@@ -120,6 +120,12 @@ void TBDGenVisitor::addConformances(DeclContext *DC) {
 void TBDGenVisitor::visitAbstractFunctionDecl(AbstractFunctionDecl *AFD) {
   addSymbol(SILDeclRef(AFD));
 
+  if (AFD->getAttrs().hasAttribute<CDeclAttr>()) {
+    // A @_cdecl("...") function has an extra symbol, with the name from the
+    // attribute.
+    addSymbol(SILDeclRef(AFD).asForeign());
+  }
+
   if (!SwiftModule->getASTContext().isSwiftVersion3())
     return;
 
@@ -216,12 +222,26 @@ void TBDGenVisitor::visitClassDecl(ClassDecl *CD) {
 
   visitNominalTypeDecl(CD);
 
-  // The below symbols are only emitted if the class is resilient.
-  if (!CD->isResilient())
+  auto hasResilientAncestor =
+      CD->isResilient(SwiftModule, ResilienceExpansion::Minimal);
+  auto ancestor = CD->getSuperclassDecl();
+  while (ancestor && !hasResilientAncestor) {
+    hasResilientAncestor |=
+        ancestor->isResilient(SwiftModule, ResilienceExpansion::Maximal);
+    ancestor = ancestor->getSuperclassDecl();
+  }
+
+  // Types with resilient superclasses have some extra symbols.
+  if (!hasResilientAncestor)
     return;
 
   addSymbol(LinkEntity::forClassMetadataBaseOffset(CD));
 
+  // And classes that are themselves resilient (not just a superclass) have even
+  // more.
+  if (!CD->isResilient())
+    return;
+
   // Emit dispatch thunks for every new vtable entry.
   struct VTableVisitor : public SILVTableVisitor<VTableVisitor> {
     TBDGenVisitor &TBD;
@@ -300,6 +320,8 @@ void TBDGenVisitor::visitProtocolDecl(ProtocolDecl *PD) {
 }
 
 void TBDGenVisitor::visitEnumDecl(EnumDecl *ED) {
+  visitNominalTypeDecl(ED);
+
   if (!ED->isResilient())
     return;
 

test/TBD/Inputs/subclass_super.swift

@@ -0,0 +1,9 @@
+open class Super {
+    open func function() {}
+
+    open var getter: Int { return 0 }
+    open var getterSetter: Int {
+        get { return 0 }
+        set {}
+    }
+}

test/TBD/enum.swift

@@ -1,17 +1,50 @@
 // RUN: %target-swift-frontend -emit-ir -o- -parse-as-library -module-name test -validate-tbd-against-ir=missing %s
 // RUN: %target-swift-frontend -enable-resilience -emit-ir -o- -parse-as-library -module-name test -validate-tbd-against-ir=missing %s
+// Swift 4:
+// RUN: %target-swift-frontend -emit-ir -o- -parse-as-library -module-name test -validate-tbd-against-ir=missing %s -swift-version 4
+// RUN: %target-swift-frontend -enable-resilience -emit-ir -o- -parse-as-library -module-name test -validate-tbd-against-ir=missing %s -swift-version 4
 
-class C {
+public protocol P {}
+
+public class C {
 }
 
-enum SinglePayload {
+public enum SinglePayload: P {
   case A
   case B(C)
   case D
 }
 
-enum MultiPayload {
+public enum MultiPayload {
   case A
   case B(C)
   case D(C)
+
+  public func method() {}
+}
+
+public enum AutomaticEquatableHashable {
+  case a, b
+}
+
+public enum Synthesized: Equatable, Hashable {
+  case a(AutomaticEquatableHashable), b
+}
+public enum ConditionalSynthesized<T> {
+  case a(T), b
+}
+
+#if swift(>=4)
+extension ConditionalSynthesized: Equatable where T: Equatable {}
+extension ConditionalSynthesized: Hashable where T: Hashable {}
+#endif
+
+public enum ZeroCases {}
+
+public enum OneCase {
+  case a
+}
+
+public enum OneCasePayload {
+  case a(C)
 }

test/TBD/function.swift

@@ -12,3 +12,11 @@ internal func internalWithDefault(_: Int = 0) {}
 private func privateNoArgs() {}
 private func privateSomeArgs(_: Int, x: Int) {}
 private func privateWithDefault(_: Int = 0) {}
+
+@_cdecl("c_publicNoArgs") public func publicNoArgsCDecl() {}
+@_cdecl("c_publicSomeArgs") public func publicSomeArgsCDecl(_: Int, x: Int) {}
+@_cdecl("c_publicWithDefault") public func publicWithDefaultCDecl(_: Int = 0) {}
+
+@_cdecl("c_internalNoArgs") internal func internalNoArgsCDecl() {}
+@_cdecl("c_internalSomeArgs") internal func internalSomeArgsCDecl(_: Int, x: Int) {}
+@_cdecl("c_internalWithDefault") internal func internalWithDefaultCDecl(_: Int = 0) {}

test/TBD/subclass.swift.gyb

@@ -0,0 +1,55 @@
+// RUN: %empty-directory(%t)
+// RUN: %gyb %s > %t/main.swift
+
+// Same-module superclass, both resilient and not:
+// RUN: %target-swift-frontend -emit-ir -o- -parse-as-library -module-name test -validate-tbd-against-ir=missing %t/main.swift -DSAME_MODULE
+// RUN: %target-swift-frontend -enable-resilience -emit-ir -o- -parse-as-library -module-name test -validate-tbd-against-ir=missing %t/main.swift -DSAME_MODULE
+
+
+// Other-module superclass is not resilient:
+// RUN: %empty-directory(%t/super)
+// RUN: %target-build-swift %S/Inputs/subclass_super.swift -emit-library -emit-module -o %t/super/subclass_super.%target-dylib-extension
+// RUN: %target-swift-frontend -emit-ir -o- -parse-as-library -module-name test -validate-tbd-against-ir=missing %t/main.swift -I %t/super
+// RUN: %target-swift-frontend -enable-resilience -emit-ir -o- -parse-as-library -module-name test -validate-tbd-against-ir=missing %t/main.swift -I %t/super
+
+// Other-module superclass is resilient:
+// RUN: %empty-directory(%t/super)
+// RUN: %target-build-swift %S/Inputs/subclass_super.swift -emit-library -emit-module -o %t/super/subclass_super.%target-dylib-extension -Xfrontend -enable-resilience
+// RUN: %target-swift-frontend -emit-ir -o- -parse-as-library -module-name test -validate-tbd-against-ir=missing %t/main.swift -I %t/super
+// RUN: %target-swift-frontend -enable-resilience -emit-ir -o- -parse-as-library -module-name test -validate-tbd-against-ir=missing %t/main.swift -I %t/super
+
+#if SAME_MODULE
+open class Super {
+    open func function() {}
+
+    open var getter: Int { return 0 }
+    open var getterSetter: Int {
+        get { return 0 }
+        set {}
+    }
+}
+#else
+import subclass_super
+#endif
+
+// Create a variety of variations like `open class ... { open override
+// func function() }` and `public class ... { public final override
+// func function() }`.
+% for access in ["open", "public", "internal", "fileprivate"]:
+% for class_final in [""] if access == "open" else ["", "final"]:
+% for member_final in [""] if access == "open" else ["", "final"]:
+% class_mod = "%s %s" % (access, class_final)
+% name = "Sub_%s_%s_%s" % (access, class_final, member_final)
+% member_mod = "%s %s" % (access, member_final)
+${class_mod} class ${name} : Super {
+    ${member_mod} override func function() {}
+
+    ${member_mod} override var getter: Int { return 0 }
+
+    ${member_mod} override var getterSetter: Int {
+        get { return 0 }
+        set {}
+    }
+}
+% end
+% end