Improve showing import relations for C++20 modules

doxygen · doxygen · commit 2851a911e4dc · 2024-11-14T21:00:53.000+01:00
diff --git a/src/moduledef.cpp b/src/moduledef.cpp
@@ -185,13 +185,13 @@ void ModuleDefImpl::addHeader(int line,const QCString &headerName,bool isSystem)
 void ModuleDefImpl::addImport(int line,const QCString &moduleName,const QCString &partitionName,bool isExported)
 {
   AUTO_TRACE("name={}:line={},module={},partition={}",name(),line,moduleName,partitionName);
-  m_imports.emplace(getDefFileName().str()+":"+std::to_string(line),ImportInfo(this,moduleName,line,partitionName,isExported));
+  m_imports[getDefFileName().str()+":"+std::to_string(line)].push_back(ImportInfo(this,moduleName,line,partitionName,isExported));
 }
 
 void ModuleDefImpl::addExportedModule(const QCString &moduleName,const ImportInfo &info)
 {
   AUTO_TRACE("name={}:moduleName={},import={}",name(),moduleName,info.importName);
-  m_exportedModules.emplace(moduleName.str(),info);
+  m_exportedModules[moduleName.str()].push_back(info);
 }
 
 void ModuleDefImpl::addClassToModule(const Entry *root,ClassDef *cd)
@@ -886,32 +886,35 @@ void ModuleDefImpl::writeExports(OutputList &ol,const QCString &title)
     ol.parseText(title);
     ol.endMemberHeader();
     ol.startMemberList();
-    for (auto &[moduleName,importInfo] : m_exportedModules)
+    for (const auto &[moduleName,importInfoList] : m_exportedModules)
     {
-      ModuleDef *mod = ModuleManager::instance().getPrimaryInterface(importInfo.importName);
-      ol.startMemberDeclaration();
-      ol.startMemberItem(importInfo.importName,OutputGenerator::MemberItemType::Normal);
-      ol.docify(theTranslator->trModule(FALSE,TRUE)+" ");
-      ol.insertMemberAlign();
-      if (mod && mod->isLinkable())
+      for (const auto &importInfo : importInfoList)
       {
-        ol.writeObjectLink(mod->getReference(),mod->getOutputFileBase(),QCString(),mod->displayName());
-      }
-      else
-      {
-        ol.startBold();
-        ol.docify(importInfo.importName);
-        ol.endBold();
-      }
-      ol.endMemberItem(OutputGenerator::MemberItemType::Normal);
-      if (mod && !mod->briefDescription().isEmpty() && Config_getBool(BRIEF_MEMBER_DESC))
-      {
-        ol.startMemberDescription(mod->getOutputFileBase());
-        ol.generateDoc(briefFile(),briefLine(),mod,nullptr,mod->briefDescription(),FALSE,FALSE,
-            QCString(),TRUE,FALSE,Config_getBool(MARKDOWN_SUPPORT));
-        ol.endMemberDescription();
+        ModuleDef *mod = ModuleManager::instance().getPrimaryInterface(importInfo.importName);
+        ol.startMemberDeclaration();
+        ol.startMemberItem(importInfo.importName,OutputGenerator::MemberItemType::Normal);
+        ol.docify(theTranslator->trModule(FALSE,TRUE)+" ");
+        ol.insertMemberAlign();
+        if (mod && mod->isLinkable())
+        {
+          ol.writeObjectLink(mod->getReference(),mod->getOutputFileBase(),QCString(),mod->displayName());
+        }
+        else
+        {
+          ol.startBold();
+          ol.docify(importInfo.importName);
+          ol.endBold();
+        }
+        ol.endMemberItem(OutputGenerator::MemberItemType::Normal);
+        if (mod && !mod->briefDescription().isEmpty() && Config_getBool(BRIEF_MEMBER_DESC))
+        {
+          ol.startMemberDescription(mod->getOutputFileBase());
+          ol.generateDoc(briefFile(),briefLine(),mod,nullptr,mod->briefDescription(),FALSE,FALSE,
+              QCString(),TRUE,FALSE,Config_getBool(MARKDOWN_SUPPORT));
+          ol.endMemberDescription();
+        }
+        ol.endMemberDeclaration(QCString(),QCString());
       }
-      ol.endMemberDeclaration(QCString(),QCString());
     }
     ol.endMemberList();
   }
@@ -1246,7 +1249,7 @@ void ModuleManager::addImport(const QCString &moduleFile,int line,const QCString
   else // import outside of a module
   {
     AUTO_TRACE_ADD("outside module");
-    p->externalImports.emplace(moduleFile.str(),ImportInfo(nullptr,importName,line,partitionName));
+    p->externalImports[moduleFile.str()].emplace_back(nullptr,importName,line,partitionName);
   }
 }
 
