Sema: Look through missing imports during unqualified type lookup.

To improve knock-on diagnostics, resolve unqualified types to their matching
member type declarations regardless of whether an import is missing when the
`MemberImportVisibility` features is enabled.

Part of rdar://126637855.

Author: tshortli

lib/Sema/TypeCheckType.cpp

@@ -1381,20 +1381,6 @@ static Type diagnoseUnknownType(const TypeResolution &resolution,
       return ErrorType::get(ctx);
     }
 
-    // Try ignoring missing imports.
-    relookupOptions |= NameLookupFlags::IgnoreMissingImports;
-    auto nonImportedResults = TypeChecker::lookupUnqualifiedType(
-        dc, repr->getNameRef(), repr->getLoc(), relookupOptions);
-    if (!nonImportedResults.empty()) {
-      auto first = cast<TypeDecl>(nonImportedResults.front().getValueDecl());
-      auto nameLoc = repr->getNameLoc();
-      maybeDiagnoseMissingImportForMember(first, dc, nameLoc.getStartLoc());
-
-      // Don't try to recover here; we'll get more access-related diagnostics
-      // downstream if we do.
-      return ErrorType::get(ctx);
-    }
-
     // Fallback.
     auto L = repr->getNameLoc();
     SourceRange R = repr->getNameLoc().getSourceRange();
@@ -1656,6 +1642,16 @@ resolveUnqualifiedIdentTypeRepr(const TypeResolution &resolution,
   auto globals =
       TypeChecker::lookupUnqualifiedType(DC, id, repr->getLoc(), lookupOptions);
 
+  // If the look up did not yield any results, try again but allow members from
+  // modules that are not directly imported to be accessible.
+  bool didIgnoreMissingImports = false;
+  if (!globals && ctx.LangOpts.hasFeature(Feature::MemberImportVisibility)) {
+    lookupOptions |= NameLookupFlags::IgnoreMissingImports;
+    globals = TypeChecker::lookupUnqualifiedType(DC, id, repr->getLoc(),
+                                                 lookupOptions);
+    didIgnoreMissingImports = true;
+  }
+
   // If we're doing structural resolution and one of the results is an
   // associated type, ignore any other results found from the same
   // DeclContext; they are going to be protocol typealiases, possibly
@@ -1730,6 +1726,11 @@ resolveUnqualifiedIdentTypeRepr(const TypeResolution &resolution,
 
   // If we found a type declaration with the given name, return it now.
   if (current) {
+    if (didIgnoreMissingImports &&
+        maybeDiagnoseMissingImportForMember(currentDecl, DC, repr->getLoc())) {
+      repr->setInvalid();
+      return ErrorType::get(ctx);
+    }
     repr->setValue(currentDecl, currentDC);
     return current;
   }

test/NameLookup/members_transitive_multifile_access_level.swift

@@ -47,19 +47,20 @@ func internalFunc(_ x: Int) {
 
 //--- function_signatures.swift
 
-// FIXME: The access level is wrong on many of these fix-its.
 import Swift // Just here to anchor the fix-its
 // expected-note    2 {{add import of module 'InternalUsesOnly'}}{{1-1=internal import InternalUsesOnly\n}}
-// expected-note@-1   {{add import of module 'PackageUsesOnly'}}{{1-1=internal import PackageUsesOnly\n}}
-// expected-note@-2   {{add import of module 'PublicUsesOnly'}}{{1-1=internal import PublicUsesOnly\n}}
-// expected-note@-3 2 {{add import of module 'MixedUses'}}{{1-1=internal import MixedUses\n}}
+// expected-note@-1   {{add import of module 'PackageUsesOnly'}}{{1-1=package import PackageUsesOnly\n}}
+// expected-note@-2   {{add import of module 'PublicUsesOnly'}}{{1-1=public import PublicUsesOnly\n}}
+// expected-note@-3 2 {{add import of module 'MixedUses'}}{{1-1=public import MixedUses\n}}
 
 extension Int {
   private func usesTypealiasInInternalUsesOnly_Private(x: TypealiasInInternalUsesOnly) {} // expected-error {{type alias 'TypealiasInInternalUsesOnly' is not available due to missing import of defining module 'InternalUsesOnly'}}
   internal func usesTypealiasInInternalUsesOnly(x: TypealiasInInternalUsesOnly) {} // expected-error {{type alias 'TypealiasInInternalUsesOnly' is not available due to missing import of defining module 'InternalUsesOnly'}}
   package func usesTypealiasInPackageUsesOnly(x: TypealiasInPackageUsesOnly) {} // expected-error {{type alias 'TypealiasInPackageUsesOnly' is not available due to missing import of defining module 'PackageUsesOnly'}}
   public func usesTypealiasInPublicUsesOnly(x: TypealiasInPublicUsesOnly) {} // expected-error {{type alias 'TypealiasInPublicUsesOnly' is not available due to missing import of defining module 'PublicUsesOnly'}}
+  // expected-warning@-1 {{cannot use type alias 'TypealiasInPublicUsesOnly' here; 'PublicUsesOnly' was not imported by this file}}
   public func usesTypealiasInMixedUses(x: TypealiasInMixedUses) {} // expected-error {{type alias 'TypealiasInMixedUses' is not available due to missing import of defining module 'MixedUses'}}
+  // expected-warning@-1 {{cannot use type alias 'TypealiasInMixedUses' here; 'MixedUses' was not imported by this file}}
   internal func usesTypealiasInMixedUses_Internal(x: TypealiasInMixedUses) {} // expected-error {{type alias 'TypealiasInMixedUses' is not available due to missing import of defining module 'MixedUses'}}
 }