[Sema] Extend TypeAccessScopeChecker to return any limiting import

Using an access-level on imports limit how imported types can be used in
API. This change extends TypeAccessScopeChecker to return both the
access scope of the target type and any import that limits where it can
be used. Diagnostics should use this information to raise errors and
point to related imports.

Author: xymus

Diff for: include/swift/AST/SourceFile.h

@@ -45,6 +45,9 @@ enum class RestrictedImportKind {
   None // No restriction, i.e. the module is imported publicly.
 };
 
+/// Import that limits the access level of imported entities.
+using ImportAccessLevel = Optional<AttributedImport<ImportedModule>>;
+
 /// A file containing Swift source code.
 ///
 /// This is a .swift or .sil file (or a virtual file, such as the contents of
@@ -382,6 +385,10 @@ class SourceFile final : public FileUnit {
   /// Get the most permissive restriction applied to the imports of \p module.
   RestrictedImportKind getRestrictedImportKind(const ModuleDecl *module) const;
 
+  /// Return the import of \p targetModule from this file with the most
+  /// permissive access level.
+  ImportAccessLevel getImportAccessLevel(const ModuleDecl *targetModule) const;
+
   /// Find all SPI names imported from \p importedModule by this file,
   /// collecting the identifiers in \p spiGroups.
   virtual void

Diff for: lib/AST/Module.cpp

@@ -2944,6 +2944,29 @@ RestrictedImportKind SourceFile::getRestrictedImportKind(const ModuleDecl *modul
   return importKind;
 }
 
+ImportAccessLevel
+SourceFile::getImportAccessLevel(const ModuleDecl *targetModule) const {
+  assert(Imports.hasValue());
+
+  // Leave it to the caller to avoid calling this service for a self import.
+  // We want to return AccessLevel::Public, but there's no import site to return.
+  assert(targetModule != getParentModule() &&
+         "getImportAccessLevel doesn't support checking for a self-import");
+
+  auto &imports = getASTContext().getImportCache();
+  ImportAccessLevel restrictiveImport = None;
+
+  for (auto &import : *Imports) {
+    if ((!restrictiveImport.has_value() ||
+         import.accessLevel > restrictiveImport->accessLevel) &&
+        imports.isImportedBy(targetModule, import.module.importedModule)) {
+      restrictiveImport = import;
+    }
+  }
+
+  return restrictiveImport;
+}
+
 bool ModuleDecl::isImportedImplementationOnly(const ModuleDecl *module) const {
   if (module == this) return false;
 

Diff for: lib/Sema/TypeAccessScopeChecker.h

@@ -31,6 +31,7 @@ class TypeAccessScopeChecker {
   bool TreatUsableFromInlineAsPublic;
 
   Optional<AccessScope> Scope = AccessScope::getPublic();
+  ImportAccessLevel ImportRestriction = None;
 
   TypeAccessScopeChecker(const DeclContext *useDC,
                          bool treatUsableFromInlineAsPublic)
@@ -43,21 +44,41 @@ class TypeAccessScopeChecker {
 
     auto AS = VD->getFormalAccessScope(File, TreatUsableFromInlineAsPublic);
     Scope = Scope->intersectWith(AS);
+
+    auto targetModule = VD->getDeclContext()->getParentModule();
+    if (targetModule != File->getParentModule()) {
+      auto localImportRestriction = File->getImportAccessLevel(targetModule);
+
+      if (localImportRestriction.has_value() &&
+          (!ImportRestriction.has_value() ||
+           localImportRestriction.value().accessLevel <
+             ImportRestriction.value().accessLevel)) {
+        ImportRestriction = localImportRestriction;
+      }
+    }
+
     return Scope.has_value();
   }
 
 public:
-  static Optional<AccessScope>
+
+  struct Result {
+    Optional<AccessScope> Scope;
+    ImportAccessLevel Import;
+  };
+
+  static Result
   getAccessScope(TypeRepr *TR, const DeclContext *useDC,
                  bool treatUsableFromInlineAsPublic = false) {
     TypeAccessScopeChecker checker(useDC, treatUsableFromInlineAsPublic);
     TR->walk(TypeReprIdentFinder([&](const IdentTypeRepr *typeRepr) {
       return checker.visitDecl(typeRepr->getBoundDecl());
     }));
-    return checker.Scope;
+    return {checker.Scope,
+            checker.ImportRestriction};
   }
 
-  static Optional<AccessScope>
+  static Result
   getAccessScope(Type T, const DeclContext *useDC,
                  bool treatUsableFromInlineAsPublic = false) {
     TypeAccessScopeChecker checker(useDC, treatUsableFromInlineAsPublic);
@@ -66,7 +87,9 @@ class TypeAccessScopeChecker {
         return TypeWalker::Action::Continue;
       return TypeWalker::Action::Stop;
     }));
-    return checker.Scope;
+
+    return {checker.Scope,
+            checker.ImportRestriction};
   }
 };
 

Diff for: lib/Sema/TypeCheckAccess.cpp

@@ -188,13 +188,14 @@ void AccessControlCheckerBase::checkTypeAccessImpl(
 
   AccessScope problematicAccessScope = AccessScope::getPublic();
   if (type) {
-    Optional<AccessScope> typeAccessScope =
+    auto scopeAndImport =
         TypeAccessScopeChecker::getAccessScope(type, useDC,
                                                checkUsableFromInline);
 
     // Note: This means that the type itself is invalid for this particular
     // context, because it references declarations from two incompatible scopes.
     // In this case we should have diagnosed the bad reference already.
+    Optional<AccessScope> typeAccessScope = scopeAndImport.Scope;
     if (!typeAccessScope.has_value())
       return;
     problematicAccessScope = *typeAccessScope;
@@ -210,9 +211,10 @@ void AccessControlCheckerBase::checkTypeAccessImpl(
     if (!typeRepr)
       return;
 
-    Optional<AccessScope> typeReprAccessScope =
+    auto typeReprAccessScopeAndImport =
         TypeAccessScopeChecker::getAccessScope(typeRepr, useDC,
                                                checkUsableFromInline);
+    auto typeReprAccessScope = typeReprAccessScopeAndImport.Scope;
     if (!typeReprAccessScope.has_value())
       return;
 
@@ -240,7 +242,7 @@ void AccessControlCheckerBase::checkTypeAccessImpl(
       // Downgrade the error to a warning in this case for source compatibility.
       Optional<AccessScope> typeReprAccessScope =
           TypeAccessScopeChecker::getAccessScope(typeRepr, useDC,
-                                                 checkUsableFromInline);
+                                                 checkUsableFromInline).Scope;
       assert(typeReprAccessScope && "valid Type but not valid TypeRepr?");
       if (contextAccessScope.hasEqualDeclContextWith(*typeReprAccessScope) ||
           contextAccessScope.isChildOf(*typeReprAccessScope)) {

Diff for: lib/Sema/TypeCheckProtocol.cpp

@@ -3406,7 +3406,7 @@ void ConformanceChecker::recordTypeWitness(AssociatedTypeDecl *assocType,
         // non-resilient modules.
         Optional<AccessScope> underlyingTypeScope =
             TypeAccessScopeChecker::getAccessScope(type, DC,
-                                                   /*usableFromInline*/false);
+                                                   /*usableFromInline*/false).Scope;
         assert(underlyingTypeScope.has_value() &&
                "the type is already invalid and we shouldn't have gotten here");