[interop] add 'ImportSymbolicCXXDecls' experimental import mode for importing class templates syntactically but not semantically

Author: hyp

include/swift/Basic/Features.def

@@ -167,6 +167,11 @@ EXPERIMENTAL_FEATURE(BuiltinMacros, false)
 /// declare an attribute which is discoverable and constructable at runtime.
 EXPERIMENTAL_FEATURE(RuntimeDiscoverableAttrs, false)
 
+/// Import C++ class templates as semantically-meaningless symbolic
+/// Swift types and C++ methods as symbolic functions with blank
+/// signatures.
+EXPERIMENTAL_FEATURE(ImportSymbolicCXXDecls, false)
+
 #undef EXPERIMENTAL_FEATURE
 #undef UPCOMING_FEATURE
 #undef SUPPRESSIBLE_LANGUAGE_FEATURE

lib/AST/ASTPrinter.cpp

@@ -3170,6 +3170,8 @@ static bool usesFeatureBuiltinMacros(Decl *decl) {
   return false;
 }
 
+static bool usesFeatureImportSymbolicCXXDecls(Decl *decl) { return false; }
+
 static void
 suppressingFeatureNoAsyncAvailability(PrintOptions &options,
                                       llvm::function_ref<void()> action) {

lib/ClangImporter/ClangImporter.cpp

@@ -2269,13 +2269,13 @@ ClangImporter::Implementation::Implementation(
           !ctx.ClangImporterOpts.BridgingHeader.empty()),
       DisableOverlayModules(ctx.ClangImporterOpts.DisableOverlayModules),
       EnableClangSPI(ctx.ClangImporterOpts.EnableClangSPI),
+      importSymbolicCXXDecls(
+          ctx.LangOpts.hasFeature(Feature::ImportSymbolicCXXDecls)),
       IsReadingBridgingPCH(false),
       CurrentVersion(ImportNameVersion::fromOptions(ctx.LangOpts)),
-      Walker(DiagnosticWalker(*this)),
-      BuffersForDiagnostics(ctx.SourceMgr),
+      Walker(DiagnosticWalker(*this)), BuffersForDiagnostics(ctx.SourceMgr),
       BridgingHeaderLookupTable(new SwiftLookupTable(nullptr)),
-      platformAvailability(ctx.LangOpts),
-      nameImporter(),
+      platformAvailability(ctx.LangOpts), nameImporter(),
       DisableSourceImport(ctx.ClangImporterOpts.DisableSourceImport),
       DWARFImporter(dwarfImporterDelegate) {}
 

lib/ClangImporter/ImportDecl.cpp

@@ -2005,7 +2005,8 @@ namespace {
       }
 
       // TODO(https://github.com/apple/swift/issues/56206): Fix this once we support dependent types.
-      if (decl->getTypeForDecl()->isDependentType()) {
+      if (decl->getTypeForDecl()->isDependentType() &&
+          !Impl.importSymbolicCXXDecls) {
         Impl.addImportDiagnostic(
             decl, Diagnostic(
                       diag::record_is_dependent,
@@ -2681,6 +2682,12 @@ namespace {
 
     Decl *VisitClassTemplateSpecializationDecl(
                  const clang::ClassTemplateSpecializationDecl *decl) {
+      // Treat a specific specialization like the unspecialized class template
+      // when importing it in symbolic mode.
+      if (Impl.importSymbolicCXXDecls)
+        return Impl.importDecl(decl->getSpecializedTemplate(),
+                               Impl.CurrentVersion);
+
       // Before we go any further, check if we've already got tens of thousands
       // of specializations. If so, it means we're likely instantiating a very
       // deep/complex template, or we've run into an infinite loop. In either
@@ -3067,6 +3074,8 @@ namespace {
               Impl.SwiftContext, SourceLoc(), templateParams, SourceLoc());
       }
 
+      bool importFuncWithoutSignature =
+          isa<clang::CXXMethodDecl>(decl) && Impl.importSymbolicCXXDecls;
       if (!dc->isModuleScopeContext() && !isa<clang::CXXMethodDecl>(decl)) {
         // Handle initializers.
         if (name.getBaseName() == DeclBaseName::createConstructor()) {
@@ -3132,12 +3141,17 @@ namespace {
           importedType =
               Impl.importFunctionReturnType(dc, decl, allowNSUIntegerAsInt);
       } else {
-        // Import the function type. If we have parameters, make sure their
-        // names get into the resulting function type.
-        importedType = Impl.importFunctionParamsAndReturnType(
-            dc, decl, {decl->param_begin(), decl->param_size()},
-            decl->isVariadic(), isInSystemModule(dc), name, bodyParams,
-            templateParams);
+        if (importFuncWithoutSignature) {
+          importedType = ImportedType{Impl.SwiftContext.getVoidType(), false};
+          bodyParams = ParameterList::createEmpty(Impl.SwiftContext);
+        } else {
+          // Import the function type. If we have parameters, make sure their
+          // names get into the resulting function type.
+          importedType = Impl.importFunctionParamsAndReturnType(
+              dc, decl, {decl->param_begin(), decl->param_size()},
+              decl->isVariadic(), isInSystemModule(dc), name, bodyParams,
+              templateParams);
+        }
 
         if (auto *mdecl = dyn_cast<clang::CXXMethodDecl>(decl)) {
           if (mdecl->isStatic()) {
@@ -3221,7 +3235,7 @@ namespace {
           }
         }
 
-        if (importedName.isSubscriptAccessor()) {
+        if (importedName.isSubscriptAccessor() && !importFuncWithoutSignature) {
           assert(func->getParameters()->size() == 1);
           auto typeDecl = dc->getSelfNominalTypeDecl();
           auto parameter = func->getParameters()->get(0);
@@ -3496,6 +3510,12 @@ namespace {
       auto name = importedName.getDeclName().getBaseIdentifier();
       if (name.empty())
         return nullptr;
+
+      if (Impl.importSymbolicCXXDecls)
+        // Import an unspecialized C++ class template as a Swift value/class
+        // type in symbolic mode.
+        return Impl.importDecl(decl->getTemplatedDecl(), Impl.CurrentVersion);
+
       auto loc = Impl.importSourceLoc(decl->getLocation());
       auto dc = Impl.importDeclContextOf(
           decl, importedName.getEffectiveContext());

lib/ClangImporter/ImportName.cpp

@@ -2173,6 +2173,11 @@ ImportedName NameImporter::importNameImpl(const clang::NamedDecl *D,
 
   if (auto classTemplateSpecDecl =
           dyn_cast<clang::ClassTemplateSpecializationDecl>(D)) {
+    /// Symbolic specializations get imported as the symbolic class template
+    /// type.
+    if (importSymbolicCXXDecls)
+      return importNameImpl(classTemplateSpecDecl->getSpecializedTemplate(),
+                            version, givenName);
     if (!isa<clang::ClassTemplatePartialSpecializationDecl>(D)) {
 
       auto &astContext = classTemplateSpecDecl->getASTContext();

lib/ClangImporter/ImportName.h

@@ -387,11 +387,15 @@ class NameImporter {
   llvm::DenseMap<std::pair<const clang::ObjCInterfaceDecl *, char>,
                  std::unique_ptr<InheritedNameSet>> allProperties;
 
+  bool importSymbolicCXXDecls;
+
 public:
   NameImporter(ASTContext &ctx, const PlatformAvailability &avail,
                clang::Sema &cSema)
       : swiftCtx(ctx), availability(avail), clangSema(cSema),
-        enumInfos(clangSema.getPreprocessor()) {}
+        enumInfos(clangSema.getPreprocessor()),
+        importSymbolicCXXDecls(
+            ctx.LangOpts.hasFeature(Feature::ImportSymbolicCXXDecls)) {}
 
   /// Determine the Swift name for a Clang decl
   ImportedName importName(const clang::NamedDecl *decl,

lib/ClangImporter/ImportType.cpp

@@ -66,6 +66,10 @@ bool ClangImporter::Implementation::isOverAligned(const clang::TypeDecl *decl) {
 }
 
 bool ClangImporter::Implementation::isOverAligned(clang::QualType type) {
+  // Do not check type layout for a clang type in symbolic mode as the
+  // type could be a dependent type.
+  if (importSymbolicCXXDecls)
+    return false;
   auto align = getClangASTContext().getTypeAlignInChars(type);
   return align > clang::CharUnits::fromQuantity(MaximumAlignment);
 }

lib/ClangImporter/ImporterImpl.h

@@ -452,6 +452,7 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
   const bool BridgingHeaderExplicitlyRequested;
   const bool DisableOverlayModules;
   const bool EnableClangSPI;
+  bool importSymbolicCXXDecls;
 
   bool IsReadingBridgingPCH;
   llvm::SmallVector<clang::serialization::SubmoduleID, 2> PCHImportedSubmodules;

test/Interop/Cxx/symbolic-imports/print-libcxx-symbolic-module-interface.swift

@@ -0,0 +1,20 @@
+// RUN: %target-swift-ide-test -print-module -module-to-print=CxxStdlib -source-filename=x -enable-experimental-cxx-interop -enable-objc-interop -module-print-submodules -enable-experimental-feature ImportSymbolicCXXDecls | %FileCheck %s
+
+// REQUIRES: asserts
+// REQUIRES: OS=macosx
+// REQUIRES: libcxx-in-sdk
+
+// CHECK: enum std {
+// CHECK-NEXT: enum __1 {
+
+// CHECK: struct basic_string {
+
+// CHECK: typealias string = std.__1.basic_string
+
+// CHECK: struct vector {
+// CHECK: mutating func push_back()
+// CHECK: }
+
+// CHECK: struct map {
+
+// CHECK-NOT: enum std

test/Interop/Cxx/symbolic-imports/print-symbolic-module-interface.swift

@@ -0,0 +1,66 @@
+// RUN: rm -rf %t
+// RUN: split-file %s %t
+// RUN: %target-swift-ide-test -print-module -module-to-print=CxxModule -I %t/Inputs -source-filename=x -enable-experimental-cxx-interop -enable-experimental-feature ImportSymbolicCXXDecls | %FileCheck %s
+
+// REQUIRES: asserts
+
+//--- Inputs/module.modulemap
+module CxxModule {
+    header "headerA.h"
+    header "headerB.h"
+    requires cplusplus
+}
+
+//--- Inputs/headerA.h
+
+namespace ns {
+    int freeFunction(int x, int y);
+}
+
+//--- Inputs/headerB.h
+
+#include "headerA.h"
+
+namespace ns {
+    struct B {
+        int y;
+    };
+
+    template<class T>
+    struct TemplateRecord {
+        void methodFunc(int x);
+
+        struct InnerRecord {
+            int innerMethod(int y);
+        };
+
+        template<class T2>
+        struct InnerTemplate {
+            void innerTemplateMethod();
+        };
+
+        InnerTemplate<int> returnsTemplateMethod();
+    };
+}
+
+using MyType = ns::TemplateRecord<int>;
+
+// CHECK:     enum ns {
+// CHECK-NEXT: struct B {
+// CHECK-NEXT:    init()
+// CHECK-NEXT:    init(y: Int32)
+// CHECK-NEXT:    var y: Int32
+// CHECK-NEXT:  }
+// CHECK-NEXT:  struct TemplateRecord {
+// CHECK-NEXT:    mutating func methodFunc()
+// CHECK-NEXT:    struct InnerRecord {
+// CHECK-NEXT:      mutating func innerMethod()
+// CHECK-NEXT:    }
+// CHECK-NEXT:    struct InnerTemplate {
+// CHECK-NEXT:      mutating func innerTemplateMethod()
+// CHECK-NEXT:    }
+// CHECK-NEXT:    mutating func returnsTemplateMethod()
+// CHECK-NEXT:  }
+// CHECK-NEXT:  static func freeFunction(_ x: Int32, _ y: Int32) -> Int32
+// CHECK-NEXT: }
+// CHECK-NEXT: typealias MyType = ns.TemplateRecord