Small rework of analyzing imported modules and printing import statements to output swift file.

Author: pelekon

Sources/JExtractSwiftLib/FFM/FFMSwift2JavaGenerator+SwiftThunkPrinting.swift

@@ -125,11 +125,51 @@ extension FFMSwift2JavaGenerator {
   }
 
   func printSwiftThunkImports(_ printer: inout CodePrinter) {
+    let mainSymbolSourceModules = Set(
+      self.lookupContext.symbolTable.importedModules.values.filter { $0.alternativeModules?.isMainSourceOfSymbols ?? false }.map(\.moduleName)
+    )
+
     for module in self.lookupContext.symbolTable.importedModules.keys.sorted() {
       guard module != "Swift" else {
         continue
       }
+
+      guard let alternativeModules = self.lookupContext.symbolTable.importedModules[module]?.alternativeModules else {
+        printer.print("import \(module)")
+        continue
+      }
+
+      // Try to print only on main module from relation chain as it has every other module.
+      guard !mainSymbolSourceModules.isDisjoint(with: alternativeModules.moduleNames) || alternativeModules.isMainSourceOfSymbols else {
+        if !alternativeModules.isMainSourceOfSymbols {
+          printer.print("import \(module)")
+        }
+        continue
+      }
+      
+      var importGroups: [String: [String]] = [:]
+      for name in alternativeModules.moduleNames {
+        guard let otherModule = self.lookupContext.symbolTable.importedModules[name] else { continue }
+
+        let groupKey = otherModule.requiredAvailablityOfModuleWithName ?? otherModule.moduleName
+        importGroups[groupKey, default: []].append(otherModule.moduleName)
+      }
+
+      for (index, group) in importGroups.keys.sorted().enumerated() {
+        if index > 0  && importGroups.keys.count > 1 {
+          printer.print("#elseif canImport(\(group))")
+        } else {
+          printer.print("#if canImport(\(group))")
+        }
+        
+        for groupModule in importGroups[group] ?? [] {
+          printer.print("import \(groupModule)")
+        }
+      }
+
+      printer.print("#else")
       printer.print("import \(module)")
+      printer.print("#endif")
     }
     printer.println()
   }

Sources/JExtractSwiftLib/SwiftTypes/DependencyScanner.swift

@@ -15,15 +15,74 @@
 import SwiftSyntax
 
 /// Scan importing modules.
