auto-reexport inferred exported submodules

Author: QuietMisdreavus

include/swift/AST/Module.h

@@ -810,6 +810,12 @@ class ModuleDecl
   /// returns the module \c Foo.
   ModuleDecl *getTopLevelModule(bool overlay = false);
 
+  /// Returns whether or not this module is a submodule of the given module.
+  /// If `this == M`, this returns false. If this is a submodule such as
+  /// `Foo.Bar.Baz`, and the given module is either `Foo` or `Foo.Bar`, this
+  /// returns true.
+  bool isSubmoduleOf(const ModuleDecl *M) const;
+
   bool isResilient() const {
     return getResilienceStrategy() != ResilienceStrategy::Default;
   }

lib/AST/Module.cpp

@@ -901,6 +901,27 @@ ModuleDecl *ModuleDecl::getTopLevelModule(bool overlay) {
   return this;
 }
 
+bool ModuleDecl::isSubmoduleOf(const ModuleDecl *M) const {
+  // Swift modules don't currently support submodules.
+  if (!isNonSwiftModule())
+    return false;
+
+  auto *ClangParent = M->findUnderlyingClangModule();
+  if (!ClangParent)
+    return false;
+
+  auto *ClangModule = findUnderlyingClangModule();
+  if (!ClangModule)
+    return false;
+
+  while ((ClangModule = ClangModule->Parent)) {
+    if (ClangModule == ClangParent)
+      return true;
+  }
+
+  return false;
+}
+
 static bool isParsedModule(const ModuleDecl *mod) {
   // FIXME: If we ever get mixed modules that contain both SourceFiles and other
   // kinds of file units, this will break; there all callers of this function should
@@ -1435,8 +1456,12 @@ collectExportedImports(const ModuleDecl *topLevelModule,
   stack.push_back(topLevelModule);
   while (!stack.empty()) {
     const ModuleDecl *module = stack.pop_back_val();
-    if (module->isNonSwiftModule())
+    if (module->isNonSwiftModule() && module != topLevelModule &&
+        !module->isSubmoduleOf(topLevelModule)) {
+      // Recurse into submodules of the top-level module so that we can
+      // re-export them if necessary.
       continue;
+    }
 
     for (const FileUnit *file : module->getFiles()) {
       if (const SourceFile *source = dyn_cast<SourceFile>(file)) {

lib/ClangImporter/ClangImporter.cpp

@@ -3585,8 +3585,7 @@ class VectorDeclPtrConsumer : public swift::VisibleDeclConsumer {
 };
 } // unnamed namespace
 
-// FIXME(https://github.com/apple/swift-docc/issues/190): Should submodules still be crawled for the symbol graph?
-bool ClangModuleUnit::shouldCollectDisplayDecls() const { return isTopLevel(); }
+bool ClangModuleUnit::shouldCollectDisplayDecls() const { return true; }
 
 void ClangModuleUnit::getTopLevelDecls(SmallVectorImpl<Decl*> &results) const {
   VectorDeclPtrConsumer consumer(results);

lib/SymbolGraphGen/SymbolGraphASTWalker.cpp

@@ -338,7 +338,7 @@ bool SymbolGraphASTWalker::isConsideredExportedImported(const Decl *D) const {
 }
 
 bool SymbolGraphASTWalker::isFromExportedImportedModule(const Decl* D, bool countUnderlyingClangModule) const {
-  auto *M = D->getModuleContext();
+  auto *M = getRealModuleOf(D);
   return isQualifiedExportedImport(D) || isExportedImportedModule(M, countUnderlyingClangModule);
 }
 

lib/SymbolGraphGen/SymbolGraphGen.cpp

@@ -17,6 +17,7 @@
 #include "swift/AST/Module.h"
 #include "swift/AST/NameLookup.h"
 #include "swift/Sema/IDETypeChecking.h"
+#include "clang/Basic/Module.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/JSON.h"
 #include "llvm/Support/Path.h"
@@ -62,18 +63,34 @@ int symbolgraphgen::emitSymbolGraphForModule(
     ModuleDecl *M, const SymbolGraphOptions &Options) {
   ModuleDecl::ImportCollector importCollector(Options.MinimumAccessLevel);
 
-  auto importFilter = [&Options](const ModuleDecl *module) {
-      if (!module)
-        return false;
+  bool IncludeClangSubmodules = false;
+  if (auto *ClangModule = M->findUnderlyingClangModule()) {
+    // If a Clang module has a definition that includes `export *; module * {
+    // export *; }` then we want to treat those inferred submodules as part of
+    // the parent module, to preserve historical behavior.
+    if (ClangModule->InferSubmodules && ClangModule->InferExportWildcard) {
+      IncludeClangSubmodules = true;
+    }
+  }
+
+  auto importFilter = [&Options, &IncludeClangSubmodules,
+                       &M](const ModuleDecl *module) {
+    if (!module)
+      return false;
+
+    if (IncludeClangSubmodules && module->isSubmoduleOf(M)) {
+      return true;
+    }
 
+    if (Options.AllowedReexportedModules.has_value())
       for (const auto &allowedModuleName : *Options.AllowedReexportedModules)
         if (allowedModuleName == module->getNameStr())
           return true;
 
-       return false;
-    };
+    return false;
+  };
 
-  if (Options.AllowedReexportedModules.has_value())
+  if (Options.AllowedReexportedModules.has_value() || IncludeClangSubmodules)
     importCollector.importFilter = std::move(importFilter);
 
   SmallVector<Decl *, 64> ModuleDecls;

test/SymbolGraph/ClangImporter/UmbrellaSubmodules.swift

@@ -0,0 +1,31 @@
+// RUN: %empty-directory(%t)
+
+// RUN: %empty-directory(%t/SwiftAttr)
+// RUN: split-file %s %t
+
+// RUN: %target-swift-symbolgraph-extract -sdk %clang-importer-sdk -module-name UmbrellaSubmodules -I %t/UmbrellaSubmodules -output-dir %t -pretty-print -v
+// RUN: %FileCheck %s --input-file %t/UmbrellaSubmodules.symbols.json
+
+//--- UmbrellaSubmodules/module.modulemap
+module UmbrellaSubmodules {
+    umbrella header "UmbrellaSubmodules.h"
+
+    export *
+    module * {
+        export *
+    }
+}
+
+//--- UmbrellaSubmodules/UmbrellaSubmodules.h
+#include "HeaderOne.h"
+#include "HeaderTwo.h"
+// CHECK-DAG: "precise": "c:UmbrellaSubmodules.h@umbrellaVar"
+static int umbrellaVar = 0;
+
+//--- UmbrellaSubmodules/HeaderOne.h
+// CHECK-DAG: "precise": "c:HeaderOne.h@varOne"
+static int varOne = 1;
+
+//--- UmbrellaSubmodules/HeaderTwo.h
+// CHECK-DAG: "precise": "c:HeaderTwo.h@varTwo"
+static int varTwo = 2;