[cxx-interop] Emit type metadata for foreign types more often

Metadata for foreign types are emitted lazily, when SILGen generates a
reference to it. Unfortunately, C++ reverse interop can also introduce
references to such metadata in the generated header when types are used
as generic arguments. This adds a type visitor to make note of the type
metadata use for those generic arguments in public APIs when C++ interop
is enabled.

rdar://132925256

Author: Gabor Horvath

lib/IRGen/IRGenSIL.cpp

@@ -18,6 +18,7 @@
 #include "GenKeyPath.h"
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/ASTMangler.h"
+#include "swift/AST/Decl.h"
 #include "swift/AST/DiagnosticsIRGen.h"
 #include "swift/AST/ExtInfo.h"
 #include "swift/AST/GenericEnvironment.h"
@@ -26,6 +27,9 @@
 #include "swift/AST/Pattern.h"
 #include "swift/AST/SemanticAttrs.h"
 #include "swift/AST/SubstitutionMap.h"
+#include "swift/AST/Type.h"
+#include "swift/AST/TypeExpansionContext.h"
+#include "swift/AST/TypeVisitor.h"
 #include "swift/AST/Types.h"
 #include "swift/Basic/Assertions.h"
 #include "swift/Basic/ExternalUnion.h"
@@ -2472,6 +2476,76 @@ static void emitDynamicSelfMetadata(IRGenSILFunction &IGF) {
   IGF.setDynamicSelfMetadata(selfTy, isExact, value, selfKind);
 }
 
+namespace {
+// Notes the use of foreign types in generic arguments for C++ interop.
+class NoteUseOfForeignTypeMetadata
+    : public TypeVisitor<NoteUseOfForeignTypeMetadata, void, bool> {
+public:
+  NoteUseOfForeignTypeMetadata(IRGenerator &IRGen) : IRGen(IRGen) {}
+
+  void visitType(TypeBase *, bool) {}
+
+  void visitTupleType(TupleType *TT, bool isInGenericArgument) {
+    for (auto type : TT->getElementTypes())
+      TypeVisitor::visit(type, isInGenericArgument);
+  }
+
+  void visitSugarType(SugarType *sugarTy, bool isInGenericArgument) {
+    TypeVisitor::visit(sugarTy->getSinglyDesugaredType(), isInGenericArgument);
+  }
+
+  void visitClassType(ClassType *CT, bool isInGenericArgument) {
+    noteUseOfTypeMetadata(CT->getDecl(), isInGenericArgument);
+  }
+
+  void visitEnumType(EnumType *ET, bool isInGenericArgument) {
+    noteUseOfTypeMetadata(ET->getDecl(), isInGenericArgument);
+  }
+
+  void visitStructType(StructType *ST, bool isInGenericArgument) {
+    noteUseOfTypeMetadata(ST->getDecl(), isInGenericArgument);
+  }
+
+  void visitBoundGenericType(BoundGenericType *BGT, bool isInGenericArgument) {
+    for (auto type : BGT->getGenericArgs())
+      TypeVisitor::visit(type, true);
+  }
+
+  void visitDynamicSelfType(DynamicSelfType *ds, bool isInGenericArgument) {
+    TypeVisitor::visit(ds->getSelfType(), isInGenericArgument);
+  }
+
+private:
+  void noteUseOfTypeMetadata(NominalTypeDecl *type, bool isInGenericArgument) {
+    if (!isInGenericArgument)
+      return;
+    if (!IRGen.hasLazyMetadata(type) || !type->hasClangNode())
+      return;
+    IRGen.noteUseOfTypeMetadata(type);
+  }
+  IRGenerator &IRGen;
+};
+} // namespace
+
+/// C++ interop might refer to the type metadat in some scenarios.
+/// This function covers those cases and makes sure metadata is emitted
+/// for the foreing types.
+static void noteUseOfMetadataByCXXInterop(IRGenerator &IRGen,
+                                          const SILFunction *f,
+                                          const TypeExpansionContext &context) {
+  auto type = f->getLoweredFunctionType();
+
+  auto processType = [&](CanType type) {
+    NoteUseOfForeignTypeMetadata visitor(IRGen);
+    visitor.visit(type, false);
+  };
+
+  for (const auto &param : type->getParameters())
+    processType(param.getArgumentType(IRGen.SIL, type, context));
+  for (const auto &result : type->getResultsWithError())
+    processType(result.getReturnValueType(IRGen.SIL, type, context));
+}
+
 /// Emit the definition for the given SIL constant.
 void IRGenModule::emitSILFunction(SILFunction *f) {
   if (f->isExternalDeclaration())
@@ -2487,6 +2561,10 @@ void IRGenModule::emitSILFunction(SILFunction *f) {
       f->isAvailableExternally())
     return;
 
+  if (Context.LangOpts.EnableCXXInterop &&
+      f->getLinkage() == SILLinkage::Public)
+    noteUseOfMetadataByCXXInterop(IRGen, f, TypeExpansionContext(*f));
+
   PrettyStackTraceSILFunction stackTrace("emitting IR", f);
   IRGenSILFunction(*this, f).emitSILFunction();
 }

test/Interop/CxxToSwiftToCxx/link-cxx-type-metadata-accessor.swift

@@ -17,6 +17,14 @@ struct CxxStruct {
     int x;
 };
 
+struct CxxStruct2 {
+    inline CxxStruct2(int x) : x(x) {}
+    inline CxxStruct2(const CxxStruct &other) : x(other.x) {}
+    inline ~CxxStruct2() {}
+
+    int x;
+};
+
 //--- module.modulemap
 module CxxTest {
     header "header.h"
@@ -30,6 +38,10 @@ public func retCxxStruct() -> CxxStruct {
     return CxxStruct(2)
 }
 
+public func retCxxStruct2() -> CxxStruct2? {
+    return CxxStruct2(2)
+}
+
 //--- use-swift-cxx-types.cpp
 
 #include "header.h"
@@ -38,5 +50,6 @@ public func retCxxStruct() -> CxxStruct {
 
 int main() {
   auto x = UseCxx::retCxxStruct();
+  auto y = UseCxx::retCxxStruct2();
   return 0;
 }