handle bridging header decls in ForwardDeclaredConcreteTypeVisitor

Author: hnrklssn

lib/ClangImporter/SwiftifyDecl.cpp

@@ -228,7 +228,7 @@ struct CountedByExpressionValidator
     case clang::BuiltinType::ULong:
     case clang::BuiltinType::LongLong:
     case clang::BuiltinType::ULongLong:
-      DLOG("Ignoring count parameter with non-portable integer literal");
+      DLOG("Ignoring count parameter with non-portable integer literal\n");
       return false;
     default:
       return true;
@@ -330,7 +330,7 @@ struct UnaliasedInstantiationVisitor
   bool
   VisitTemplateSpecializationType(const clang::TemplateSpecializationType *) {
     hasUnaliasedInstantiation = true;
-    DLOG("Signature contains raw template, skipping");
+    DLOG("Signature contains raw template, skipping\n");
     return false;
   }
 };
@@ -340,15 +340,33 @@ struct ForwardDeclaredConcreteTypeVisitor
   bool hasForwardDeclaredConcreteType = false;
   const clang::Module *Owner;
 
-  ForwardDeclaredConcreteTypeVisitor(const clang::Module *Owner) : Owner(Owner) { ASSERT(Owner); };
+  ForwardDeclaredConcreteTypeVisitor(const clang::Module *Owner) : Owner(Owner) {};
 
   bool VisitRecordType(clang::RecordType *RT) {
     const clang::RecordDecl *RD = RT->getDecl()->getDefinition();
     ASSERT(RD && "pointer to concrete type without type definition?");
     const clang::Module *M = RD->getOwningModule();
+
+    if (!Owner && !M) {
+      DLOG("Both decls are in bridging header");
+      return true;
+    }
+
+    if (!Owner) {
+      hasForwardDeclaredConcreteType = true;
+      DLOG("Imported signature contains concrete type not available in bridging header, skipping\n");
+      LLVM_DEBUG(DUMP(RD));
+      return false;
+    }
+    if (!M) {
+      ABORT([RD](auto &out) {
+        out << "Imported signature contains concrete type without an owning clang module:\n";
+        RD->dump(out);
+      });
+    }
     if (!Owner->isModuleVisible(M)) {
       hasForwardDeclaredConcreteType = true;
-      DLOG("Imported signature contains concrete type not available in clang module, skipping");
+      DLOG("Imported signature contains concrete type not available in clang module, skipping\n");
       LLVM_DEBUG(DUMP(RD));
       return false;
     }
@@ -415,7 +433,7 @@ static bool swiftifyImpl(ClangImporter::Implementation &Self,
     return false;
 
   if (ClangDecl->isImplicit()) {
-    DLOG("implicit functions lack lifetime and bounds info");
+    DLOG("implicit functions lack lifetime and bounds info\n");
     return false;
   }
 
@@ -427,6 +445,8 @@ static bool swiftifyImpl(ClangImporter::Implementation &Self,
   } else {
     OwningModule = ClangDecl->getOwningModule();
   }
+  bool IsInBridgingHeader = MappedDecl->getModuleContext()->getName().str() == CLANG_HEADER_MODULE_NAME;
+  ASSERT(OwningModule || IsInBridgingHeader);
   ForwardDeclaredConcreteTypeVisitor CheckForwardDecls(OwningModule);
 
   // We only attach the macro if it will produce an overload. Any __counted_by
@@ -620,7 +640,7 @@ void ClangImporter::Implementation::swiftify(AbstractFunctionDecl *MappedDecl) {
 
   MacroDecl *SwiftifyImportDecl = dyn_cast_or_null<MacroDecl>(getKnownSingleDecl(SwiftContext, "_SwiftifyImport"));
   if (!SwiftifyImportDecl) {
-    DLOG("_SwiftifyImport macro not found");
+    DLOG("_SwiftifyImport macro not found\n");
     return;
   }
 
@@ -672,7 +692,7 @@ void ClangImporter::Implementation::swiftifyProtocol(
   MacroDecl *SwiftifyImportDecl = dyn_cast_or_null<MacroDecl>(
       getKnownSingleDecl(SwiftContext, "_SwiftifyImportProtocol"));
   if (!SwiftifyImportDecl) {
-    DLOG("_SwiftifyImportProtocol macro not found");
+    DLOG("_SwiftifyImportProtocol macro not found\n");
     return;
   }
 

test/Interop/C/swiftify-import/bridging-header.swift

@@ -16,6 +16,9 @@ imports for TMP_DIR/test.swift:
 	_StringProcessing
 	_SwiftConcurrencyShims
 	_Concurrency
+	A
+	B
+	C
 imports for __ObjC.foo:
 imports for @__swiftmacro_So3foo15_SwiftifyImportfMp_.swift:
 	__ObjC
@@ -25,21 +28,73 @@ imports for @__swiftmacro_So3foo15_SwiftifyImportfMp_.swift:
 @__swiftmacro_So3foo15_SwiftifyImportfMp_.swift
 ------------------------------
 /// This is an auto-generated wrapper for safer interop
-@_alwaysEmitIntoClient @available(visionOS 1.0, tvOS 12.2, watchOS 5.2, iOS 12.2, macOS 10.14.4, *) @_disfavoredOverload public func foo(_ p: Span<Int32>) {
-    let len = Int32(exactly: p.count)!
+@_alwaysEmitIntoClient @available(visionOS 1.0, tvOS 12.2, watchOS 5.2, iOS 12.2, macOS 10.14.4, *) @_disfavoredOverload public func foo(_ p: Span<a_t>, _ x: UnsafeMutablePointer<no_module_record_t>!) {
+    let len = no_module_t(exactly: p.count)!
     return unsafe p.withUnsafeBufferPointer { _pPtr in
-      return unsafe foo(len, _pPtr.baseAddress!)
+      return unsafe foo(len, _pPtr.baseAddress!, x)
     }
 }
 ------------------------------
 
 //--- test.swift
-func test(s: Span<CInt>) {
-  foo(s)
+import A
+import B
+import C
+
+func test(s: Span<a_t>, x: UnsafeMutablePointer<no_module_record_t>) {
+  unsafe foo(s, x)
+}
+
+func test2(p: UnsafeMutablePointer<CInt>, len: CInt, y: UnsafeMutablePointer<b_t>) {
+  unsafe bar(len, p, y)
+}
+
+func test3(p: UnsafeMutablePointer<CInt>, len: CInt, z: UnsafeMutablePointer<c_t>) {
+  unsafe baz(len, p, z)
 }
 
 //--- bridging.h
 #include <ptrcheck.h>
 #include <lifetimebound.h>
 
-void foo(int len, const int * __counted_by(len) p __noescape);
+#include "no-module.h"
+#include "a.h"
+#include "c.h"
+
+struct no_module_record_t;
+void foo(no_module_t len, const a_t * __counted_by(len) p __noescape, struct no_module_record_t *x);
+
+struct b_t;
+void bar(int len, const int * __counted_by(len) p __noescape, struct b_t *y);
+
+void baz(int len, const int * __counted_by(len) p __noescape, struct c_t *z);
+
+//--- no-module.h
+typedef int no_module_t;
+struct no_module_record_t {
+  int placeholder;
+};
+
+//--- a.h
+typedef int a_t;
+
+//--- b.h
+struct b_t {
+  int placeholder;
+};
+
+//--- c.h
+struct c_t {
+  int placeholder;
+};
+
+//--- module.modulemap
+module A {
+  header "a.h"
+}
+module B {
+  header "b.h"
+}
+module C {
+  header "c.h"
+}