Sema: track use of public imports by more extensions

Consider extensions to imported types as users of a public import. This
silences false reports of unused public imports in the case of an empty
extension satisfying generic requirements via retroactive conformances.
It also silences real reports of superfluously public imports used in
internal extension, but this isn't very harmful at this time.

We should revisit this later and tighten the check, we should refactor
the logic use to determine what makes an extension public.

rdar://120391841

Author: xymus

lib/Sema/TypeCheckAccess.cpp

@@ -2360,6 +2360,32 @@ class DeclAvailabilityChecker : public DeclVisitor<DeclAvailabilityChecker> {
     Where = wasWhere.withExported(hasExportedMembers ||
                                   !ED->getInherited().empty());
     checkConstrainedExtensionRequirements(ED, hasExportedMembers);
+
+    if (!hasExportedMembers &&
+        !ED->getInherited().empty()) {
+      // If we haven't already visited the extended nominal visit it here.
+      // This logic is too wide but prevents false reports of an unused public
+      // import. We should instead check for public generic requirements
+      // similarly to ShouldPrintForModuleInterface::shouldPrint.
+      auto DC = Where.getDeclContext();
+      ImportAccessLevel import = extendedType->getImportAccessFrom(DC);
+      if (import.has_value()) {
+        auto SF = DC->getParentSourceFile();
+        if (SF)
+          SF->registerAccessLevelUsingImport(import.value(),
+                                             AccessLevel::Public);
+
+        auto &ctx = DC->getASTContext();
+        if (ctx.LangOpts.EnableModuleApiImportRemarks) {
+          ModuleDecl *importedVia = import->module.importedModule,
+                     *sourceModule = ED->getModuleContext();
+          ED->diagnose(diag::module_api_import,
+                       ED, importedVia, sourceModule,
+                       importedVia == sourceModule,
+                       /*isImplicit*/false);
+        }
+      }
+    }
   }
 
   void checkPrecedenceGroup(const PrecedenceGroupDecl *PGD,

test/Sema/superfluously-public-imports.swift

@@ -22,6 +22,7 @@
 // RUN: %target-swift-frontend -emit-module %t/ImportUsedInPackage.swift -o %t -I %t
 // RUN: %target-swift-frontend -emit-module %t/ExportedUnused.swift -o %t -I %t
 // RUN: %target-swift-frontend -emit-module %t/SPIOnlyUsedInSPI.swift -o %t -I %t
+// RUN: %target-swift-frontend -emit-module %t/RetroactiveConformance.swift -o %t -I %t
 
 /// Check diagnostics.
 // RUN: %target-swift-frontend -typecheck %t/Client.swift -I %t \
@@ -110,6 +111,11 @@ public func packageFunc() -> PackageType { return PackageType() }
 //--- SPIOnlyUsedInSPI.swift
 public struct ToUseFromSPI {}
 
+//--- RetroactiveConformance.swift
+public struct Extended {
+  public var count: Int { 42 }
+}
+
 //--- Client_Swift5.swift
 /// No diagnostics should be raised on the implicit access level.
 import UnusedImport // expected-error {{ambiguous implicit access level for import of 'UnusedImport'; it is imported as 'public' elsewhere}}
@@ -143,6 +149,7 @@ public import ImportUsedInPackage // expected-warning {{public import of 'Import
 
 @_exported public import ExportedUnused
 @_spiOnly public import SPIOnlyUsedInSPI
+public import RetroactiveConformance
 
 public func useInSignature(_ a: TypeUsedInSignature) {} // expected-remark {{struct 'TypeUsedInSignature' is imported via 'DepUsedInSignature'}}
 public func exportedTypeUseInSignature(_ a: ExportedType) {} // expected-remark {{struct 'ExportedType' is imported via 'Exporter', which reexports definition from 'Exportee'}}
@@ -228,6 +235,13 @@ package func packageFunc(a: PackageType = packageFunc()) {} // expected-remark {
 @_spi(X)
 public func spiFunc(a: ToUseFromSPI) {} // expected-remark {{struct 'ToUseFromSPI' is imported via 'SPIOnlyUsedInSPI'}}
 
+public protocol Countable {
+  var count: Int { get } // expected-remark {{struct 'Int' is imported via 'Swift'}}
+}
+
+extension Extended: Countable { // expected-remark {{struct 'Extended' is imported via 'RetroactiveConformance'}}
+}
+
 /// Tests for imports of clang modules.
 //--- module.modulemap
 module ClangSimpleUnused {