Diagnose invalid module alias (#6841)

Declaring a module alias for a target that isn't a recursive dependency of the product the alias is being defined for doesn't actually work, instead it gets silently skipped. This adds a diagnostic for this case.

I don't know if this scenario should work, but it doesn't in practice, so even if it is supposed to, a diagnostic seems better than nothing.

Separately, it seems problematic that the duplicateModule diagnostic contains a completely context-free suggestion to use module aliases. This leads to the very confusing outcome that it is being suggested in this particular case which cannot be resolved using a module alias.

rdar://114200576

Sources/PackageGraph/ModuleAliasTracker.swift

@@ -24,6 +24,7 @@ class ModuleAliasTracker {
     var parentToChildProducts = [String: [String]]()
     var parentToChildIDs = [PackageIdentity: [PackageIdentity]]()
     var childToParentID = [PackageIdentity: PackageIdentity]()
+    var appliedAliases = Set<String>()
 
     init() {}
     func addTargetAliases(targets: [Target], package: PackageIdentity) throws {
@@ -63,7 +64,7 @@ class ModuleAliasTracker {
         }
 
         for (originalName, newName) in aliases {
-            let model = ModuleAliasModel(name: originalName, alias: newName, originPackage: originPackage, consumingPackage: consumingPackage)
+            let model = ModuleAliasModel(name: originalName, alias: newName, originPackage: originPackage, consumingPackage: consumingPackage, productName: productName)
             idToAliasMap[originPackage, default: [:]][productID, default: []].append(model)
             aliasMap[productID, default: []].append(model)
         }
@@ -163,13 +164,22 @@ class ModuleAliasTracker {
 
             for relTarget in relevantTargets {
                 if let val = lookupAlias(key: relTarget.name, in: aliasBuffer) {
+                    appliedAliases.insert(relTarget.name)
                     relTarget.addModuleAlias(for: relTarget.name, as: val)
                     if let prechainVal = aliasBuffer[relTarget.name],
                        prechainVal.alias != val {
                         relTarget.addPrechainModuleAlias(for: relTarget.name, as: prechainVal.alias)
+                        appliedAliases.insert(prechainVal.alias)
                         relTarget.addPrechainModuleAlias(for: prechainVal.alias, as: val)
                         observabilityScope.emit(info: "Module alias '\(prechainVal.alias)' defined in package '\(prechainVal.consumingPackage)' for target '\(relTarget.name)' in package/product '\(productID)' is overridden by alias '\(val)'; if this override is not intended, remove '\(val)' from 'moduleAliases' in its manifest")
                         aliasBuffer.removeValue(forKey: prechainVal.alias)
+
+                        // Since we're overriding an alias here, we have to pretend it was applied to avoid follow-on warnings.
+                        var currentAlias: String? = val
+                        while let _currentAlias = currentAlias, !appliedAliases.contains(_currentAlias) {
+                            appliedAliases.insert(_currentAlias)
+                            currentAlias = aliasBuffer.values.first { $0.alias == _currentAlias }?.name
+                        }
                     }
                     aliasBuffer.removeValue(forKey: relTarget.name)
                 }
@@ -257,6 +267,7 @@ class ModuleAliasTracker {
                     for target in productTargets {
                         let depAliases = target.recursiveDependentTargets.compactMap{$0.moduleAliases}.flatMap{$0}
                         for (key, alias) in depAliases {
+                            appliedAliases.insert(key)
                             target.addModuleAlias(for: key, as: alias)
                         }
                     }
@@ -269,6 +280,16 @@ class ModuleAliasTracker {
         }
     }
 
+    func diagnoseUnappliedAliases(observabilityScope: ObservabilityScope) {
+        for aliasList in aliasMap.values {
+            for productAlias in aliasList {
+                if !appliedAliases.contains(productAlias.name) {
+                    observabilityScope.emit(warning: "module alias for target '\(productAlias.name)', declared in package '\(productAlias.consumingPackage)', does not match any recursive target dependency of product '\(productAlias.productName)' from package '\(productAlias.originPackage)'")
+                }
+            }
+        }
+    }
+
     private func chainModuleAliases(targets: [Target],
                                     checkedTargets: [Target],
                                     targetAliases: [String: [String]],
@@ -336,11 +357,13 @@ class ModuleAliasTracker {
 
         for target in targets {
             for (key, val) in aliasDict {
+                appliedAliases.insert(key)
                 target.addModuleAlias(for: key, as: val)
             }
             for (key, valList) in prechainAliasDict {
                 if let val = valList.first,
                     valList.count <= 1 {
+                    appliedAliases.insert(key)
                     target.addModuleAlias(for: key, as: val)
                     target.addPrechainModuleAlias(for: key, as: val)
                 }
@@ -401,12 +424,14 @@ class ModuleAliasModel {
     var alias: String
     let originPackage: PackageIdentity
     let consumingPackage: PackageIdentity
+    let productName: String
 
-    init(name: String, alias: String, originPackage: PackageIdentity, consumingPackage: PackageIdentity) {
+    init(name: String, alias: String, originPackage: PackageIdentity, consumingPackage: PackageIdentity, productName: String) {
         self.name = name
         self.alias = alias
         self.originPackage = originPackage
         self.consumingPackage = consumingPackage
+        self.productName = productName
     }
 }
 

Sources/PackageGraph/PackageGraph+Loading.swift

@@ -799,6 +799,10 @@ private func resolveModuleAliases(packageBuilders: [ResolvedPackageBuilder],
                                                      observabilityScope: observabilityScope)
         }
     }
+
+    // Emit diagnostics for any module aliases that did not end up being applied.
+    aliasTracker.diagnoseUnappliedAliases(observabilityScope: observabilityScope)
+
     return true
 }