-func importingModuleNames(sourceFile: SourceFileSyntax) -> [String] {
-  var importingModuleNames: [String] = []
+func importingModules(sourceFile: SourceFileSyntax) -> [ImportedSwiftModule] {
+  var importingModuleNames: [ImportedSwiftModule] = []
   for item in sourceFile.statements {
     if let importDecl = item.item.as(ImportDeclSyntax.self) {
       guard let moduleName = importDecl.path.first?.name.text else {
         continue
       }
-      importingModuleNames.append(moduleName)
+      importingModuleNames.append(ImportedSwiftModule(name: moduleName, availableWithModuleName: nil, alternativeModuleNames: []))
+    } else if let ifConfigDecl = item.item.as(IfConfigDeclSyntax.self) {
+      importingModuleNames.append(contentsOf: modules(from: ifConfigDecl))
     }
   }
   return importingModuleNames
 }
+
+private func modules(from ifConfigDecl: IfConfigDeclSyntax) -> [ImportedSwiftModule] {
+  guard 
+    let firstClause = ifConfigDecl.clauses.first,
+    let calledExpression = firstClause.condition?.as(FunctionCallExprSyntax.self)?.calledExpression.as(DeclReferenceExprSyntax.self),
+    calledExpression.baseName.text == "canImport" else {
+      return []
+    }
+
+    var modules: [ImportedSwiftModule] = []
+    modules.reserveCapacity(ifConfigDecl.clauses.count)
+
+    for (index, clause) in ifConfigDecl.clauses.enumerated() {
+      let importedModuleNames = clause.elements?.as(CodeBlockItemListSyntax.self)?
+        .compactMap { CodeBlockItemSyntax($0) }
+        .compactMap { $0.item.as(ImportDeclSyntax.self) }
+        .compactMap { $0.path.first?.name.text } ?? []
+
+        let importModuleName: String? = if 
+          let funcCallExpr = clause.condition?.as(FunctionCallExprSyntax.self),
+          let calledDeclReference = funcCallExpr.calledExpression.as(DeclReferenceExprSyntax.self),
+          calledDeclReference.baseName.text == "canImport",
+          let moduleNameSyntax = funcCallExpr.arguments.first?.expression.as(DeclReferenceExprSyntax.self) {
+            moduleNameSyntax.baseName.text
+          } else {
+            nil
+          }
+
+        let clauseModules = importedModuleNames.map { 
+          ImportedSwiftModule(name: $0, 
+          availableWithModuleName: importModuleName, 
+          alternativeModuleNames: [])
+        }
+        
+        // Assume single import from #else statement is fallback and use it as main source of symbols
+        if 
+          clauseModules.count == 1 && 
+          index == (ifConfigDecl.clauses.count - 1) && 
+          clause.poundKeyword.tokenKind == .poundElse {
+            var fallbackModule: ImportedSwiftModule = clauseModules[0]
+            var moduleNames: [String] = []
+            moduleNames.reserveCapacity(modules.count)
+
+            for i in 0..<modules.count {
+              modules[i].alternativeModuleNames.insert(fallbackModule.name)
+              moduleNames.append(modules[i].name)
+            }
+
+          fallbackModule.alternativeModuleNames = Set(modules.map(\.name))
+          fallbackModule.isMainSourceOfSymbols = true
+        }
+
+        modules.append(contentsOf: clauseModules)
+    }
+
+    return modules
+}

Sources/JExtractSwiftLib/SwiftTypes/ImportedSwiftModule.swift

@@ -0,0 +1,32 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2025 Apple Inc. and the Swift.org project authors
+// Licensed under Apache License v2.0
+//
+// See LICENSE.txt for license information
+// See CONTRIBUTORS.txt for the list of Swift.org project authors
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+//===----------------------------------------------------------------------===//
+
+
+struct ImportedSwiftModule: Hashable {
+  let name: String
+  let availableWithModuleName: String?
+  var alternativeModuleNames: Set<String>
+  var isMainSourceOfSymbols: Bool
+
+  init(name: String, availableWithModuleName: String? = nil, alternativeModuleNames: Set<String> = [], isMainSourceOfSymbols: Bool = false) {
+    self.name = name
+    self.availableWithModuleName = availableWithModuleName
+    self.alternativeModuleNames = alternativeModuleNames
+    self.isMainSourceOfSymbols = isMainSourceOfSymbols
+  }
+
+  func hash(into hasher: inout Hasher) {
+    hasher.combine(name)
+  }
+}

Sources/JExtractSwiftLib/SwiftTypes/SwiftKnownModules.swift

@@ -48,13 +48,20 @@ private var swiftSymbolTable: SwiftModuleSymbolTable {
 }
 
 private var foundationEssentialsSymbolTable: SwiftModuleSymbolTable {
-  var builder = SwiftParsedModuleSymbolTableBuilder(moduleName: "FoundationEssentials", importedModules: ["Swift": swiftSymbolTable])
+  var builder = SwiftParsedModuleSymbolTableBuilder(
+    moduleName: "FoundationEssentials", 
+    requiredAvailablityOfModuleWithName: "FoundationEssentials",
+    alternativeModules: .init(isMainSourceOfSymbols: false, moduleNames: ["Foundation"]),
+    importedModules: ["Swift": swiftSymbolTable])
   builder.handle(sourceFile: foundationEssentialsSourceFile)
   return builder.finalize()
 }
 
 private var foundationSymbolTable: SwiftModuleSymbolTable {
-  var builder = SwiftParsedModuleSymbolTableBuilder(moduleName: "Foundation", importedModules: ["Swift": swiftSymbolTable])
+  var builder = SwiftParsedModuleSymbolTableBuilder(
+    moduleName: "Foundation", 
+    alternativeModules: .init(isMainSourceOfSymbols: true, moduleNames: ["FoundationEssentials"]),
+    importedModules: ["Swift": swiftSymbolTable])
   builder.handle(sourceFile: foundationSourceFile)
   return builder.finalize()
 }

Sources/JExtractSwiftLib/SwiftTypes/SwiftModuleSymbolTable.swift

@@ -19,6 +19,12 @@ struct SwiftModuleSymbolTable: SwiftSymbolTableProtocol {
   /// The name of this module.
   let moduleName: String
 
+  /// The name of module required to be imported and checked via canImport statement.
+  let requiredAvailablityOfModuleWithName: String?
+
+  /// Data about alternative modules which provides desired symbos e.g. FoundationEssentials is non-Darwin platform alternative for Foundation
+  let alternativeModules: AlternativeModuleNamesData?
+
   /// The top-level nominal types, found by name.
   var topLevelTypes: [String: SwiftNominalTypeDeclaration] = [:]
 
@@ -36,4 +42,18 @@ struct SwiftModuleSymbolTable: SwiftSymbolTableProtocol {
   func lookupNestedType(_ name: String, parent: SwiftNominalTypeDeclaration) -> SwiftNominalTypeDeclaration? {
     nestedTypes[parent]?[name]
   }
+
+  func isAlternative(for moduleName: String) -> Bool {
+    alternativeModules.flatMap { $0.moduleNames.contains(moduleName) } ?? false
+  }
 }
+
+extension SwiftModuleSymbolTable {
+  struct AlternativeModuleNamesData {
+    /// Flag indicating module should be used as source of symbols to avoid duplication of symbols.
+    let isMainSourceOfSymbols: Bool
+
+    /// Names of modules which are alternative for currently checked module.
+    let moduleNames: Set<String>
+  }
+}

Sources/JExtractSwiftLib/SwiftTypes/SwiftParsedModuleSymbolTableBuilder.swift

@@ -26,9 +26,18 @@ struct SwiftParsedModuleSymbolTableBuilder {
   /// Extension decls their extended type hasn't been resolved.
   var unresolvedExtensions: [ExtensionDeclSyntax]
 
-  init(moduleName: String, importedModules: [String: SwiftModuleSymbolTable], log: Logger? = nil) {
+  init(
+    moduleName: String, 
+    requiredAvailablityOfModuleWithName: String? = nil, 
+    alternativeModules: SwiftModuleSymbolTable.AlternativeModuleNamesData? = nil, 
+    importedModules: [String: SwiftModuleSymbolTable], 
+    log: Logger? = nil
+  ) {
     self.log = log
-    self.symbolTable = .init(moduleName: moduleName)
+    self.symbolTable = .init(
+      moduleName: moduleName, 
+      requiredAvailablityOfModuleWithName: requiredAvailablityOfModuleWithName, 
+      alternativeModules: alternativeModules)
     self.importedModules = importedModules
     self.unresolvedExtensions = []
   }

Sources/JExtractSwiftLib/SwiftTypes/SwiftSymbolTable.swift

@@ -42,6 +42,9 @@ package class SwiftSymbolTable {
   let parsedModule:SwiftModuleSymbolTable
 
   private var knownTypeToNominal: [SwiftKnownTypeDeclKind: SwiftNominalTypeDeclaration] = [:]
+  private var prioritySortedImportedModules: [SwiftModuleSymbolTable] {
+    importedModules.values.sorted(by: { ($0.alternativeModules?.isMainSourceOfSymbols ?? false) && $0.moduleName < $1.moduleName })
+  }
 
   init(parsedModule: SwiftModuleSymbolTable, importedModules: [String: SwiftModuleSymbolTable]) {
     self.parsedModule = parsedModule
@@ -58,18 +61,22 @@ extension SwiftSymbolTable {
 
     // Prepare imported modules.
     // FIXME: Support arbitrary dependencies.
-    var moduleNames: Set<String> = []
+    var modules: Set<ImportedSwiftModule> = []
     for sourceFile in sourceFiles {
-      moduleNames.formUnion(importingModuleNames(sourceFile: sourceFile))
+      modules.formUnion(importingModules(sourceFile: sourceFile))
     }
     var importedModules: [String: SwiftModuleSymbolTable] = [:]
     importedModules[SwiftKnownModule.swift.name] = SwiftKnownModule.swift.symbolTable
-    for moduleName in moduleNames.sorted() {
+    for module in modules {
+      // We don't need duplicates of symbols, first known definition is enough to parse module
+      // e.g Data from FoundationEssentials and Foundation collide and lead to different results due to random order of keys in Swift's Dictionary
+      // guard module.isMainSourceOfSymbols || !importedModules.contains(where: { $0.value.isAlternative(for: String)}) else { continue }
+
       if
-        importedModules[moduleName] == nil,
-        let knownModule = SwiftKnownModule(rawValue: moduleName)
+        importedModules[module.name] == nil,
+        let knownModule = SwiftKnownModule(rawValue: module.name)
       {
-        importedModules[moduleName] = knownModule.symbolTable
+        importedModules[module.name] = knownModule.symbolTable
       }
     }
 
@@ -95,7 +102,7 @@ extension SwiftSymbolTable: SwiftSymbolTableProtocol {
       return parsedResult
     }
 
-    for importedModule in importedModules.values {
+    for importedModule in prioritySortedImportedModules {
       if let result = importedModule.lookupTopLevelNominalType(name) {
         return result
       }