Handle lookup into Builtin with module selector

beccadax · beccadax · commit ffaa35810c88 · 2025-10-24T16:23:48.000-07:00
Lookups like Builtin::Int64 were failing because BuiltinUnit rejected all unqualified lookups. Make it allow unqualified lookups with a module selector.
diff --git a/include/swift/AST/LookupKinds.h b/include/swift/AST/LookupKinds.h
@@ -104,6 +104,9 @@ enum class ModuleLookupFlags : unsigned {
   /// If @abi attributes are present, return the decls representing the ABI,
   /// not the API.
   ABIProviding = 1 << 1,
+  /// The lookup is qualified by a module selector which has specified this
+  /// module explicitly.
+  HasModuleSelector = 1 << 2,
 };
 
 } // end namespace swift
diff --git a/include/swift/AST/ModuleNameLookup.h b/include/swift/AST/ModuleNameLookup.h
@@ -53,6 +53,10 @@ void simple_display(llvm::raw_ostream &out, ResolutionKind kind);
 ///
 /// \param moduleOrFile The module or file unit to search, including imports.
 /// \param name The name to look up.
+/// \param hasModuleSelector Whether \p name was originally qualified by a
+///        module selector. This information is threaded through to underlying
+///        lookup calls; the callee is responsible for actually applying the
+///        module selector.
 /// \param[out] decls Any found decls will be added to this vector.
 /// \param lookupKind Whether this lookup is qualified or unqualified.
 /// \param resolutionKind What sort of decl is expected.
@@ -64,8 +68,11 @@ void simple_display(llvm::raw_ostream &out, ResolutionKind kind);
 /// \param options name lookup options. Currently only used to communicate the
 ///        NL_IncludeUsableFromInline option.
 void lookupInModule(const DeclContext *moduleOrFile,
-                    DeclName name, SmallVectorImpl<ValueDecl *> &decls,
-                    NLKind lookupKind, ResolutionKind resolutionKind,
+                    DeclName name,
+                    bool hasModuleSelector,
+                    SmallVectorImpl<ValueDecl *> &decls,
+                    NLKind lookupKind,
+                    ResolutionKind resolutionKind,
                     const DeclContext *moduleScopeContext,
                     SourceLoc loc, NLOptions options);
 
diff --git a/include/swift/AST/NameLookupRequests.h b/include/swift/AST/NameLookupRequests.h
@@ -475,13 +475,13 @@ using QualifiedLookupResult = SmallVector<ValueDecl *, 4>;
 class LookupInModuleRequest
     : public SimpleRequest<
           LookupInModuleRequest,
