Support module selectors in qualified lookup

# Conflicts:
#	lib/ClangImporter/ImportDecl.cpp

Author: beccadax

include/swift/AST/NameLookup.h

@@ -438,6 +438,14 @@ class UsableFilteringDeclConsumer final : public VisibleDeclConsumer {
 /// \returns true if any declarations were removed, false otherwise.
 bool removeOverriddenDecls(SmallVectorImpl<ValueDecl*> &decls);
 
+/// Remove any declarations in the given set that do not match the
+/// module selector, if it is not empty.
+///
+/// \returns true if any declarations were removed, false otherwise.
+bool removeOutOfModuleDecls(SmallVectorImpl<ValueDecl*> &decls,
+                            Identifier moduleSelector,
+                            const DeclContext *dc);
+
 /// Remove any declarations in the given set that are shadowed by
 /// other declarations in that set.
 ///
@@ -494,6 +502,7 @@ namespace namelookup {
 /// Once name lookup has gathered a set of results, perform any necessary
 /// steps to prune the result set before returning it to the caller.
 void pruneLookupResultSet(const DeclContext *dc, NLOptions options,
+                          Identifier moduleSelector,
                           SmallVectorImpl<ValueDecl *> &decls);
 
 /// Do nothing if debugClient is null.

lib/AST/NameLookup.cpp

@@ -257,6 +257,42 @@ enum class ConstructorComparison {
   Better,
 };
 
+bool swift::removeOutOfModuleDecls(SmallVectorImpl<ValueDecl*> &decls,
+                                   Identifier moduleSelector,
+                                   const DeclContext *dc) {
+  if (moduleSelector.empty())
+    return false;
+
+  ASTContext &ctx = dc->getASTContext();
+
+  // FIXME: Should we look this up relative to dc?
+  // We'd need a new ResolutionKind.
+  // FIXME: How can we diagnose this?
+  ModuleDecl *visibleFrom = ctx.getLoadedModule(moduleSelector);
+  if (!visibleFrom) {
+    LLVM_DEBUG(llvm::dbgs() << "no module " << moduleSelector << "\n");
+    decls.clear();
+    return true;
+  }
+
+  bool initialCount = decls.size();
+  decls.erase(
+    std::remove_if(decls.begin(), decls.end(), [&](ValueDecl *decl) -> bool {
+      bool inScope = ctx.getImportCache().isImportedBy(decl->getModuleContext(),
+                                                       visibleFrom);
+
+      LLVM_DEBUG(decl->dumpRef(llvm::dbgs()));
+      LLVM_DEBUG(llvm::dbgs() << ": " << decl->getModuleContext()->getName()
+                              << (inScope ? " is " : " is NOT ")
+                              << "selected by " << visibleFrom->getName()
+                              << "\n");
+
+      return !inScope;
+    }),
+    decls.end());
+  return initialCount != decls.size();
+}
+
 /// Determines whether \p ctor1 is a "better" initializer than \p ctor2.
 static ConstructorComparison compareConstructors(ConstructorDecl *ctor1,
                                                  ConstructorDecl *ctor2,
@@ -1577,14 +1613,17 @@ static bool isAcceptableLookupResult(const DeclContext *dc,
 }
 
 void namelookup::pruneLookupResultSet(const DeclContext *dc, NLOptions options,
+                                      Identifier moduleSelector,
                                       SmallVectorImpl<ValueDecl *> &decls) {
   // If we're supposed to remove overridden declarations, do so now.
   if (options & NL_RemoveOverridden)
     removeOverriddenDecls(decls);
 
   // If we're supposed to remove shadowed/hidden declarations, do so now.
-  if (options & NL_RemoveNonVisible)
+  if (options & NL_RemoveNonVisible) {
+    removeOutOfModuleDecls(decls, moduleSelector, dc);
     removeShadowedDecls(decls, dc);
+  }
 
   ModuleDecl *M = dc->getParentModule();
   filterForDiscriminator(decls, M->getDebugClient());
@@ -1818,7 +1857,7 @@ QualifiedLookupRequest::evaluate(Evaluator &eval, const DeclContext *DC,
     }
   }
 
-  pruneLookupResultSet(DC, options, decls);
+  pruneLookupResultSet(DC, options, member.getModuleSelector(), decls);
   if (auto *debugClient = DC->getParentModule()->getDebugClient()) {
     debugClient->finishLookupInNominals(DC, typeDecls, member.getFullName(),
                                         options, decls);
@@ -1870,7 +1909,7 @@ ModuleQualifiedLookupRequest::evaluate(Evaluator &eval, const DeclContext *DC,
     }
   }
 
-  pruneLookupResultSet(DC, options, decls);
+  pruneLookupResultSet(DC, options, member.getModuleSelector(), decls);
 
   if (auto *debugClient = DC->getParentModule()->getDebugClient()) {
     debugClient->finishLookupInModule(DC, module, member.getFullName(),
@@ -1938,7 +1977,7 @@ AnyObjectLookupRequest::evaluate(Evaluator &evaluator, const DeclContext *dc,
       decls.push_back(decl);
   }
 
-  pruneLookupResultSet(dc, options, decls);
+  pruneLookupResultSet(dc, options, member.getModuleSelector(), decls);
   if (auto *debugClient = dc->getParentModule()->getDebugClient()) {
     debugClient->finishLookupInAnyObject(dc, member.getFullName(), options,
                                          decls);

test/NameLookup/module_selector.swift

@@ -21,6 +21,7 @@ extension main::B: main::Equatable {
   // @_derivative(of:)
 
   @_dynamicReplacement(for: main::negate())
+  // FIXME improve: expected-error@-1 {{replaced function 'main::negate()' could not be found}}
   mutating func myNegate() {
     let fn: (main::Int, main::Int) -> main::Int =
     // FIXME:
@@ -30,11 +31,12 @@ extension main::B: main::Equatable {
       // expected-error@-3 {{expected expression after operator}}
 
     let magnitude: main::Int.main::Magnitude = main::magnitude
-    // expected-EVENTUALLY-error@-1 {{a type mismatch with 'Never'}}
-    // FIXME: expected-error@-2 {{variable used within its own initial value}}
+    // expected-EVENTUALLY-error@-1 {{can't find 'Int'}}
+    // FIXME improve: expected-error@-2 {{type alias 'Magnitude' is not a member type of 'Int'}}
+    // FIXME: expected-error@-3 {{variable used within its own initial value}}
     if main::Bool.main::random() {
       main::negate()
-      // expected-EVENTUALLY-error@-1 {{something about not finding 'negate' because we didn't look in self}}
+      // FIXME improve: expected-error@-1 {{use of unresolved identifier 'main::negate'}}
     }
     else {
       self = main::B(value: .main::min)
@@ -66,7 +68,8 @@ extension ModuleSelectorTestingKit::C: ModuleSelectorTestingKit::Equatable {
       // expected-error@-3 {{expected expression after operator}}
     let magnitude: ModuleSelectorTestingKit::Int.ModuleSelectorTestingKit::Magnitude = ModuleSelectorTestingKit::magnitude
     // expected-EVENTUALLY-error@-1 {{something about not finding 'magnitude' because we didn't look in self}}
-    // FIXME: expected-error@-2 {{variable used within its own initial value}}
+    // FIXME improve: expected-error@-2 {{type alias 'Magnitude' is not a member type of 'Int'}}
+    // FIXME: expected-error@-3 {{variable used within its own initial value}}
     if ModuleSelectorTestingKit::Bool.ModuleSelectorTestingKit::random() {
       ModuleSelectorTestingKit::negate()
       // expected-EVENTUALLY-error@-1 {{something about not finding 'negate' because we didn't look in self}}
@@ -94,6 +97,7 @@ extension Swift::D: Swift::Equatable {
   // @_derivative(of:)
 
   @_dynamicReplacement(for: Swift::negate())
+  // FIXME improve: expected-error@-1 {{replaced function 'Swift::negate()' could not be found}}
   mutating func myNegate() {
     let fn: (Swift::Int, Swift::Int) -> Swift::Int =
     // FIXME:
@@ -106,7 +110,7 @@ extension Swift::D: Swift::Equatable {
     // FIXME: expected-error@-2 {{variable used within its own initial value}}
     if Swift::Bool.Swift::random() {
       Swift::negate()
-      // expected-EVENTUALLY-error@-1 {{something about not finding 'negate' because we didn't look in self}}
+      // FIXME improve: expected-error@-1 {{use of unresolved identifier 'Swift::negate'}}
     }
     else {
       self = Swift::D(value: .ModuleSelectorTestingKit::min)