[interop][SwiftToCxx] initial generic struct support

include/swift/IRGen/IRABIDetailsProvider.h

@@ -105,6 +105,12 @@ class IRABIDetailsProvider {
   /// access function.
   FunctionABISignature getTypeMetadataAccessFunctionSignature();
 
+  /// Returns additional generic requirement parameters that are required to
+  /// call the type metadata access function for the given type.
+  SmallVector<GenericRequirement, 2>
+  getTypeMetadataAccessFunctionGenericRequirementParameters(
+      NominalTypeDecl *nominal);
+
   struct EnumElementInfo {
     unsigned tag;
     StringRef globalVariableName;

lib/IRGen/IRABIDetailsProvider.cpp

@@ -15,6 +15,7 @@
 #include "FixedTypeInfo.h"
 #include "GenEnum.h"
 #include "GenType.h"
+#include "GenericRequirement.h"
 #include "IRGen.h"
 #include "IRGenModule.h"
 #include "NativeConventionSchema.h"
@@ -126,6 +127,16 @@ class IRABIDetailsProviderImpl {
     return {returnTy, {paramTy}};
   }
 
+  SmallVector<GenericRequirement, 2>
+  getTypeMetadataAccessFunctionGenericRequirementParameters(
+      NominalTypeDecl *nominal) {
+    GenericTypeRequirements requirements(IGM, nominal);
+    SmallVector<GenericRequirement, 2> result;
+    for (const auto &req : requirements.getRequirements())
+      result.push_back(req);
+    return result;
+  }
+
   llvm::MapVector<EnumElementDecl *, IRABIDetailsProvider::EnumElementInfo>
   getEnumTagMapping(const EnumDecl *ED) {
     llvm::MapVector<EnumElementDecl *, IRABIDetailsProvider::EnumElementInfo>
@@ -221,6 +232,13 @@ IRABIDetailsProvider::getTypeMetadataAccessFunctionSignature() {
   return impl->getTypeMetadataAccessFunctionSignature();
 }
 
+SmallVector<GenericRequirement, 2>
+IRABIDetailsProvider::getTypeMetadataAccessFunctionGenericRequirementParameters(
+    NominalTypeDecl *nominal) {
+  return impl->getTypeMetadataAccessFunctionGenericRequirementParameters(
+      nominal);
+}
+
 llvm::MapVector<EnumElementDecl *, IRABIDetailsProvider::EnumElementInfo>
 IRABIDetailsProvider::getEnumTagMapping(const EnumDecl *ED) {
   return impl->getEnumTagMapping(ED);

lib/PrintAsClang/ClangSyntaxPrinter.cpp

@@ -159,8 +159,10 @@ void ClangSyntaxPrinter::printNullability(
 }
 
 void ClangSyntaxPrinter::printSwiftTypeMetadataAccessFunctionCall(
-    StringRef name) {
-  os << name << "(0)";
+    StringRef name, ArrayRef<GenericRequirement> requirements) {
+  os << name << "(0";
+  printGenericRequirementsInstantiantions(requirements, LeadingTrivia::Comma);
+  os << ')';
 }
 
 void ClangSyntaxPrinter::printValueWitnessTableAccessSequenceFromTypeMetadata(
@@ -187,12 +189,92 @@ void ClangSyntaxPrinter::printValueWitnessTableAccessSequenceFromTypeMetadata(
 }
 
 void ClangSyntaxPrinter::printCTypeMetadataTypeFunction(
-    const NominalTypeDecl *typeDecl, StringRef typeMetadataFuncName) {
+    const NominalTypeDecl *typeDecl, StringRef typeMetadataFuncName,
+    llvm::ArrayRef<GenericRequirement> genericRequirements) {
+  // FIXME: Support generic requirements > 3.
+  if (!genericRequirements.empty())
+    os << "static_assert(" << genericRequirements.size()
+       << " <= " << NumDirectGenericTypeMetadataAccessFunctionArgs
+       << ", \"unsupported generic requirement list for metadata func\");\n";
   os << "// Type metadata accessor for " << typeDecl->getNameStr() << "\n";
   os << "SWIFT_EXTERN ";
   printSwiftImplQualifier();
   os << "MetadataResponseTy " << typeMetadataFuncName << '(';
   printSwiftImplQualifier();
-  os << "MetadataRequestTy)";
+  os << "MetadataRequestTy";
+  if (!genericRequirements.empty())
+    os << ", ";
+  llvm::interleaveComma(genericRequirements, os,
+                        [&](const GenericRequirement &) {
+                          // FIXME: Print parameter name.
+                          os << "void * _Nonnull";
+                        });
+  os << ')';
   os << " SWIFT_NOEXCEPT SWIFT_CALL;\n\n";
 }
+
+void ClangSyntaxPrinter::printGenericTypeParamTypeName(
+    const GenericTypeParamType *gtpt) {
+  os << "T_" << gtpt->getDepth() << '_' << gtpt->getIndex();
+}
+
+void ClangSyntaxPrinter::printGenericSignature(
+    const CanGenericSignature &signature) {
+  os << "template<";
+  llvm::interleaveComma(
+      signature.getGenericParams(), os,
+      [&](const CanTypeWrapper<GenericTypeParamType> &genericParamType) {
+        os << "class ";
+        printGenericTypeParamTypeName(genericParamType);
+      });
+  os << ">\n";
+  os << "requires ";
+  llvm::interleave(
+      signature.getGenericParams(), os,
+      [&](const CanTypeWrapper<GenericTypeParamType> &genericParamType) {
+        os << "swift::isUsableInGenericContext<";
+        printGenericTypeParamTypeName(genericParamType);
+        os << ">";
+      },
+      " && ");
+  os << "\n";
+}
+
+void ClangSyntaxPrinter::printGenericSignatureParams(
+    const CanGenericSignature &signature) {
+  os << '<';
+  llvm::interleaveComma(
+      signature.getGenericParams(), os,
+      [&](const CanTypeWrapper<GenericTypeParamType> &genericParamType) {
+        printGenericTypeParamTypeName(genericParamType);
+      });
+  os << '>';
+}
+
+void ClangSyntaxPrinter::printGenericRequirementInstantiantion(
+    const GenericRequirement &requirement) {
+  assert(!requirement.Protocol && "protocol requirements not supported yet!");
+  auto *gtpt = requirement.TypeParameter->getAs<GenericTypeParamType>();
+  assert(gtpt && "unexpected generic param type");
+  os << "swift::getTypeMetadata<";
+  printGenericTypeParamTypeName(gtpt);
+  os << ">()";
+}
+
+void ClangSyntaxPrinter::printGenericRequirementsInstantiantions(
+    ArrayRef<GenericRequirement> requirements, LeadingTrivia leadingTrivia) {
+  if (leadingTrivia == LeadingTrivia::Comma && !requirements.empty())
+    os << ", ";
+  llvm::interleaveComma(requirements, os,
+                        [&](const GenericRequirement &requirement) {
+                          printGenericRequirementInstantiantion(requirement);
+                        });
+}
+
+void ClangSyntaxPrinter::printPrimaryCxxTypeName(
+    const NominalTypeDecl *type, const ModuleDecl *moduleContext) {
+  printModuleNamespaceQualifiersIfNeeded(type->getModuleContext(),
+                                         moduleContext);
+  // FIXME: Print class qualifiers for nested class references.
+  printBaseName(type);
+}

lib/PrintAsClang/ClangSyntaxPrinter.h

@@ -13,13 +13,16 @@
 #ifndef SWIFT_PRINTASCLANG_CLANGSYNTAXPRINTER_H
 #define SWIFT_PRINTASCLANG_CLANGSYNTAXPRINTER_H
 
+#include "swift/AST/GenericRequirement.h"
 #include "swift/Basic/LLVM.h"
 #include "swift/ClangImporter/ClangImporter.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace swift {
 
+class CanGenericSignature;
+class GenericTypeParamType;
 class ModuleDecl;
 class NominalTypeDecl;
 
@@ -41,6 +44,8 @@ StringRef getCxxOpaqueStorageClassName();
 
 class ClangSyntaxPrinter {
 public:
+  enum class LeadingTrivia { None, Comma };
+
   ClangSyntaxPrinter(raw_ostream &os) : os(os) {}
 
   /// Print a given identifier. If the identifer conflicts with a keyword, add a
@@ -98,16 +103,46 @@ class ClangSyntaxPrinter {
   static bool isClangKeyword(Identifier name);
 
   /// Print the call expression to the Swift type metadata access function.
-  void printSwiftTypeMetadataAccessFunctionCall(StringRef name);
+  void printSwiftTypeMetadataAccessFunctionCall(
+      StringRef name, ArrayRef<GenericRequirement> requirements);
 
   /// Print the set of statements to access the value witness table pointer
   /// ('vwTable') from the given type metadata variable.
   void printValueWitnessTableAccessSequenceFromTypeMetadata(
       StringRef metadataVariable, StringRef vwTableVariable, int indent);
 
   /// Print the metadata accessor function for the given type declaration.
-  void printCTypeMetadataTypeFunction(const NominalTypeDecl *typeDecl,
-                                      StringRef typeMetadataFuncName);
+  void printCTypeMetadataTypeFunction(
+      const NominalTypeDecl *typeDecl, StringRef typeMetadataFuncName,
+      llvm::ArrayRef<GenericRequirement> genericRequirements);
+
+  /// Print the name of the generic type param type in C++.
+  void printGenericTypeParamTypeName(const GenericTypeParamType *gtpt);
+
+  /// Print the Swift generic signature as C++ template declaration alongside
+  /// its requirements.
+  void printGenericSignature(const CanGenericSignature &signature);
+
+  /// Print the C++ template parameters that should be passed for a given
+  /// generic signature.
+  void printGenericSignatureParams(const CanGenericSignature &signature);
+
+  /// Print the call to the C++ type traits that computes the underlying type /
+  /// witness table pointer value that are passed to Swift for the given generic
+  /// requirement.
+  void
+  printGenericRequirementInstantiantion(const GenericRequirement &requirement);
+
+  /// Print the list of calls to C++ type traits that compute the generic
+  /// pointer values to pass to Swift.
+  void printGenericRequirementsInstantiantions(
+      ArrayRef<GenericRequirement> requirements,
+      LeadingTrivia leadingTrivia = LeadingTrivia::None);
+
+  // Print the C++ type name that corresponds to the primary user facing C++
+  // class for the given nominal type.
+  void printPrimaryCxxTypeName(const NominalTypeDecl *type,
+                               const ModuleDecl *moduleContext);
 
 protected:
   raw_ostream &os;

lib/PrintAsClang/PrintClangClassType.cpp

@@ -37,7 +37,7 @@ void ClangClassTypePrinter::printClassTypeDecl(
                            // Print out special functions, like functions that
                            // access type metadata.
                            printer.printCTypeMetadataTypeFunction(
-                               typeDecl, typeMetadataFuncName);
+                               typeDecl, typeMetadataFuncName, {});
                          });
 
   std::string baseClassName;