SwiftExtract: configurable importable modules + generic-type initializer extraction

Two opt-in, language-neutral knobs on `SwiftExtractConfiguration` (both default to
the prior behavior, so the Java path is unchanged):

- `availableImportModules: Set<String>` — module names treated as importable when
  resolving `#if canImport(<module>)`. The analyzer wraps its build configuration
  in an `ImportOverlayBuildConfiguration` so declarations guarded behind
  `#if canImport(MyModule)` are extracted (e.g. another language code generator
  may declare its runtime module importable here, even when the static build
  config doesn't otherwise know about it).

- `extractsGenericTypeInitializers: Bool` — extract initializers of generic
  nominal types even when not specialized. swift-java skips these by default (an
  open generic isn't directly constructible); other language code generators
  that specialize generics in a post-analysis pass need the base type's
  initializers available to clone onto the specialization.

Author: ktoso

Sources/SwiftExtract/SwiftAnalysisVisitor.swift

@@ -338,7 +338,9 @@ final class SwiftAnalysisVisitor {
       return
     }
 
-    if typeContext.swiftNominal.isGeneric && !typeContext.isSpecialization {
+    if typeContext.swiftNominal.isGeneric && !typeContext.isSpecialization
+      && !config.extractsGenericTypeInitializers
+    {
       log.debug("Skip Importing generic type initializer \(node.kind) '\(node.qualifiedNameForDebug)'")
       return
     }

Sources/SwiftExtract/SwiftAnalyzer.swift

@@ -91,15 +91,27 @@ public final class SwiftAnalyzer {
       do {
         let data = try Data(contentsOf: URL(fileURLWithPath: staticBuildConfigPath))
         let decoder = JSONDecoder()
-        self.buildConfig = try decoder.decode(StaticBuildConfiguration.self, from: data)
+        let staticConfig = try decoder.decode(StaticBuildConfiguration.self, from: data)
+        self.buildConfig = SwiftAnalyzer.overlayingAvailableModules(staticConfig, config.availableImportModules)
         self.log.info("Using custom static build configuration from: \(staticBuildConfigPath)")
       } catch {
         fatalError("Failed to load static build configuration from '\(staticBuildConfigPath)': \(error)")
       }
     } else {
-      self.buildConfig = .swiftExtractDefault
+      self.buildConfig = SwiftAnalyzer.overlayingAvailableModules(.swiftExtractDefault, config.availableImportModules)
     }
   }
+
+  /// Overlay the configured extra importable modules onto a base build config
+  /// (returns the base unchanged when none are configured).
+  private static func overlayingAvailableModules<Base: BuildConfiguration>(
+    _ base: Base,
+    _ availableImportModules: Set<String>
+  ) -> any BuildConfiguration {
+    availableImportModules.isEmpty
+      ? base
+      : ImportOverlayBuildConfiguration(base: base, availableImportModules: availableImportModules)
+  }
 }
 
 // ===== --------------------------------------------------------------------------------------------------------------

Sources/SwiftExtract/SwiftExtractConfiguration.swift

@@ -67,13 +67,32 @@ public protocol SwiftExtractConfiguration {
   /// Verbosity for the analyzer's logger; `nil` falls back to `.info`.
   var swiftExtractLogLevel: Logger.Level? { get }
 
+  /// Whether to extract initializers of *generic* nominal types even when they
+  /// are not (yet) specialized. swift-java skips these by default (an open
+  /// generic isn't directly constructible); other language code generators that
+  /// specialize generics in a post-analysis pass set this `true` so the base
+  /// type's initializers are available to clone onto the specialization.
+  /// Default: false.
+  var extractsGenericTypeInitializers: Bool { get }
+
+  /// Module names that should be treated as importable when resolving
+  /// `#if canImport(<module>)` conditions, in addition to whatever the build
+  /// configuration already knows. Lets a target opt-in to extracting code
+  /// guarded behind `#if canImport(MyModule)` (e.g. another language code
+  /// generator can declare its runtime module importable here). Default: empty.
+  var availableImportModules: Set<String> { get }
+
   /// Whether the given module name has stub declarations configured.
   func hasImportedModuleStub(moduleOfNominal moduleName: String) -> Bool
 }
 
 extension SwiftExtractConfiguration {
   public var extractsOperators: Bool { false }
 
+  public var extractsGenericTypeInitializers: Bool { false }
+
+  public var availableImportModules: Set<String> { [] }
+
   public func hasImportedModuleStub(moduleOfNominal moduleName: String) -> Bool {
     importedModuleStubs?.keys.contains(moduleName) ?? false
   }
@@ -91,6 +110,7 @@ public struct DefaultSwiftExtractConfiguration: SwiftExtractConfiguration {
   public var swiftExtractAccessLevel: AccessLevelMode
   public var swiftExtractLogLevel: Logger.Level?
   public var extractsOperators: Bool
+  public var availableImportModules: Set<String>
 
   public init(
     swiftModule: String? = nil,
@@ -100,7 +120,8 @@ public struct DefaultSwiftExtractConfiguration: SwiftExtractConfiguration {
     staticBuildConfigurationFile: String? = nil,
     swiftFilterInclude: [String]? = nil,
     swiftFilterExclude: [String]? = nil,
-    importedModuleStubs: [String: [String]]? = nil
+    importedModuleStubs: [String: [String]]? = nil,
+    availableImportModules: Set<String> = []
   ) {
     self.swiftModule = swiftModule
     self.swiftExtractAccessLevel = accessLevel
@@ -110,5 +131,6 @@ public struct DefaultSwiftExtractConfiguration: SwiftExtractConfiguration {
     self.swiftFilterInclude = swiftFilterInclude
     self.swiftFilterExclude = swiftFilterExclude
     self.importedModuleStubs = importedModuleStubs
+    self.availableImportModules = availableImportModules
   }
 }

Sources/SwiftExtract/SwiftExtractDefaultBuildConfiguration.swift

@@ -101,3 +101,41 @@ extension BuildConfiguration where Self == SwiftExtractDefaultBuildConfiguration
     .shared
   }
 }
+
+/// Wraps any `BuildConfiguration` and additionally reports a configured set of
+/// module names as importable. Used so a target can extract declarations guarded
+/// behind `#if canImport(<module>)` for modules the static build configuration
+/// does not otherwise know about (e.g. another language code generator can
+/// declare its own runtime module importable for extraction).
+package struct ImportOverlayBuildConfiguration<Base: BuildConfiguration>: BuildConfiguration {
+  package var base: Base
+  package var availableImportModules: Set<String>
+
+  package init(base: Base, availableImportModules: Set<String>) {
+    self.base = base
+    self.availableImportModules = availableImportModules
+  }
+
+  package func canImport(importPath: [(TokenSyntax, String)], version: CanImportVersion) throws -> Bool {
+    // `importPath` is the dotted module path; the leading component is the module.
+    if let moduleName = importPath.first?.1, availableImportModules.contains(moduleName) {
+      return true
+    }
+    return try base.canImport(importPath: importPath, version: version)
+  }
+
+  package func isCustomConditionSet(name: String) throws -> Bool { try base.isCustomConditionSet(name: name) }
+  package func hasFeature(name: String) throws -> Bool { try base.hasFeature(name: name) }
+  package func hasAttribute(name: String) throws -> Bool { try base.hasAttribute(name: name) }
+  package func isActiveTargetOS(name: String) throws -> Bool { try base.isActiveTargetOS(name: name) }
+  package func isActiveTargetArchitecture(name: String) throws -> Bool { try base.isActiveTargetArchitecture(name: name) }
+  package func isActiveTargetEnvironment(name: String) throws -> Bool { try base.isActiveTargetEnvironment(name: name) }
+  package func isActiveTargetRuntime(name: String) throws -> Bool { try base.isActiveTargetRuntime(name: name) }
+  package func isActiveTargetPointerAuthentication(name: String) throws -> Bool { try base.isActiveTargetPointerAuthentication(name: name) }
+  package func isActiveTargetObjectFormat(name: String) throws -> Bool { try base.isActiveTargetObjectFormat(name: name) }
+  package var targetPointerBitWidth: Int { base.targetPointerBitWidth }
+  package var targetAtomicBitWidths: [Int] { base.targetAtomicBitWidths }
+  package var endianness: Endianness { base.endianness }
+  package var languageVersion: VersionTuple { base.languageVersion }
+  package var compilerVersion: VersionTuple { base.compilerVersion }
+}