-          QualifiedLookupResult(const DeclContext *, DeclName, NLKind,
+          QualifiedLookupResult(const DeclContext *, DeclName, bool, NLKind,
                                 namelookup::ResolutionKind, const DeclContext *,
                                 NLOptions),
           RequestFlags::Uncached | RequestFlags::DependencySink> {
 public:
   LookupInModuleRequest(
-      const DeclContext *, DeclName, NLKind,
+      const DeclContext *, DeclName, bool, NLKind,
       namelookup::ResolutionKind, const DeclContext *,
       SourceLoc, NLOptions);
 
@@ -498,6 +498,10 @@ class LookupInModuleRequest
   /// \param evaluator The request evaluator.
   /// \param moduleOrFile The module or file unit to search, including imports.
   /// \param name The name to look up.
+  /// \param hasModuleSelector Whether \p name was originally qualified by a
+  ///        module selector. This information is threaded through to underlying
+  ///        lookup calls; the callee is responsible for actually applying the
+  ///        module selector.
   /// \param lookupKind Whether this lookup is qualified or unqualified.
   /// \param resolutionKind What sort of decl is expected.
   /// \param moduleScopeContext The top-level context from which the lookup is
@@ -506,7 +510,8 @@ class LookupInModuleRequest
   /// \param options Lookup options to apply.
   QualifiedLookupResult
   evaluate(Evaluator &evaluator, const DeclContext *moduleOrFile, DeclName name,
-           NLKind lookupKind, namelookup::ResolutionKind resolutionKind,
+           bool hasModuleSelector, NLKind lookupKind,
+           namelookup::ResolutionKind resolutionKind,
            const DeclContext *moduleScopeContext, NLOptions options) const;
 
 public:
diff --git a/lib/AST/Module.cpp b/lib/AST/Module.cpp
@@ -104,9 +104,6 @@ BuiltinUnit::LookupCache &BuiltinUnit::getCache() const {
 void BuiltinUnit::LookupCache::lookupValue(
        Identifier Name, NLKind LookupKind, const BuiltinUnit &M,
        SmallVectorImpl<ValueDecl*> &Result) {
-  // Only qualified lookup ever finds anything in the builtin module.
-  if (LookupKind != NLKind::QualifiedLookup) return;
-
   ValueDecl *&Entry = Cache[Name];
   ASTContext &Ctx = M.getParentModule()->getASTContext();
   if (!Entry) {
@@ -1073,6 +1070,11 @@ void ModuleDecl::lookupAvailabilityDomains(
 void BuiltinUnit::lookupValue(DeclName name, NLKind lookupKind,
                               OptionSet<ModuleLookupFlags> Flags,
                               SmallVectorImpl<ValueDecl*> &result) const {
+  // Only qualified lookup ever finds anything in the builtin module.
+  if (lookupKind != NLKind::QualifiedLookup
+        && !Flags.contains(ModuleLookupFlags::HasModuleSelector))
+    return;
+
   getCache().lookupValue(name.getBaseIdentifier(), lookupKind, *this, result);
 }
 
diff --git a/lib/AST/ModuleNameLookup.cpp b/lib/AST/ModuleNameLookup.cpp
@@ -66,11 +66,16 @@ class ModuleNameLookup {
   /// \param moduleScopeContext The top-level context from which the lookup is
   ///        being performed, for checking access. This must be either a
   ///        FileUnit or a Module.
+  /// \param hasModuleSelector Whether \p name was originally qualified by a
+  ///        module selector. This information is threaded through to underlying
+  ///        lookup calls; the callee is responsible for actually applying the
+  ///        module selector.
   /// \param options Lookup options to apply.
   void lookupInModule(SmallVectorImpl<ValueDecl *> &decls,
                       const DeclContext *moduleOrFile,
                       ImportPath::Access accessPath,
                       const DeclContext *moduleScopeContext,
+                      bool hasModuleSelector,
                       NLOptions options);
 };
 
@@ -173,6 +178,7 @@ void ModuleNameLookup<LookupStrategy>::lookupInModule(
     const DeclContext *moduleOrFile,
     ImportPath::Access accessPath,
     const DeclContext *moduleScopeContext,
+    bool hasModuleSelector,
     NLOptions options) {
   assert(moduleOrFile->isModuleScopeContext());
 
@@ -189,7 +195,7 @@ void ModuleNameLookup<LookupStrategy>::lookupInModule(
         selfOverlay = true;
       else
         lookupInModule(decls, overlay, accessPath, moduleScopeContext,
-                       options);
+                       hasModuleSelector, options);
     }
     // FIXME: This may not work gracefully if more than one of these lookups
     // finds something.
@@ -228,6 +234,8 @@ void ModuleNameLookup<LookupStrategy>::lookupInModule(
     currentModuleLookupFlags |= ModuleLookupFlags::ExcludeMacroExpansions;
   if (options & NL_ABIProviding)
     currentModuleLookupFlags |= ModuleLookupFlags::ABIProviding;
+  if (hasModuleSelector)
+    currentModuleLookupFlags |= ModuleLookupFlags::HasModuleSelector;
 
   // Do the lookup into the current module.
   auto *module = moduleOrFile->getParentModule();
@@ -255,6 +263,7 @@ void ModuleNameLookup<LookupStrategy>::lookupInModule(
     OptionSet<ModuleLookupFlags> importedModuleLookupFlags = {};
     if (options & NL_ABIProviding)
       currentModuleLookupFlags |= ModuleLookupFlags::ABIProviding;
+    // Do not propagate HasModuleSelector here; the selector wasn't specific.
 
     auto visitImport = [&](ImportedModule import,
                            const DeclContext *moduleScopeContext) {
@@ -357,27 +366,29 @@ void ModuleNameLookup<LookupStrategy>::lookupInModule(
 QualifiedLookupResult
 LookupInModuleRequest::evaluate(
     Evaluator &evaluator, const DeclContext *moduleOrFile, DeclName name,
-    NLKind lookupKind, ResolutionKind resolutionKind,
+    bool hasModuleSelector, NLKind lookupKind, ResolutionKind resolutionKind,
     const DeclContext *moduleScopeContext, NLOptions options) const {
   assert(moduleScopeContext->isModuleScopeContext());
 
   QualifiedLookupResult decls;
   LookupByName lookup(moduleOrFile->getASTContext(), resolutionKind,
                       name, lookupKind);
-  lookup.lookupInModule(decls, moduleOrFile, {}, moduleScopeContext, options);
+  lookup.lookupInModule(decls, moduleOrFile, {}, moduleScopeContext,
+                        hasModuleSelector, options);
   return decls;
 }
 
 void namelookup::lookupInModule(const DeclContext *moduleOrFile,
                                 DeclName name,
+                                bool hasModuleSelector,
                                 SmallVectorImpl<ValueDecl *> &decls,
                                 NLKind lookupKind,
                                 ResolutionKind resolutionKind,
                                 const DeclContext *moduleScopeContext,
                                 SourceLoc loc, NLOptions options) {
   auto &ctx = moduleOrFile->getASTContext();
-  LookupInModuleRequest req(moduleOrFile, name, lookupKind, resolutionKind,
-                            moduleScopeContext, loc, options);
+  LookupInModuleRequest req(moduleOrFile, name, hasModuleSelector, lookupKind,
+                            resolutionKind, moduleScopeContext, loc, options);
   auto results = evaluateOrDefault(ctx.evaluator, req, {});
   decls.append(results.begin(), results.end());
 }
@@ -393,6 +404,7 @@ void namelookup::lookupVisibleDeclsInModule(
   auto &ctx = moduleOrFile->getASTContext();
   LookupVisibleDecls lookup(ctx, resolutionKind, lookupKind);
   lookup.lookupInModule(decls, moduleOrFile, accessPath, moduleScopeContext,
+                        /*hasModuleSelector=*/false,
                         NL_QualifiedDefault);
 }
 
diff --git a/lib/AST/NameLookup.cpp b/lib/AST/NameLookup.cpp
@@ -373,6 +373,8 @@ bool swift::removeOutOfModuleDecls(SmallVectorImpl<ValueDecl*> &decls,
   // We'd need a new ResolutionKind.
   // FIXME: How can we diagnose this?
   ModuleDecl *visibleFrom = ctx.getLoadedModule(moduleSelector);
+  if (!visibleFrom && moduleSelector == ctx.TheBuiltinModule->getName())
+    visibleFrom = ctx.TheBuiltinModule;
   if (!visibleFrom) {
     LLVM_DEBUG(llvm::dbgs() << "no module " << moduleSelector << "\n");
     bool clearedAny = !decls.empty();
@@ -2860,8 +2862,9 @@ ModuleQualifiedLookupRequest::evaluate(Evaluator &eval, const DeclContext *DC,
                : ResolutionKind::Overloadable);
   auto topLevelScope = DC->getModuleScopeContext();
   if (module == topLevelScope->getParentModule()) {
-    lookupInModule(module, member.getFullName(), decls, NLKind::QualifiedLookup,
-                   kind, topLevelScope, SourceLoc(), options);
+    lookupInModule(module, member.getFullName(), member.hasModuleSelector(),
+                   decls, NLKind::QualifiedLookup, kind, topLevelScope,
+                   SourceLoc(), options);
   } else {
     // Note: This is a lookup into another module. Unless we're compiling
     // multiple modules at once, or if the other module re-exports this one,
@@ -2876,8 +2879,8 @@ ModuleQualifiedLookupRequest::evaluate(Evaluator &eval, const DeclContext *DC,
                      [&](ImportPath::Access accessPath) {
                        return accessPath.matches(member.getFullName());
                      })) {
-      lookupInModule(module, member.getFullName(), decls,
-                     NLKind::QualifiedLookup, kind, topLevelScope,
+      lookupInModule(module, member.getFullName(), member.hasModuleSelector(),
+                     decls, NLKind::QualifiedLookup, kind, topLevelScope,
                      SourceLoc(), options);
     }
   }
diff --git a/lib/AST/NameLookupRequests.cpp b/lib/AST/NameLookupRequests.cpp
@@ -631,12 +631,12 @@ UnqualifiedLookupRequest::UnqualifiedLookupRequest(
 ) : SimpleRequest(contextualizeOptions(descriptor)) { }
 
 LookupInModuleRequest::LookupInModuleRequest(
-      const DeclContext *moduleOrFile, DeclName name, NLKind lookupKind,
-      namelookup::ResolutionKind resolutionKind,
+      const DeclContext *moduleOrFile, DeclName name, bool hasModuleSelector,
+      NLKind lookupKind, namelookup::ResolutionKind resolutionKind,
       const DeclContext *moduleScopeContext,
       SourceLoc loc, NLOptions options
- ) : SimpleRequest(moduleOrFile, name, lookupKind, resolutionKind,
-                   moduleScopeContext,
+ ) : SimpleRequest(moduleOrFile, name, hasModuleSelector, lookupKind,
+                   resolutionKind, moduleScopeContext,
                    contextualizeOptions(moduleOrFile, loc, options)) { }
 
 ModuleQualifiedLookupRequest::ModuleQualifiedLookupRequest(
diff --git a/lib/AST/UnqualifiedLookup.cpp b/lib/AST/UnqualifiedLookup.cpp
@@ -481,12 +481,15 @@ void UnqualifiedLookupFactory::addImportedResults(const DeclContext *const dc) {
                       : isOriginallyMacroLookup ? ResolutionKind::MacrosOnly
                       : ResolutionKind::Overloadable;
   auto moduleToLookIn = dc;
-  if (Name.hasModuleSelector())
+  if (Name.hasModuleSelector()) {
     // FIXME: Should we look this up relative to dc?
     // We'd need a new ResolutionKind.
-    moduleToLookIn =
-        dc->getASTContext().getLoadedModule(Name.getModuleSelector());
-  
+    auto moduleName = Name.getModuleSelector();
+    moduleToLookIn = dc->getASTContext().getLoadedModule(moduleName);
+    if (!moduleToLookIn && moduleName == Ctx.TheBuiltinModule->getName())
+      moduleToLookIn = Ctx.TheBuiltinModule;
+  }
+
   // If we didn't find the module, it obviously can't have any results.
   if (!moduleToLookIn)
     return;
@@ -501,9 +504,9 @@ void UnqualifiedLookupFactory::addImportedResults(const DeclContext *const dc) {
   if (options.contains(Flags::IgnoreAccessControl))
     nlOptions |= NL_IgnoreAccessControl;
 
-  lookupInModule(moduleToLookIn, Name.getFullName(), CurModuleResults,
-                 NLKind::UnqualifiedLookup, resolutionKind, dc,
-                 Loc, nlOptions);
+  lookupInModule(moduleToLookIn, Name.getFullName(), Name.hasModuleSelector(),
+                 CurModuleResults, NLKind::UnqualifiedLookup, resolutionKind,
+                 dc, Loc, nlOptions);
 
   if (dc->isInSwiftinterface() &&
       !dc->getASTContext().LangOpts.FormalCxxInteropMode) {
diff --git a/lib/ClangImporter/ClangImporter.cpp b/lib/ClangImporter/ClangImporter.cpp
@@ -8130,9 +8130,10 @@ importer::getValueDeclsForName(NominalTypeDecl *decl, StringRef name) {
     // There is no Clang module for this declaration, so perform lookup from
     // the main module. This will find declarations from the bridging header.
     namelookup::lookupInModule(
-        ctx.MainModule, ctx.getIdentifier(name), results,
-        NLKind::UnqualifiedLookup, namelookup::ResolutionKind::Overloadable,
-        ctx.MainModule, SourceLoc(), NL_UnqualifiedDefault);
+        ctx.MainModule, ctx.getIdentifier(name), /*hasModuleSelector=*/false,
+        results, NLKind::UnqualifiedLookup,
+        namelookup::ResolutionKind::Overloadable, ctx.MainModule, SourceLoc(),
+        NL_UnqualifiedDefault);
 
     // Filter out any declarations that didn't come from Clang.
     auto newEnd =
diff --git a/lib/Frontend/ModuleInterfaceSupport.cpp b/lib/Frontend/ModuleInterfaceSupport.cpp
@@ -209,7 +209,8 @@ diagnoseIfModuleImportsShadowingDecl(ModuleInterfaceOptions const &Opts,
   using namespace namelookup;
 
   SmallVector<ValueDecl *, 4> decls;
-  lookupInModule(importedModule, importingModule->getName(), decls,
+  lookupInModule(importedModule, importingModule->getName(),
+                 /*hasModuleSelector=*/false, decls,
                  NLKind::UnqualifiedLookup, ResolutionKind::TypesOnly,
                  importedModule, SourceLoc(),
                  NL_UnqualifiedDefault | NL_IncludeUsableFromInline);
diff --git a/lib/Sema/CSSimplify.cpp b/lib/Sema/CSSimplify.cpp
@@ -10301,8 +10301,7 @@ performMemberLookup(ConstraintKind constraintKind, DeclNameRef memberName,
       }
     }
 
-    DeclName unprefixedName(context, memberName.getBaseName(), lookupLabels);
-    lookupName = DeclNameRef(unprefixedName);
+    lookupName = lookupName.withArgumentLabels(context, lookupLabels);
   }
 
   // Look for members within the base.
diff --git a/lib/Sema/ImportResolution.cpp b/lib/Sema/ImportResolution.cpp
@@ -1344,7 +1344,8 @@ ScopedImportLookupRequest::evaluate(Evaluator &evaluator,
   // FIXME: Doesn't handle scoped testable imports correctly.
   assert(accessPath.size() == 1 && "can't handle sub-decl imports");
   SmallVector<ValueDecl *, 8> decls;
-  lookupInModule(topLevelModule, accessPath.front().Item, decls,
+  lookupInModule(topLevelModule, accessPath.front().Item,
+                 /*hasModuleSelector=*/true, decls,
                  NLKind::QualifiedLookup, ResolutionKind::Overloadable,
                  import->getDeclContext()->getModuleScopeContext(),
                  import->getLoc(), NL_QualifiedDefault);
diff --git a/lib/Sema/TypeCheckAttr.cpp b/lib/Sema/TypeCheckAttr.cpp
@@ -3006,6 +3006,7 @@ void AttributeChecker::checkApplicationMainAttribute(DeclAttribute *attr,
   if (KitModule) {
     SmallVector<ValueDecl *, 1> decls;
     namelookup::lookupInModule(KitModule, Id_ApplicationDelegate,
+                               /*hasModuleSelector=*/false,
                                decls, NLKind::QualifiedLookup,
                                namelookup::ResolutionKind::TypesOnly,
                                SF, attr->getLocation(),
diff --git a/lib/Sema/TypeCheckType.cpp b/lib/Sema/TypeCheckType.cpp
@@ -193,8 +193,8 @@ static unsigned getGenericRequirementKind(TypeResolutionOptions options) {
 Type TypeResolution::resolveDependentMemberType(
     Type baseTy, DeclContext *DC, SourceRange baseRange,
     QualifiedIdentTypeRepr *repr) const {
-  // FIXME(ModQual): Reject qualified names immediately; they cannot be
-  // dependent member types.
+  // FIXME(ModQual): If module selector is present, check that it matches the
+  // protocol's module.
   Identifier refIdentifier = repr->getNameRef().getBaseIdentifier();
   ASTContext &ctx = DC->getASTContext();
 
diff --git a/test/NameLookup/module_selector.swift b/test/NameLookup/module_selector.swift
@@ -1,5 +1,5 @@
-// RUN: %target-typecheck-verify-swift -verify-ignore-unrelated -sdk %clang-importer-sdk -module-name main -I %S/Inputs -enable-experimental-feature ModuleSelector
-// RUN: %target-typecheck-verify-swift -verify-ignore-unrelated -sdk %clang-importer-sdk -module-name main -I %S/Inputs -enable-experimental-feature ModuleSelector -enable-experimental-feature ParserASTGen
+// RUN: %target-typecheck-verify-swift -verify-ignore-unrelated -sdk %clang-importer-sdk -module-name main -I %S/Inputs -enable-builtin-module -enable-experimental-feature ModuleSelector
+// RUN: %target-typecheck-verify-swift -verify-ignore-unrelated -sdk %clang-importer-sdk -module-name main -I %S/Inputs -enable-builtin-module -enable-experimental-feature ModuleSelector -enable-experimental-feature ParserASTGen
 
 // REQUIRES: swift_feature_ModuleSelector, swift_feature_ParserASTGen
 
@@ -19,6 +19,8 @@ import ModuleSelectorTestingKit
 import ctypes.bits
 import struct ModuleSelectorTestingKit::A
 
+import Builtin
+
 let magnitude: Never = fatalError()
 
 // Test correct code using `A`
@@ -351,3 +353,7 @@ func badModuleNames() {
   let y: A.NonexistentModule::MyChildType = fatalError()
   // expected-error@-1 {{'NonexistentModule::MyChildType' is not a member type of struct 'ModuleSelectorTestingKit.A'}}
 }
+
+func builtinModuleLookups(_ int: Builtin::Int64) -> Builtin::Int64 {
+  return Builtin::int_bswap_Int64(int)
+}
diff --git a/tools/SourceKit/lib/SwiftLang/SwiftSourceDocInfo.cpp b/tools/SourceKit/lib/SwiftLang/SwiftSourceDocInfo.cpp
@@ -543,8 +543,8 @@ static void walkRelatedDecls(const ValueDecl *VD, const FnTy &Fn) {
     }
   } else {
     namelookup::lookupInModule(DC->getModuleScopeContext(),
-                               VD->getBaseName(), results,
-                               NLKind::UnqualifiedLookup,
+                               VD->getBaseName(), /*hasModuleSelector=*/false,
+                               results, NLKind::UnqualifiedLookup,
                                namelookup::ResolutionKind::Overloadable,
                                DC->getModuleScopeContext(),
                                VD->getLoc(),
