Sema: Look through missing imports during qualified type lookup.

To improve knock-on diagnostics, resolve qualified 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

@@ -1472,19 +1472,6 @@ static Type diagnoseUnknownType(const TypeResolution &resolution,
     return ErrorType::get(ctx);
   }
 
-  // Try ignoring missing imports.
-  relookupOptions |= NameLookupFlags::IgnoreMissingImports;
-  auto nonImportedMembers = TypeChecker::lookupMemberType(
-      dc, parentType, repr->getNameRef(), repr->getLoc(), relookupOptions);
-  if (nonImportedMembers) {
-    const TypeDecl *first = nonImportedMembers.front().Member;
-    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);
-  }
-
   // FIXME: Typo correction!
 
   // Lookup into a type.
@@ -1902,10 +1889,25 @@ static Type resolveQualifiedIdentTypeRepr(const TypeResolution &resolution,
   if (options.contains(TypeResolutionFlags::AllowUsableFromInline))
     lookupOptions |= NameLookupFlags::IncludeUsableFromInline;
   LookupTypeResult memberTypes;
-  if (parentTy->mayHaveMembers())
+  if (parentTy->mayHaveMembers()) {
     memberTypes = TypeChecker::lookupMemberType(
         DC, parentTy, repr->getNameRef(), repr->getLoc(), lookupOptions);
 
+    // If no members were found, try ignoring missing imports.
+    if (!memberTypes &&
+        ctx.LangOpts.hasFeature(Feature::MemberImportVisibility)) {
+      lookupOptions |= NameLookupFlags::IgnoreMissingImports;
+      memberTypes = TypeChecker::lookupMemberType(
+          DC, parentTy, repr->getNameRef(), repr->getLoc(), lookupOptions);
+
+      if (memberTypes.size() == 1) {
+        if (maybeDiagnoseMissingImportForMember(memberTypes.back().Member, DC,
+                                                repr->getLoc()))
+          return ErrorType::get(ctx);
+      }
+    }
+  }
+
   // Name lookup was ambiguous. Complain.
   // FIXME: Could try to apply generic arguments first, and see whether
   // that resolves things. But do we really want that to succeed?

test/NameLookup/members_transitive_multifile_access_level.swift

@@ -10,7 +10,9 @@
 // RUN: %target-swift-frontend -emit-module -o %t %t/Exports.swift -I %t
 // RUN: %target-swift-frontend -typecheck -verify -swift-version 5 \
 // RUN:   -primary-file %t/function_bodies.swift \
-// RUN:   -primary-file %t/function_signatures.swift \
+// RUN:   -primary-file %t/function_signatures_unqualified.swift \
+// RUN:   -primary-file %t/function_signatures_qualified.swift \
+// RUN:   -primary-file %t/extensions.swift \
 // RUN:   %t/imports.swift \
 // RUN:   -I %t -package-name Package \
 // RUN:   -enable-experimental-feature MemberImportVisibility
@@ -45,7 +47,7 @@ func internalFunc(_ x: Int) {
   _ = x.memberInMixedUses // expected-error {{property 'memberInMixedUses' is not available due to missing import of defining module 'MixedUses'}}
 }
 
-//--- function_signatures.swift
+//--- function_signatures_unqualified.swift
 
 import Swift // Just here to anchor the fix-its
 // expected-note    2 {{add import of module 'InternalUsesOnly'}}{{1-1=internal import InternalUsesOnly\n}}
@@ -64,6 +66,57 @@ extension Int {
   internal func usesTypealiasInMixedUses_Internal(x: TypealiasInMixedUses) {} // expected-error {{type alias 'TypealiasInMixedUses' is not available due to missing import of defining module 'MixedUses'}}
 }
 
+//--- function_signatures_qualified.swift
+
+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=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}}
+
+private func usesTypealiasInInternalUsesOnly_Private(x: Int.TypealiasInInternalUsesOnly) {} // expected-error {{type alias 'TypealiasInInternalUsesOnly' is not available due to missing import of defining module 'InternalUsesOnly'}}
+internal func usesTypealiasInInternalUsesOnly(x: Int.TypealiasInInternalUsesOnly) {} // expected-error {{type alias 'TypealiasInInternalUsesOnly' is not available due to missing import of defining module 'InternalUsesOnly'}}
+package func usesTypealiasInPackageUsesOnly(x: Int.TypealiasInPackageUsesOnly) {} // expected-error {{type alias 'TypealiasInPackageUsesOnly' is not available due to missing import of defining module 'PackageUsesOnly'}}
+public func usesTypealiasInPublicUsesOnly(x: Int.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: Int.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: Int.TypealiasInMixedUses) {} // expected-error {{type alias 'TypealiasInMixedUses' is not available due to missing import of defining module 'MixedUses'}}
+
+//--- extensions.swift
+
+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=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.NestedInInternalUsesOnly { // expected-error {{struct 'NestedInInternalUsesOnly' is not available due to missing import of defining module 'InternalUsesOnly'}}
+  private func privateMethod() {}
+}
+
+extension Int.NestedInInternalUsesOnly { // expected-error {{struct 'NestedInInternalUsesOnly' is not available due to missing import of defining module 'InternalUsesOnly'}}
+  internal func internalMethod() {}
+}
+
+extension Int.NestedInPackageUsesOnly { // expected-error {{struct 'NestedInPackageUsesOnly' is not available due to missing import of defining module 'PackageUsesOnly'}}
+  package func packageMethod() {}
+}
+
+extension Int.NestedInPublicUsesOnly { // expected-error {{struct 'NestedInPublicUsesOnly' is not available due to missing import of defining module 'PublicUsesOnly'}}
+  // expected-warning@-1 {{cannot use struct 'NestedInPublicUsesOnly' in an extension with public or '@usableFromInline' members; 'PublicUsesOnly' was not imported by this file}}
+  public func publicMethod() {}
+}
+
+extension Int.NestedInMixedUses { // expected-error {{struct 'NestedInMixedUses' is not available due to missing import of defining module 'MixedUses'}}
+  // expected-warning@-1 {{cannot use struct 'NestedInMixedUses' in an extension with public or '@usableFromInline' members; 'MixedUses' was not imported by this file}}
+  public func publicMethod() {}
+}
+
+extension Int.NestedInMixedUses { // expected-error {{struct 'NestedInMixedUses' is not available due to missing import of defining module 'MixedUses'}}
+  internal func internalMethod() {}
+}
+
 //--- imports.swift
 
 internal import InternalUsesOnly