@@ -1301,32 +1304,38 @@ void ModuleManager::addTagInfo(const QCString &fileName,const QCString &tagFile,
 void ModuleManager::resolvePartitionsRecursively(ModuleDef *intfMod, ModuleDef *mod)
 {
   AUTO_TRACE();
-  for (auto &[partitionFileName,importInfo] : mod->getImports()) // foreach import
+  for (auto &[partitionFileName,importInfoList] : mod->getImports()) // foreach import
   {
-    AUTO_TRACE_ADD("partitionFileName={} importName={} partitionName={}",
-        partitionFileName,importInfo.importName,importInfo.partitionName);
-    if (importInfo.importName==intfMod->name() && !importInfo.partitionName.isEmpty() &&
-        importInfo.exported) // that is an exported partition of this module
+    for (auto &importInfo : importInfoList)
     {
-      auto it = p->moduleNameMap.find(importInfo.importName.str());
-      if (it != p->moduleNameMap.end())
+      AUTO_TRACE_ADD("partitionFileName={} importName={} partitionName={}",
+          partitionFileName,importInfo.importName,importInfo.partitionName);
+      if (importInfo.importName==intfMod->name() && !importInfo.partitionName.isEmpty() &&
+          importInfo.exported) // that is an exported partition of this module
       {
-        for (auto importedMod : it->second)
+        auto it = p->moduleNameMap.find(importInfo.importName.str());
+        if (it != p->moduleNameMap.end())
         {
-          if (importedMod->qualifiedName()==importInfo.importName+":"+importInfo.partitionName)
+          for (auto importedMod : it->second)
           {
-            AUTO_TRACE_ADD("Interface module {} exports partition {}:{}",
-                mod->name(),importedMod->name(),importedMod->partitionName());
-            toModuleDefImpl(intfMod)->addPartition(toModuleDefImpl(importedMod));
-            toModuleDefImpl(importedMod)->setPrimaryInterface(intfMod);
-            for (const auto &[partitionFileName_,partitionImportInfo] : importedMod->getImports())
+            if (importedMod->qualifiedName()==importInfo.importName+":"+importInfo.partitionName)
             {
-              if (partitionImportInfo.exported && intfMod->name()!=partitionImportInfo.importName)
+              AUTO_TRACE_ADD("Interface module {} exports partition {}:{}",
+                  mod->name(),importedMod->name(),importedMod->partitionName());
+              toModuleDefImpl(intfMod)->addPartition(toModuleDefImpl(importedMod));
+              toModuleDefImpl(importedMod)->setPrimaryInterface(intfMod);
+              for (const auto &[partitionFileName_,partitionImportInfoList] : importedMod->getImports())
               {
-                toModuleDefImpl(intfMod)->addExportedModule(partitionImportInfo.importName,partitionImportInfo);
+                for (const auto &partitionImportInfo : partitionImportInfoList)
+                {
+                  if (partitionImportInfo.exported && intfMod->name()!=partitionImportInfo.importName)
+                  {
+                    toModuleDefImpl(intfMod)->addExportedModule(partitionImportInfo.importName,partitionImportInfo);
+                  }
+                }
               }
+              resolvePartitionsRecursively(intfMod,importedMod);
             }
-            resolvePartitionsRecursively(intfMod,importedMod);
           }
         }
       }
@@ -1345,11 +1354,14 @@ void ModuleManager::resolvePartitions()
     }
 
     // copy exported imports to m_exportedModules
-    for (const auto &[fileName,importInfo] : mod->getImports())
+    for (const auto &[fileName,importInfoList] : mod->getImports())
     {
-      if (importInfo.exported && mod->name()!=importInfo.importName)
+      for (const auto &importInfo : importInfoList)
       {
-        toModuleDefImpl(mod)->addExportedModule(importInfo.importName,importInfo);
+        if (importInfo.exported && mod->name()!=importInfo.importName)
+        {
+          toModuleDefImpl(mod)->addExportedModule(importInfo.importName,importInfo);
+        }
       }
     }
 
@@ -1372,37 +1384,61 @@ void ModuleManager::resolveImports()
     FileDef *fd = mod->getFileDef();
     if (fd)
     {
-      for (const auto &[fileName,importInfo] : mod->getImports())
+      for (const auto &[fileName,importInfoList] : mod->getImports())
       {
-        ModuleDef *importedModule = getPrimaryInterface(importInfo.importName);
-        const FileDef *importedFd = importedModule ? importedModule->getFileDef() : nullptr;
-        AUTO_TRACE_ADD("module: addIncludeDependency {}->{}:{} fd={}",
-             mod->qualifiedName(), importInfo.qualifiedName(), importInfo.line, fd?fd->absFilePath():"");
-        fd->addIncludeDependency(importedFd,importInfo.qualifiedName(),IncludeKind::ImportModule);
+        for (const auto &importInfo : importInfoList)
+        {
+          ModuleDef *importedModule = getPrimaryInterface(importInfo.importName);
+          const FileDef *importedFd = importedModule ? importedModule->getFileDef() : nullptr;
+          AUTO_TRACE_ADD("module: addIncludeDependency {}->{}:{} fd={}",
+              mod->qualifiedName(), importInfo.qualifiedName(), importInfo.line, fd?fd->absFilePath():"");
+          fd->addIncludeDependency(importedFd,importInfo.qualifiedName(),IncludeKind::ImportModule);
+        }
       }
     }
   }
-  for (const auto &[fileName,importInfo] : p->externalImports)
+  for (const auto &[fileName,importInfoList] : p->externalImports)
   {
-    bool ambig = false;
-    FileDef *fd = findFileDef(Doxygen::inputNameLinkedMap,QCString(fileName),ambig);
-    if (fd)
+    for (const auto &importInfo : importInfoList)
     {
-      ModuleDef *mod = getPrimaryInterface(importInfo.importName);
-      FileDef *importedFd = mod ? mod->getFileDef() : nullptr;
-      fd->addIncludeDependency(importedFd,importInfo.importName,IncludeKind::ImportModule);
+      bool ambig = false;
+      FileDef *fd = findFileDef(Doxygen::inputNameLinkedMap,QCString(fileName),ambig);
+      AUTO_TRACE_ADD("externalImport name={} fd={}",fileName,(void*)fd);
+      if (fd)
+      {
+        ModuleDef *mod = getPrimaryInterface(importInfo.importName);
+        FileDef *importedFd = mod ? mod->getFileDef() : nullptr;
+        fd->addIncludeDependency(importedFd,importInfo.importName,IncludeKind::ImportModule);
+        if (importedFd)
+        {
+          importedFd->addIncludedByDependency(fd,stripFromPath(QCString(fileName)),IncludeKind::ImportModule);
+        }
+      }
+      else
+      {
+        fd->addIncludeDependency(nullptr,importInfo.importName,IncludeKind::ImportModule);
+      }
     }
   }
   for (const auto &headerInfo : p->headers)
   {
     bool ambig = false;
     FileDef *fd = findFileDef(Doxygen::inputNameLinkedMap,headerInfo.fileName,ambig);
+    AUTO_TRACE_ADD("header name={} fd={}",headerInfo.fileName,(void*)fd);
     if (fd)
     {
       QCString resolvedHeader = determineAbsoluteIncludeName(headerInfo.fileName,headerInfo.headerName);
       FileDef *importFd = findFileDef(Doxygen::inputNameLinkedMap,resolvedHeader,ambig);
       fd->addIncludeDependency(importFd, headerInfo.headerName,
                                headerInfo.isSystem ? IncludeKind::ImportSystem : IncludeKind::ImportLocal);
+      if (importFd)
+      {
+        importFd->addIncludedByDependency(fd,headerInfo.fileName,IncludeKind::ImportModule);
+      }
+    }
+    else
+    {
+      fd->addIncludeDependency(nullptr,headerInfo.headerName,IncludeKind::ImportModule);
     }
   }
 }
@@ -1468,7 +1504,7 @@ void ModuleManager::writeDocumentation(OutputList &ol)
 int ModuleManager::numDocumentedModules() const
 {
   int count=0;
-  for (auto &mod : p->moduleFileMap) // foreach module
+  for (const auto &mod : p->moduleFileMap) // foreach module
   {
     if (mod->isPrimaryInterface()) count++;
   }
@@ -1523,7 +1559,7 @@ ModuleDef *ModuleManager::getPrimaryInterface(const QCString &moduleName) const
   auto it = p->moduleNameMap.find(moduleName.str());
   if (it != p->moduleNameMap.end())
   {
-    for (auto &mod : it->second)
+    for (const auto &mod : it->second)
     {
       if (mod->isPrimaryInterface())
       {
@@ -1536,23 +1572,23 @@ ModuleDef *ModuleManager::getPrimaryInterface(const QCString &moduleName) const
 
 void ModuleManager::addListReferences()
 {
-  for (auto &mod : p->moduleFileMap) // foreach module
+  for (const auto &mod : p->moduleFileMap) // foreach module
   {
     if (mod->isPrimaryInterface()) toModuleDefImpl(mod)->addListReferences();
   }
 }
 
 void ModuleManager::addMembersToMemberGroup()
 {
-  for (auto &mod : p->moduleFileMap) // foreach module
+  for (const auto &mod : p->moduleFileMap) // foreach module
   {
     if (mod->isPrimaryInterface()) toModuleDefImpl(mod)->addMembersToMemberGroup();
   }
 }
 
 void ModuleManager::distributeMemberGroupDocumentation()
 {
-  for (auto &mod : p->moduleFileMap) // foreach module
+  for (const auto &mod : p->moduleFileMap) // foreach module
   {
     if (mod->isPrimaryInterface()) toModuleDefImpl(mod)->distributeMemberGroupDocumentation();
   }
diff --git a/src/moduledef.h b/src/moduledef.h
@@ -56,8 +56,9 @@ struct ImportInfo
   }
 };
 
+using ImportInfoList = std::vector<ImportInfo>;
 using ModuleMap = std::unordered_map<std::string,ModuleDef *>;
-using ImportInfoMap = std::unordered_map<std::string,ImportInfo>;
+using ImportInfoMap = std::unordered_map<std::string,ImportInfoList>;
 
 
 class ModuleDef : public DefinitionMutable, public Definition
diff --git a/src/xmlgen.cpp b/src/xmlgen.cpp
@@ -1352,17 +1352,20 @@ static void writeExports(const ImportInfoMap &exportMap,TextStream &t)
 {
   if (exportMap.empty()) return;
   t << "    <exports>\n";
-  for (auto &[moduleName,importInfo] : exportMap)
+  for (const auto &[moduleName,importInfoList] : exportMap)
   {
-    t << "      <export";
-    ModuleDef *mod = ModuleManager::instance().getPrimaryInterface(importInfo.importName);
-    if (mod && mod->isLinkableInProject())
+    for (const auto &importInfo : importInfoList)
     {
-      t << " refid=\"" << mod->getOutputFileBase() << "\"";
+      t << "      <export";
+      ModuleDef *mod = ModuleManager::instance().getPrimaryInterface(importInfo.importName);
+      if (mod && mod->isLinkableInProject())
+      {
+        t << " refid=\"" << mod->getOutputFileBase() << "\"";
+      }
+      t << ">";
+      t << importInfo.importName;
+      t << "</export>\n";
     }
-    t << ">";
-    t << importInfo.importName;
-    t << "</export>\n";
   }
   t << "    </exports>\n";
 }

Original file line number	Diff line number	Diff line change
`@@ -185,13 +185,13 @@ void ModuleDefImpl::addHeader(int line,const QCString &headerName,bool isSystem)`
`185`	`185`	`void ModuleDefImpl::addImport(int line,const QCString &moduleName,const QCString &partitionName,bool isExported)`
`186`	`186`	`{`
`187`	`187`	`AUTO_TRACE("name={}:line={},module={},partition={}",name(),line,moduleName,partitionName);`
`188`		`- m_imports.emplace(getDefFileName().str()+":"+std::to_string(line),ImportInfo(this,moduleName,line,partitionName,isExported));`
	`188`	`+ m_imports[getDefFileName().str()+":"+std::to_string(line)].push_back(ImportInfo(this,moduleName,line,partitionName,isExported));`
`189`	`189`	`}`
`190`	`190`
`191`	`191`	`void ModuleDefImpl::addExportedModule(const QCString &moduleName,const ImportInfo &info)`
`192`	`192`	`{`
`193`	`193`	`AUTO_TRACE("name={}:moduleName={},import={}",name(),moduleName,info.importName);`
`194`		`- m_exportedModules.emplace(moduleName.str(),info);`
	`194`	`+ m_exportedModules[moduleName.str()].push_back(info);`
`195`	`195`	`}`
`196`	`196`
`197`	`197`	`void ModuleDefImpl::addClassToModule(const Entry root,ClassDef cd)`
`@@ -886,32 +886,35 @@ void ModuleDefImpl::writeExports(OutputList &ol,const QCString &title)`
`886`	`886`	`ol.parseText(title);`
`887`	`887`	`ol.endMemberHeader();`
`888`	`888`	`ol.startMemberList();`
`889`		`- for (auto &[moduleName,importInfo] : m_exportedModules)`
	`889`	`+ for (const auto &[moduleName,importInfoList] : m_exportedModules)`
`890`	`890`	`{`
`891`		`- ModuleDef *mod = ModuleManager::instance().getPrimaryInterface(importInfo.importName);`
`892`		`- ol.startMemberDeclaration();`
`893`		`- ol.startMemberItem(importInfo.importName,OutputGenerator::MemberItemType::Normal);`
`894`		`- ol.docify(theTranslator->trModule(FALSE,TRUE)+" ");`
`895`		`- ol.insertMemberAlign();`
`896`		`- if (mod && mod->isLinkable())`
	`891`	`+ for (const auto &importInfo : importInfoList)`
`897`	`892`	`{`
`898`		`- ol.writeObjectLink(mod->getReference(),mod->getOutputFileBase(),QCString(),mod->displayName());`
`899`		`- }`
`900`		`- else`
`901`		`- {`
`902`		`- ol.startBold();`
`903`		`- ol.docify(importInfo.importName);`
`904`		`- ol.endBold();`
`905`		`- }`
`906`		`- ol.endMemberItem(OutputGenerator::MemberItemType::Normal);`
`907`		`- if (mod && !mod->briefDescription().isEmpty() && Config_getBool(BRIEF_MEMBER_DESC))`
`908`		`- {`
`909`		`- ol.startMemberDescription(mod->getOutputFileBase());`
`910`		`- ol.generateDoc(briefFile(),briefLine(),mod,nullptr,mod->briefDescription(),FALSE,FALSE,`
`911`		`- QCString(),TRUE,FALSE,Config_getBool(MARKDOWN_SUPPORT));`
`912`		`- ol.endMemberDescription();`
	`893`	`+ ModuleDef *mod = ModuleManager::instance().getPrimaryInterface(importInfo.importName);`
	`894`	`+ ol.startMemberDeclaration();`
	`895`	`+ ol.startMemberItem(importInfo.importName,OutputGenerator::MemberItemType::Normal);`
	`896`	`+ ol.docify(theTranslator->trModule(FALSE,TRUE)+" ");`
	`897`	`+ ol.insertMemberAlign();`
	`898`	`+ if (mod && mod->isLinkable())`
	`899`	`+ {`
	`900`	`+ ol.writeObjectLink(mod->getReference(),mod->getOutputFileBase(),QCString(),mod->displayName());`
	`901`	`+ }`
	`902`	`+ else`
	`903`	`+ {`
	`904`	`+ ol.startBold();`
	`905`	`+ ol.docify(importInfo.importName);`
	`906`	`+ ol.endBold();`
	`907`	`+ }`
	`908`	`+ ol.endMemberItem(OutputGenerator::MemberItemType::Normal);`
	`909`	`+ if (mod && !mod->briefDescription().isEmpty() && Config_getBool(BRIEF_MEMBER_DESC))`
	`910`	`+ {`
	`911`	`+ ol.startMemberDescription(mod->getOutputFileBase());`
	`912`	`+ ol.generateDoc(briefFile(),briefLine(),mod,nullptr,mod->briefDescription(),FALSE,FALSE,`
	`913`	`+ QCString(),TRUE,FALSE,Config_getBool(MARKDOWN_SUPPORT));`
	`914`	`+ ol.endMemberDescription();`
	`915`	`+ }`
	`916`	`+ ol.endMemberDeclaration(QCString(),QCString());`
`913`	`917`	`}`
`914`		`- ol.endMemberDeclaration(QCString(),QCString());`
`915`	`918`	`}`
`916`	`919`	`ol.endMemberList();`
`917`	`920`	`}`
`@@ -1246,7 +1249,7 @@ void ModuleManager::addImport(const QCString &moduleFile,int line,const QCString`
`1246`	`1249`	`else // import outside of a module`
`1247`	`1250`	`{`
`1248`	`1251`	`AUTO_TRACE_ADD("outside module");`
`1249`		`- p->externalImports.emplace(moduleFile.str(),ImportInfo(nullptr,importName,line,partitionName));`
	`1252`	`+ p->externalImports[moduleFile.str()].emplace_back(nullptr,importName,line,partitionName);`
`1250`	`1253`	`}`
`1251`	`1254`	`}`
`1252`	`1255`
`@@ -1301,32 +1304,38 @@ void ModuleManager::addTagInfo(const QCString &fileName,const QCString &tagFile,`
`1301`	`1304`	`void ModuleManager::resolvePartitionsRecursively(ModuleDef intfMod, ModuleDef mod)`
`1302`	`1305`	`{`
`1303`	`1306`	`AUTO_TRACE();`
`1304`		`- for (auto &[partitionFileName,importInfo] : mod->getImports()) // foreach import`
	`1307`	`+ for (auto &[partitionFileName,importInfoList] : mod->getImports()) // foreach import`
`1305`	`1308`	`{`
`1306`		`- AUTO_TRACE_ADD("partitionFileName={} importName={} partitionName={}",`
`1307`		`- partitionFileName,importInfo.importName,importInfo.partitionName);`
`1308`		`- if (importInfo.importName==intfMod->name() && !importInfo.partitionName.isEmpty() &&`
`1309`		`- importInfo.exported) // that is an exported partition of this module`
	`1309`	`+ for (auto &importInfo : importInfoList)`
`1310`	`1310`	`{`
`1311`		`- auto it = p->moduleNameMap.find(importInfo.importName.str());`
`1312`		`- if (it != p->moduleNameMap.end())`
	`1311`	`+ AUTO_TRACE_ADD("partitionFileName={} importName={} partitionName={}",`
	`1312`	`+ partitionFileName,importInfo.importName,importInfo.partitionName);`
	`1313`	`+ if (importInfo.importName==intfMod->name() && !importInfo.partitionName.isEmpty() &&`
	`1314`	`+ importInfo.exported) // that is an exported partition of this module`
`1313`	`1315`	`{`
`1314`		`- for (auto importedMod : it->second)`
	`1316`	`+ auto it = p->moduleNameMap.find(importInfo.importName.str());`
	`1317`	`+ if (it != p->moduleNameMap.end())`
`1315`	`1318`	`{`
`1316`		`- if (importedMod->qualifiedName()==importInfo.importName+":"+importInfo.partitionName)`
	`1319`	`+ for (auto importedMod : it->second)`
`1317`	`1320`	`{`
`1318`		`- AUTO_TRACE_ADD("Interface module {} exports partition {}:{}",`
`1319`		`- mod->name(),importedMod->name(),importedMod->partitionName());`
`1320`		`- toModuleDefImpl(intfMod)->addPartition(toModuleDefImpl(importedMod));`
`1321`		`- toModuleDefImpl(importedMod)->setPrimaryInterface(intfMod);`
`1322`		`- for (const auto &[partitionFileName_,partitionImportInfo] : importedMod->getImports())`
	`1321`	`+ if (importedMod->qualifiedName()==importInfo.importName+":"+importInfo.partitionName)`
`1323`	`1322`	`{`
`1324`		`- if (partitionImportInfo.exported && intfMod->name()!=partitionImportInfo.importName)`
	`1323`	`+ AUTO_TRACE_ADD("Interface module {} exports partition {}:{}",`
	`1324`	`+ mod->name(),importedMod->name(),importedMod->partitionName());`
	`1325`	`+ toModuleDefImpl(intfMod)->addPartition(toModuleDefImpl(importedMod));`
	`1326`	`+ toModuleDefImpl(importedMod)->setPrimaryInterface(intfMod);`
	`1327`	`+ for (const auto &[partitionFileName_,partitionImportInfoList] : importedMod->getImports())`
`1325`	`1328`	`{`
`1326`		`- toModuleDefImpl(intfMod)->addExportedModule(partitionImportInfo.importName,partitionImportInfo);`
	`1329`	`+ for (const auto &partitionImportInfo : partitionImportInfoList)`
	`1330`	`+ {`
	`1331`	`+ if (partitionImportInfo.exported && intfMod->name()!=partitionImportInfo.importName)`
	`1332`	`+ {`
	`1333`	`+ toModuleDefImpl(intfMod)->addExportedModule(partitionImportInfo.importName,partitionImportInfo);`
	`1334`	`+ }`
	`1335`	`+ }`
`1327`	`1336`	`}`
	`1337`	`+ resolvePartitionsRecursively(intfMod,importedMod);`
`1328`	`1338`	`}`
`1329`		`- resolvePartitionsRecursively(intfMod,importedMod);`
`1330`	`1339`	`}`
`1331`	`1340`	`}`
`1332`	`1341`	`}`
`@@ -1345,11 +1354,14 @@ void ModuleManager::resolvePartitions()`
`1345`	`1354`	`}`
`1346`	`1355`
`1347`	`1356`	`// copy exported imports to m_exportedModules`
`1348`		`- for (const auto &[fileName,importInfo] : mod->getImports())`
	`1357`	`+ for (const auto &[fileName,importInfoList] : mod->getImports())`
`1349`	`1358`	`{`
`1350`		`- if (importInfo.exported && mod->name()!=importInfo.importName)`
	`1359`	`+ for (const auto &importInfo : importInfoList)`
`1351`	`1360`	`{`
`1352`		`- toModuleDefImpl(mod)->addExportedModule(importInfo.importName,importInfo);`
	`1361`	`+ if (importInfo.exported && mod->name()!=importInfo.importName)`
	`1362`	`+ {`
	`1363`	`+ toModuleDefImpl(mod)->addExportedModule(importInfo.importName,importInfo);`
	`1364`	`+ }`
`1353`	`1365`	`}`
`1354`	`1366`	`}`
`1355`	`1367`
`@@ -1372,37 +1384,61 @@ void ModuleManager::resolveImports()`
`1372`	`1384`	`FileDef *fd = mod->getFileDef();`
`1373`	`1385`	`if (fd)`
`1374`	`1386`	`{`
`1375`		`- for (const auto &[fileName,importInfo] : mod->getImports())`
	`1387`	`+ for (const auto &[fileName,importInfoList] : mod->getImports())`
`1376`	`1388`	`{`
`1377`		`- ModuleDef *importedModule = getPrimaryInterface(importInfo.importName);`
`1378`		`- const FileDef *importedFd = importedModule ? importedModule->getFileDef() : nullptr;`
`1379`		`- AUTO_TRACE_ADD("module: addIncludeDependency {}->{}:{} fd={}",`
`1380`		`- mod->qualifiedName(), importInfo.qualifiedName(), importInfo.line, fd?fd->absFilePath():"");`
`1381`		`- fd->addIncludeDependency(importedFd,importInfo.qualifiedName(),IncludeKind::ImportModule);`
	`1389`	`+ for (const auto &importInfo : importInfoList)`
	`1390`	`+ {`
	`1391`	`+ ModuleDef *importedModule = getPrimaryInterface(importInfo.importName);`
	`1392`	`+ const FileDef *importedFd = importedModule ? importedModule->getFileDef() : nullptr;`
	`1393`	`+ AUTO_TRACE_ADD("module: addIncludeDependency {}->{}:{} fd={}",`
	`1394`	`+ mod->qualifiedName(), importInfo.qualifiedName(), importInfo.line, fd?fd->absFilePath():"");`
	`1395`	`+ fd->addIncludeDependency(importedFd,importInfo.qualifiedName(),IncludeKind::ImportModule);`
	`1396`	`+ }`
`1382`	`1397`	`}`
`1383`	`1398`	`}`
`1384`	`1399`	`}`
`1385`		`- for (const auto &[fileName,importInfo] : p->externalImports)`
	`1400`	`+ for (const auto &[fileName,importInfoList] : p->externalImports)`
`1386`	`1401`	`{`
`1387`		`- bool ambig = false;`
`1388`		`- FileDef *fd = findFileDef(Doxygen::inputNameLinkedMap,QCString(fileName),ambig);`
`1389`		`- if (fd)`
	`1402`	`+ for (const auto &importInfo : importInfoList)`
`1390`	`1403`	`{`
`1391`		`- ModuleDef *mod = getPrimaryInterface(importInfo.importName);`
`1392`		`- FileDef *importedFd = mod ? mod->getFileDef() : nullptr;`
`1393`		`- fd->addIncludeDependency(importedFd,importInfo.importName,IncludeKind::ImportModule);`
	`1404`	`+ bool ambig = false;`
	`1405`	`+ FileDef *fd = findFileDef(Doxygen::inputNameLinkedMap,QCString(fileName),ambig);`
	`1406`	`+ AUTO_TRACE_ADD("externalImport name={} fd={}",fileName,(void*)fd);`
	`1407`	`+ if (fd)`
	`1408`	`+ {`
	`1409`	`+ ModuleDef *mod = getPrimaryInterface(importInfo.importName);`
	`1410`	`+ FileDef *importedFd = mod ? mod->getFileDef() : nullptr;`
	`1411`	`+ fd->addIncludeDependency(importedFd,importInfo.importName,IncludeKind::ImportModule);`
	`1412`	`+ if (importedFd)`
	`1413`	`+ {`
	`1414`	`+ importedFd->addIncludedByDependency(fd,stripFromPath(QCString(fileName)),IncludeKind::ImportModule);`
	`1415`	`+ }`
	`1416`	`+ }`
	`1417`	`+ else`
	`1418`	`+ {`
	`1419`	`+ fd->addIncludeDependency(nullptr,importInfo.importName,IncludeKind::ImportModule);`
	`1420`	`+ }`
`1394`	`1421`	`}`
`1395`	`1422`	`}`
`1396`	`1423`	`for (const auto &headerInfo : p->headers)`
`1397`	`1424`	`{`
`1398`	`1425`	`bool ambig = false;`
`1399`	`1426`	`FileDef *fd = findFileDef(Doxygen::inputNameLinkedMap,headerInfo.fileName,ambig);`
	`1427`	`+ AUTO_TRACE_ADD("header name={} fd={}",headerInfo.fileName,(void*)fd);`
`1400`	`1428`	`if (fd)`
`1401`	`1429`	`{`
`1402`	`1430`	`QCString resolvedHeader = determineAbsoluteIncludeName(headerInfo.fileName,headerInfo.headerName);`
`1403`	`1431`	`FileDef *importFd = findFileDef(Doxygen::inputNameLinkedMap,resolvedHeader,ambig);`
`1404`	`1432`	`fd->addIncludeDependency(importFd, headerInfo.headerName,`
`1405`	`1433`	`headerInfo.isSystem ? IncludeKind::ImportSystem : IncludeKind::ImportLocal);`
	`1434`	`+ if (importFd)`
	`1435`	`+ {`
	`1436`	`+ importFd->addIncludedByDependency(fd,headerInfo.fileName,IncludeKind::ImportModule);`
	`1437`	`+ }`
	`1438`	`+ }`
	`1439`	`+ else`
	`1440`	`+ {`
	`1441`	`+ fd->addIncludeDependency(nullptr,headerInfo.headerName,IncludeKind::ImportModule);`
`1406`	`1442`	`}`
`1407`	`1443`	`}`
`1408`	`1444`	`}`
`@@ -1468,7 +1504,7 @@ void ModuleManager::writeDocumentation(OutputList &ol)`
`1468`	`1504`	`int ModuleManager::numDocumentedModules() const`
`1469`	`1505`	`{`
`1470`	`1506`	`int count=0;`
`1471`		`- for (auto &mod : p->moduleFileMap) // foreach module`
	`1507`	`+ for (const auto &mod : p->moduleFileMap) // foreach module`
`1472`	`1508`	`{`
`1473`	`1509`	`if (mod->isPrimaryInterface()) count++;`
`1474`	`1510`	`}`
`@@ -1523,7 +1559,7 @@ ModuleDef *ModuleManager::getPrimaryInterface(const QCString &moduleName) const`
`1523`	`1559`	`auto it = p->moduleNameMap.find(moduleName.str());`
`1524`	`1560`	`if (it != p->moduleNameMap.end())`
`1525`	`1561`	`{`
`1526`		`- for (auto &mod : it->second)`
	`1562`	`+ for (const auto &mod : it->second)`
`1527`	`1563`	`{`
`1528`	`1564`	`if (mod->isPrimaryInterface())`
`1529`	`1565`	`{`
`@@ -1536,23 +1572,23 @@ ModuleDef *ModuleManager::getPrimaryInterface(const QCString &moduleName) const`
`1536`	`1572`
`1537`	`1573`	`void ModuleManager::addListReferences()`
`1538`	`1574`	`{`
`1539`		`- for (auto &mod : p->moduleFileMap) // foreach module`
	`1575`	`+ for (const auto &mod : p->moduleFileMap) // foreach module`
`1540`	`1576`	`{`
`1541`	`1577`	`if (mod->isPrimaryInterface()) toModuleDefImpl(mod)->addListReferences();`
`1542`	`1578`	`}`
`1543`	`1579`	`}`
`1544`	`1580`
`1545`	`1581`	`void ModuleManager::addMembersToMemberGroup()`
`1546`	`1582`	`{`
`1547`		`- for (auto &mod : p->moduleFileMap) // foreach module`
	`1583`	`+ for (const auto &mod : p->moduleFileMap) // foreach module`
`1548`	`1584`	`{`
`1549`	`1585`	`if (mod->isPrimaryInterface()) toModuleDefImpl(mod)->addMembersToMemberGroup();`
`1550`	`1586`	`}`
`1551`	`1587`	`}`
`1552`	`1588`
`1553`	`1589`	`void ModuleManager::distributeMemberGroupDocumentation()`
`1554`	`1590`	`{`
`1555`		`- for (auto &mod : p->moduleFileMap) // foreach module`
	`1591`	`+ for (const auto &mod : p->moduleFileMap) // foreach module`
`1556`	`1592`	`{`
`1557`	`1593`	`if (mod->isPrimaryInterface()) toModuleDefImpl(mod)->distributeMemberGroupDocumentation();`
`1558`	`1594`	`}`
Original file line number	Diff line number	Diff line change
`@@ -56,8 +56,9 @@ struct ImportInfo`
`56`	`56`	`}`
`57`	`57`	`};`
`58`	`58`
	`59`	`+using ImportInfoList = std::vector<ImportInfo>;`
`59`	`60`	`using ModuleMap = std::unordered_map<std::string,ModuleDef *>;`
`60`		`-using ImportInfoMap = std::unordered_map<std::string,ImportInfo>;`
	`61`	`+using ImportInfoMap = std::unordered_map<std::string,ImportInfoList>;`
`61`	`62`
`62`	`63`
`63`	`64`	`class ModuleDef : public DefinitionMutable, public Definition`
Original file line number	Diff line number	Diff line change
`@@ -1352,17 +1352,20 @@ static void writeExports(const ImportInfoMap &exportMap,TextStream &t)`
`1352`	`1352`	`{`
`1353`	`1353`	`if (exportMap.empty()) return;`
`1354`	`1354`	`t << " <exports>\n";`
`1355`		`- for (auto &[moduleName,importInfo] : exportMap)`
	`1355`	`+ for (const auto &[moduleName,importInfoList] : exportMap)`
`1356`	`1356`	`{`
`1357`		`- t << " <export";`
`1358`		`- ModuleDef *mod = ModuleManager::instance().getPrimaryInterface(importInfo.importName);`
`1359`		`- if (mod && mod->isLinkableInProject())`
	`1357`	`+ for (const auto &importInfo : importInfoList)`
`1360`	`1358`	`{`
`1361`		`- t << " refid=\"" << mod->getOutputFileBase() << "\"";`
	`1359`	`+ t << " <export";`
	`1360`	`+ ModuleDef *mod = ModuleManager::instance().getPrimaryInterface(importInfo.importName);`
	`1361`	`+ if (mod && mod->isLinkableInProject())`
	`1362`	`+ {`
	`1363`	`+ t << " refid=\"" << mod->getOutputFileBase() << "\"";`
	`1364`	`+ }`
	`1365`	`+ t << ">";`
	`1366`	`+ t << importInfo.importName;`
	`1367`	`+ t << "</export>\n";`
`1362`	`1368`	`}`
`1363`		`- t << ">";`
`1364`		`- t << importInfo.importName;`
`1365`		`- t << "</export>\n";`
`1366`	`1369`	`}`
`1367`	`1370`	`t << " </exports>\n";`
`1368`	`1371`	`}`