[Sema] Don't report public imports of submodules as being unused in API

An import of a submodule implies an import of its top module, and
referenced decl will be associated with the top module. Make sure
we don't warn on public imports of a submodule being unused in API and
only report if the top module is unused.

Author: xymus

lib/Sema/TypeCheckAccess.cpp

@@ -2440,24 +2440,30 @@ void swift::diagnoseUnnecessaryPublicImports(SourceFile &SF) {
         import.accessLevel <= AccessLevel::Internal)
       continue;
 
-    AccessLevel levelUsed = SF.getMaxAccessLevelUsingImport(import.module.importedModule);
-    if (import.accessLevel > levelUsed) {
-      auto diagId = import.accessLevel == AccessLevel::Public ?
-                                                  diag::remove_public_import :
-                                                  diag::remove_package_import;
-
-      auto inFlight = ctx.Diags.diagnose(import.importLoc,
-                                         diagId,
-                                         import.module.importedModule);
-
-      if (levelUsed == AccessLevel::Package) {
-        inFlight.fixItReplace(import.accessLevelRange, "package");
-      } else if (ctx.LangOpts.hasFeature(Feature::InternalImportsByDefault)) {
-        // Let it default to internal.
-        inFlight.fixItRemove(import.accessLevelRange);
-      } else {
-        inFlight.fixItReplace(import.accessLevelRange, "internal");
-      }
+    // Ignore submodules as we associate decls with the top module.
+    // The top module will be reported if it's not used.
+    auto importedModule = import.module.importedModule;
+    if (importedModule->getTopLevelModule() != importedModule)
+      continue;
+
+    AccessLevel levelUsed = SF.getMaxAccessLevelUsingImport(importedModule);
+    if (import.accessLevel <= levelUsed)
+      continue;
+
+    auto diagId = import.accessLevel == AccessLevel::Public ?
+                                          diag::remove_public_import :
+                                          diag::remove_package_import;
+    auto inFlight = ctx.Diags.diagnose(import.importLoc,
+                                       diagId,
+                                       importedModule);
+
+    if (levelUsed == AccessLevel::Package) {
+      inFlight.fixItReplace(import.accessLevelRange, "package");
+    } else if (ctx.LangOpts.hasFeature(Feature::InternalImportsByDefault)) {
+      // Let it default to internal.
+      inFlight.fixItRemove(import.accessLevelRange);
+    } else {
+      inFlight.fixItReplace(import.accessLevelRange, "internal");
     }
   }
 }

test/Sema/access-level-import-inconsistent-same-file.swift

@@ -91,7 +91,6 @@ public func dummyAPI(t: Lib1.Type1) {}
 //--- Client_Clang.swift
 
 public import ClangLib.Sub1 // expected-note {{imported 'public' here}}
-// expected-warning @-1 {{public import of 'Sub1' was not used in public declarations or inlinable code}}
 private import ClangLib.Sub1 // expected-warning {{module 'Sub1' is imported as 'public' from the same file; this 'private' access level will be ignored}}
 internal import ClangLib.Sub2
 

test/Sema/superfluously-public-imports.swift

@@ -24,6 +24,8 @@
 /// Check diagnostics.
 // RUN: %target-swift-frontend -typecheck %t/Client.swift -I %t \
 // RUN:   -package-name pkg -Rmodule-api-import -swift-version 6 -verify
+// RUN: %target-swift-frontend -typecheck %t/ClientOfClangModules.swift -I %t \
+// RUN:   -package-name pkg -Rmodule-api-import -swift-version 6 -verify
 // RUN: %target-swift-frontend -typecheck %t/Client_Swift5.swift -I %t \
 // RUN:   -swift-version 5 -verify
 
@@ -211,3 +213,63 @@ func implicitlyInternalFunc(a: NotAnAPIType = notAnAPIFunc()) {}
 
 // For package decls we only remark on types used in signatures, not for inlinable code.
 package func packageFunc(a: PackageType = packageFunc()) {} // expected-remark {{struct 'PackageType' is imported via 'ImportUsedInPackage'}}
+
+/// Tests for imports of clang modules.
+//--- module.modulemap
+module ClangSimpleUnused {
+    header "ClangSimpleUnused.h"
+}
+module ClangSimple {
+    header "ClangSimple.h"
+}
+
+module ClangSubmodule {
+    header "ClangSubmodule.h"
+
+    module ClangSubmoduleSubmodule {
+      header "ClangSubmoduleSubmodule.h"
+    }
+}
+
+module ClangSubmoduleUnused {
+    header "ClangSubmoduleUnused.h"
+
+    module ClangSubmoduleUnsuedSubmodule {
+      header "ClangSubmoduleUnusedSubmodule.h"
+    }
+}
+
+module ClangTopModule {
+  header "ClangTopModule.h"
+  module ClangTopModuleSubmodule {
+    header "ClangTopModuleSubmodule.h"
+  }
+}
+
+//--- ClangSimpleUnused.h
+//--- ClangSimple.h
+struct ClangSimpleType {};
+
+//--- ClangSubmodule.h
+//--- ClangSubmoduleSubmodule.h
+struct ClangSubmoduleSubmoduleType {};
+
+//--- ClangSubmoduleUnused.h
+//--- ClangSubmoduleUnusedSubmodule.h
+
+//--- ClangTopModule.h
+struct ClangTopModuleType {};
+//--- ClangTopModuleSubmodule.h
+
+//--- ClientOfClangModules.swift
+public import ClangSimple
+public import ClangSimpleUnused // expected-warning {{public import of 'ClangSimpleUnused' was not used in public declarations or inlinable code}}
+public import ClangSubmodule.ClangSubmoduleSubmodule
+public import ClangSubmoduleUnused.ClangSubmoduleUnsuedSubmodule // expected-warning {{public import of 'ClangSubmoduleUnused' was not used in public declarations or inlinable code}}
+
+// Only the top-level module is used, but we can't detect whether the submodule was used or not.
+public import ClangTopModule.ClangTopModuleSubmodule
+
+public func clangUser(a: ClangSimpleType) {} // expected-remark {{struct 'ClangSimpleType' is imported via 'ClangSimple'}}
+public func clangUser(a: ClangSubmoduleSubmoduleType) {} // expected-remark {{struct 'ClangSubmoduleSubmoduleType' is imported via 'ClangSubmodule'}}
+public func clangUser(a: ClangTopModuleType) {} // expected-remark {{struct 'ClangTopModuleType' is imported via 'ClangTopModule'}}