@@ -78,48 +131,55 @@ internal import Exports
 
 extension Int {
   public typealias TypealiasInInternalUsesOnly = Self
+  public struct NestedInInternalUsesOnly {}
   public var memberInInternalUsesOnly: Int { return self }
 }
 
 //--- InternalUsesOnlyDefaultedImport.swift
 
 extension Int {
   public typealias TypealiasInInternalUsesOnlyDefaultedImport = Self
+  public struct NestedInInternalUsesOnlyDefaultedImport {}
   public var memberInInternalUsesOnlyDefaultedImport: Int { return self }
 }
 
 //--- PackageUsesOnly.swift
 
 extension Int {
   public typealias TypealiasInPackageUsesOnly = Self
+  public struct NestedInPackageUsesOnly {}
   public var memberInPackageUsesOnly: Int { return self }
 }
 
 //--- PublicUsesOnly.swift
 
 extension Int {
   public typealias TypealiasInPublicUsesOnly = Self
+  public struct NestedInPublicUsesOnly {}
   public var memberInPublicUsesOnly: Int { return self }
 }
 
 //--- PublicUsesOnlyDefaultedImport.swift
 
 extension Int {
   public typealias TypealiasInPublicUsesOnlyDefaultedImport = Self
+  public struct NestedInPublicUsesOnlyDefaultedImport {}
   public var memberInPublicUsesOnlyDefaultedImport: Int { return self }
 }
 
 //--- MixedUses.swift
 
 extension Int {
   public typealias TypealiasInMixedUses = Self
+  public struct NestedInMixedUses {}
   public var memberInMixedUses: Int { return self }
 }
 
 //--- InternalUsesOnlyTransitivelyImported.swift
 
 extension Int {
   public typealias TypealiasInInternalUsesOnlyTransitivelyImported = Self
+  public struct NestedInInternalUsesOnlyTransitivelyImported {}
   public var memberInInternalUsesOnlyTransitivelyImported: Int { return self }
 }