Handle module selectors in unqualified lookup

Author: beccadax

lib/AST/UnqualifiedLookup.cpp

@@ -472,19 +472,32 @@ void UnqualifiedLookupFactory::setAsideUnavailableResults(
 }
 
 void UnqualifiedLookupFactory::addImportedResults(const DeclContext *const dc) {
+  assert(dc);
+
   using namespace namelookup;
   SmallVector<ValueDecl *, 8> CurModuleResults;
   auto resolutionKind = isOriginallyTypeLookup ? ResolutionKind::TypesOnly
                       : isOriginallyMacroLookup ? ResolutionKind::MacrosOnly
                       : ResolutionKind::Overloadable;
+  auto moduleToLookIn = dc;
+  if (Name.hasModuleSelector())
+    // FIXME: Should we look this up relative to dc?
+    // We'd need a new ResolutionKind.
+    moduleToLookIn =
+        dc->getASTContext().getLoadedModule(Name.getModuleSelector());
+  
+  // If we didn't find the module, it obviously can't have any results.
+  if (!moduleToLookIn)
+    return;
+
   auto nlOptions = NL_UnqualifiedDefault;
   if (options.contains(Flags::IncludeUsableFromInline))
     nlOptions |= NL_IncludeUsableFromInline;
   if (options.contains(Flags::ExcludeMacroExpansions))
     nlOptions |= NL_ExcludeMacroExpansions;
   if (options.contains(Flags::ABIProviding))
     nlOptions |= NL_ABIProviding;
-  lookupInModule(dc, Name.getFullName(), CurModuleResults,
+  lookupInModule(moduleToLookIn, Name.getFullName(), CurModuleResults,
                  NLKind::UnqualifiedLookup, resolutionKind, dc,
                  Loc, nlOptions);
 

test/NameLookup/module_selector.swift

@@ -64,13 +64,19 @@ extension A: @retroactive Swift::Equatable {
 // Test resolution of main:: using `B`
 
 extension main::B {}
+// FIXME improve: expected-error@-1 {{cannot find type 'main::B' in scope}}
 
 extension B: @retroactive main::Equatable {
+  // FIXME improve: expected-error@-1 {{cannot find type 'main::Equatable' in scope}}
 
   @_implements(main::Equatable, ==(_:_:))
+  // FIXME improve: expected-error@-1 {{cannot find type 'main::Equatable' in scope}}
 
   public static func equals(_: main::B, _: main::B) -> main::Bool {
-    main::fatalError()
+  // FIXME improve: expected-error@-1 {{cannot find type 'main::B' in scope}}
+  // FIXME improve: expected-error@-2 {{cannot find type 'main::B' in scope}}
+  // FIXME improve: expected-error@-3 {{cannot find type 'main::Bool' in scope}}
+    main::fatalError() // no-error -- not typechecking function bodies
   }
 
   // FIXME: Add tests with autodiff @_differentiable(jvp:vjp:) and
@@ -81,6 +87,7 @@ extension B: @retroactive main::Equatable {
 
   mutating func myNegate() {
     let fn: (main::Int, main::Int) -> main::Int =
+    // FIXME improve: expected-error@-1 3{{cannot find type 'main::Int' in scope}}
       (main::+)
 
     let magnitude: Int.main::Magnitude = main::magnitude
@@ -89,19 +96,23 @@ extension B: @retroactive main::Equatable {
     _ = (fn, magnitude)
 
     if main::Bool.main::random() {
+      // FIXME improve: expected-error@-1 {{cannot find 'main::Bool' in scope}}
 
       main::negate()
       // FIXME improve: expected-error@-1 {{cannot find 'main::negate' in scope}}
     }
     else {
       self = main::B(value: .main::min)
+      // FIXME improve: expected-error@-1 {{cannot find 'main::B' in scope}}
+      // expected-error@-2 {{cannot infer contextual base in reference to member 'main::min'}}
 
       self = B.main::init(value: .min)
     }
 
     self.main::myNegate()
 
     main::fatalError()
+    // FIXME improve: expected-error@-1 {{cannot find 'main::fatalError' in scope}}
   }
 
   // FIXME: Can we test @convention(witness_method:)?
@@ -112,11 +123,15 @@ extension B: @retroactive main::Equatable {
 extension ModuleSelectorTestingKit::C {}
 
 extension C: @retroactive ModuleSelectorTestingKit::Equatable {
+// FIXME improve: expected-error@-1 {{cannot find type 'ModuleSelectorTestingKit::Equatable' in scope}}
 
   @_implements(ModuleSelectorTestingKit::Equatable, ==(_:_:))
+  // FIXME improve: expected-error@-1 {{cannot find type 'ModuleSelectorTestingKit::Equatable' in scope}}
 
   public static func equals(_: ModuleSelectorTestingKit::C, _: ModuleSelectorTestingKit::C) -> ModuleSelectorTestingKit::Bool {
-    ModuleSelectorTestingKit::fatalError()
+  // FIXME improve: expected-error@-1 {{cannot find type 'ModuleSelectorTestingKit::Bool' in scope}}
+
+    ModuleSelectorTestingKit::fatalError() // no-error -- not typechecking function bodies
   }
 
   // FIXME: Add tests with autodiff @_differentiable(jvp:vjp:) and
@@ -126,6 +141,7 @@ extension C: @retroactive ModuleSelectorTestingKit::Equatable {
 
   mutating func myNegate() {
     let fn: (ModuleSelectorTestingKit::Int, ModuleSelectorTestingKit::Int) -> ModuleSelectorTestingKit::Int =
+    // FIXME improve: expected-error@-1 3{{cannot find type 'ModuleSelectorTestingKit::Int' in scope}}
       (ModuleSelectorTestingKit::+)
 
     let magnitude: Int.ModuleSelectorTestingKit::Magnitude = ModuleSelectorTestingKit::magnitude
@@ -134,6 +150,7 @@ extension C: @retroactive ModuleSelectorTestingKit::Equatable {
     _ = (fn, magnitude)
 
     if ModuleSelectorTestingKit::Bool.ModuleSelectorTestingKit::random() {
+    // FIXME improve: expected-error@-1 {{cannot find 'ModuleSelectorTestingKit::Bool' in scope}}
 
       ModuleSelectorTestingKit::negate()
       // expected-error@-1 {{cannot find 'ModuleSelectorTestingKit::negate' in scope}}
@@ -147,6 +164,7 @@ extension C: @retroactive ModuleSelectorTestingKit::Equatable {
     self.ModuleSelectorTestingKit::myNegate()
 
     ModuleSelectorTestingKit::fatalError()
+    // FIXME improve: expected-error@-1 {{cannot find 'ModuleSelectorTestingKit::fatalError' in scope}}
   }
 
   // FIXME: Can we test @convention(witness_method:)?
@@ -155,12 +173,16 @@ extension C: @retroactive ModuleSelectorTestingKit::Equatable {
 // Test resolution of Swift:: using `D`
 
 extension Swift::D {}
+// FIXME improve: expected-error@-1 {{cannot find type 'Swift::D' in scope}}
 
 extension D: @retroactive Swift::Equatable {
+// Caused by Swift::D failing to typecheck in `equals(_:_:)`: expected-error@-1 *{{extension outside of file declaring struct 'D' prevents automatic synthesis of '==' for protocol 'Equatable'}} expected-note@-1 *{{add stubs for conformance}}
 
   @_implements(Swift::Equatable, ==(_:_:))
   public static func equals(_: Swift::D, _: Swift::D) -> Swift::Bool {
-    Swift::fatalError()
+  // expected-error@-1 {{cannot find type 'Swift::D' in scope}}
+  // expected-error@-2 {{cannot find type 'Swift::D' in scope}}
+    Swift::fatalError() // no-error -- not typechecking function bodies
   }
 
   // FIXME: Add tests with autodiff @_differentiable(jvp:vjp:) and
@@ -175,7 +197,7 @@ extension D: @retroactive Swift::Equatable {
       (Swift::+)
 
     let magnitude: Int.Swift::Magnitude = Swift::magnitude
-    // expected-error@-1 {{cannot convert value of type 'Never' to specified type 'Int.Magnitude' (aka 'UInt')}}
+    // expected-error@-1 {{cannot find 'Swift::magnitude' in scope}}
 
     _ = (fn, magnitude)
 
@@ -186,6 +208,8 @@ extension D: @retroactive Swift::Equatable {
     }
     else {
       self = Swift::D(value: .Swift::min)
+      // FIXME improve: expected-error@-1 {{cannot find 'Swift::D' in scope}}
+      // expected-error@-2 {{cannot infer contextual base in reference to member 'Swift::min'}}
 
       self = D.Swift::init(value: .min)
     }
@@ -199,7 +223,6 @@ extension D: @retroactive Swift::Equatable {
 }
 
 let mog: Never = fatalError()
-// expected-note@-1 {{did you mean 'mog'?}}
 
 func localVarsCantBeAccessedByModuleSelector() {
   let mag: Int.Swift::Magnitude = main::mag
@@ -212,55 +235,62 @@ struct AvailableUser {
   @available(macOS 10.15, *) var use1: String { "foo" }
 
   @main::available() var use2
+  // FIXME improve: expected-error@-1 {{unknown attribute 'available'}}
+  // FIXME suppress: expected-error@-2 {{type annotation missing in pattern}}
 
   @ModuleSelectorTestingKit::available() var use4
   // no-error
 
   @Swift::available() var use5
+  // FIXME improve: expected-error@-1 {{unknown attribute 'available'}}
+  // FIXME suppress: expected-error@-2 {{type annotation missing in pattern}}
 }
 
 func builderUser2(@main::MyBuilder fn: () -> Void) {}
+// FIXME improve: expected-error@-1 {{unknown attribute 'MyBuilder'}}
 
 func builderUser3(@ModuleSelectorTestingKit::MyBuilder fn: () -> Void) {}
+// no-error
 
 func builderUser4(@Swift::MyBuilder fn: () -> Void) {}
+// FIXME improve: expected-error@-1 {{unknown attribute 'MyBuilder'}}
 
 // Error cases
 
 func decl1(
   p1: main::A,
+  // FIXME: expected-error@-1 {{cannot find type 'main::A' in scope}}
   label p2: inout A,
   label p3: @escaping () -> A
 ) {
   switch Optional(main::p2) {
   case Optional.some(let decl1i):
-    // expected-warning@-1 {{immutable value 'decl1i' was never used; consider replacing with '_' or removing it}}
     break
   case .none:
     break
   }
 
   switch Optional(main::p2) {
   case let Optional.some(decl1j):
-    // expected-warning@-1 {{immutable value 'decl1j' was never used; consider replacing with '_' or removing it}}
     break
   case .none:
     break
   }
 
   switch Optional(main::p2) {
  case let decl1k?:
-    // expected-warning@-1 {{immutable value 'decl1k' was never used; consider replacing with '_' or removing it}}
     break
   case .none:
     break
   }
 }
 
 typealias decl5 = main::Bool
+// FIXME improve: expected-error@-1 {{cannot find type 'main::Bool' in scope}}
 
 func badModuleNames() {
   NonexistentModule::print()
+  // expected-error@-1 {{cannot find 'NonexistentModule::print' in scope}}
 
   _ = "foo".NonexistentModule::count