[clangd] Add flags to symbol requests to restrict to ObjC symbols

[dgoldman]

Summary

clangd will set this flag for files with ObjC language flag enabled. This can be used to only include ObjC symbols when searching for symbols.

clang-tools-extra/clangd/CodeComplete.cpp

void ProcessOverloadCandidates(Sema &S, unsigned CurrentArg,
     llvm::DenseMap<SymbolID, std::string> FetchedDocs;
     if (Index) {
       LookupRequest IndexRequest;
       for (const auto &S : ScoredSignatures) {
         if (!S.IDForDoc)
           continue;
         IndexRequest.IDs.insert(S.IDForDoc);
       }
+      IndexRequest.IncludeObjC = S.getLangOpts().ObjC;
       Index->lookup(IndexRequest, [&](const Symbol &S) {
         if (!S.Documentation.empty())
           FetchedDocs[S.ID] = std::string(S.Documentation);
       });
       vlog("SigHelp: requested docs for {0} symbols from the index, got {1} "
            "symbols with non-empty docs in the response",
            IndexRequest.IDs.size(), FetchedDocs.size());
     }
class CodeCompleteFlow {
   llvm::Optional<FuzzyMatcher> Filter; // Initialized once Sema runs.
   Range ReplacedRange;
   std::vector<std::string> QueryScopes; // Initialized once Sema runs.
   // Initialized once QueryScopes is initialized, if there are scopes.
   llvm::Optional<ScopeDistance> ScopeProximity;
   llvm::Optional<OpaqueType> PreferredType; // Initialized once Sema runs.
   // Whether to query symbols from any scope. Initialized once Sema runs.
   bool AllScopes = false;
+  /// Whether Objective-C symbols should be included in the search.
+  bool IncludeObjC = false;
   llvm::StringSet<> ContextWords;
   // Include-insertion and proximity scoring rely on the include structure.
   // This is available after Sema has run.
   llvm::Optional<IncludeInserter> Inserter;  // Available during runWithSema.
   llvm::Optional<URIDistance> FileProximity; // Initialized once Sema runs.
   /// Speculative request based on the cached request and the filter text before
   /// the cursor.
   /// Initialized right before sema run. This is only set if `SpecFuzzyFind` is
CodeCompleteResult runWithSema() {
     } else {
       const auto &Pos = sourceLocToPosition(
           Recorder->CCSema->getSourceManager(),
           Recorder->CCSema->getPreprocessor().getCodeCompletionLoc());
       ReplacedRange.start = ReplacedRange.end = Pos;
     }
     Filter = FuzzyMatcher(
         Recorder->CCSema->getPreprocessor().getCodeCompletionFilter());
+    auto &ASTCtx = Recorder->CCSema->getASTContext();
+    IncludeObjC = ASTCtx.getLangOpts().ObjC;
     std::tie(QueryScopes, AllScopes) = getQueryScopes(
         Recorder->CCContext, *Recorder->CCSema, HeuristicPrefix, Opts);
     if (!QueryScopes.empty())
       ScopeProximity.emplace(QueryScopes);
     PreferredType =
-        OpaqueType::fromType(Recorder->CCSema->getASTContext(),
-                             Recorder->CCContext.getPreferredType());
+        OpaqueType::fromType(ASTCtx, Recorder->CCContext.getPreferredType());
     // Sema provides the needed context to query the index.
     // FIXME: in addition to querying for extra/overlapping symbols, we should
     //        explicitly request symbols corresponding to Sema results.
     //        We can use their signals even if the index can't suggest them.
     // We must copy index results to preserve them, but there are at most Limit.
     auto IndexResults = (Opts.Index && allowIndex(Recorder->CCContext))
                             ? queryIndex()
                             : SymbolSlab();
SymbolSlab queryIndex() {
     // Build the query.
     FuzzyFindRequest Req;
     if (Opts.Limit)
       Req.Limit = Opts.Limit;
     Req.Query = std::string(Filter->pattern());
     Req.RestrictForCodeCompletion = true;
     Req.Scopes = QueryScopes;
     Req.AnyScope = AllScopes;
+    Req.IncludeObjC = IncludeObjC;
     // FIXME: we should send multiple weighted paths here.
     Req.ProximityPaths.push_back(std::string(FileName));
     if (PreferredType)
       Req.PreferredTypes.push_back(std::string(PreferredType->raw()));
     vlog("Code complete: fuzzyFind({0:2})", toJSON(Req));
 
     if (SpecFuzzyFind)
       SpecFuzzyFind->NewReq = Req;

clang-tools-extra/clangd/HeaderSourceSwitch.cpp

 llvm::Optional<Path> getCorrespondingHeaderOrSource(PathRef OriginalFile,
                                                     ParsedAST &AST,
                                                     const SymbolIndex *Index) {
   if (!Index) {
     // FIXME: use the AST to do the inference.
     return None;
   }
   LookupRequest Request;
+  Request.IncludeObjC = AST.getLangOpts().ObjC;
   // Find all symbols present in the original file.
   for (const auto *D : getIndexableLocalDecls(AST)) {
     if (auto ID = getSymbolID(D))
       Request.IDs.insert(ID);
   }
   llvm::StringMap<int> Candidates; // Target path => score.
   auto AwardTarget = [&](const char *TargetURI) {
     if (auto TargetPath = URI::resolve(TargetURI, OriginalFile)) {

clang-tools-extra/clangd/Hover.cpp

if (!SymbolCollector::shouldCollectSymbol(ND, ND.getASTContext(),
                                             SymbolCollector::Options(),
                                             /*IsMainFileOnly=*/false))
     return;
   auto ID = getSymbolID(&ND);
   if (!ID)
     return;
   LookupRequest Req;
   Req.IDs.insert(ID);
+  Req.IncludeObjC = ND.getASTContext().getLangOpts().ObjC;
   Index->lookup(Req, [&](const Symbol &S) {
     Hover.Documentation = std::string(S.Documentation);
   });
 }
 
 // Default argument might exist but be unavailable, in the case of unparsed
 // arguments for example. This function returns the default argument if it is
 // available.

clang-tools-extra/clangd/IncludeFixer.h

private:
 
   llvm::Optional<Fix> insertHeader(llvm::StringRef Name,
                                    llvm::StringRef Symbol = "") const;
 
   struct UnresolvedName {
     std::string Name;   // E.g. "X" in foo::X.
     SourceLocation Loc; // Start location of the unresolved name.
     std::vector<std::string> Scopes; // Namespace scopes we should search in.
+    /// Whether Objective-C symbols should be included in the search for this
+    /// name.
+    bool IncludeObjC = false;
   };
 
   /// Records the last unresolved name seen by Sema.
   class UnresolvedNameRecorder;
 
   /// Attempts to fix the unresolved name associated with the current
   /// diagnostic. We assume a diagnostic is caused by a unresolved name when
   /// they have the same source location and the unresolved name is the last

clang-tools-extra/clangd/IncludeFixer.cpp

auto Extracted = extractUnresolvedNameCheaply(
         static_cast<Sema::LookupNameKind>(LookupKind) ==
             Sema::LookupNameKind::LookupNestedNameSpecifierName);
     if (!Extracted)
       return TypoCorrection();
 
     UnresolvedName Unresolved;
     Unresolved.Name = Extracted->Name;
     Unresolved.Loc = Typo.getBeginLoc();
+    Unresolved.IncludeObjC = SemaPtr->getLangOpts().ObjC;
     if (!Extracted->ResolvedScope && !S) // Give up if no scope available.
       return TypoCorrection();
 
     if (Extracted->ResolvedScope)
       Unresolved.Scopes.push_back(*Extracted->ResolvedScope);
     else // no qualifier or qualifier is unresolved.
       Unresolved.Scopes = collectAccessibleScopes(
           *SemaPtr, Typo, S, static_cast<Sema::LookupNameKind>(LookupKind));
std::vector<Fix> IncludeFixer::fixUnresolvedName() const {
   auto &Unresolved = *LastUnresolvedName;
   vlog("Trying to fix unresolved name \"{0}\" in scopes: [{1}]",
        Unresolved.Name, llvm::join(Unresolved.Scopes, ", "));
 
   FuzzyFindRequest Req;
   Req.AnyScope = false;
   Req.Query = Unresolved.Name;
   Req.Scopes = Unresolved.Scopes;
+  Req.IncludeObjC = Unresolved.IncludeObjC;
   Req.RestrictForCodeCompletion = true;
   Req.Limit = 100;
 
   if (llvm::Optional<const SymbolSlab *> Syms = fuzzyFindCached(Req))
     return fixesForSymbols(**Syms);
 
   return {};
 }

clang-tools-extra/clangd/XRefs.cpp

for (const auto &E : Candidates) {
     LocateASTReferentMetric.record(1, "regular");
     // Otherwise the target declaration is the right one.
     AddResultDecl(D);
   }
 
   // Now query the index for all Symbol IDs we found in the AST.
   if (Index && !ResultIndex.empty()) {
     LookupRequest QueryRequest;
+    QueryRequest.IncludeObjC = AST.getLangOpts().ObjC;
     for (auto It : ResultIndex)
       QueryRequest.IDs.insert(It.first);
     std::string Scratch;
     Index->lookup(QueryRequest, [&](const Symbol &Sym) {
       auto &R = Result[ResultIndex.lookup(Sym.ID)];
 
       if (R.Definition) { // from AST
         // Special case: if the AST yielded a definition, then it may not be
locateSymbolTextually(const SpelledWord &Word, ParsedAST &AST,
   Req.Scopes =
       visibleNamespaces(sourcePrefix(Word.Location, SM), AST.getLangOpts());
   // FIXME: For extra strictness, consider AnyScope=false.
   Req.AnyScope = true;
   // We limit the results to 3 further below. This limit is to avoid fetching
   // too much data, while still likely having enough for 3 results to remain
   // after additional filtering.
   Req.Limit = 10;
+  Req.IncludeObjC = AST.getLangOpts().ObjC;
   bool TooMany = false;
   using ScoredLocatedSymbol = std::pair<float, LocatedSymbol>;
   std::vector<ScoredLocatedSymbol> ScoredResults;
   Index->fuzzyFind(Req, [&](const Symbol &Sym) {
     // Only consider exact name matches, including case.
     // This is to avoid too many false positives.
     // We could relax this in the future (e.g. to allow for typos) if we make
     // the query more accurate by other means.
for (const NamedDecl *D : Decls) {
       // TODO: we could skip TU-scoped symbols here (e.g. static functions) if
       // we know this file isn't a header. The details might be tricky.
       if (D->getParentFunctionOrMethod())
         continue;
       IDsToQuery.insert(ID);
     }
 
     RelationsRequest OverriddenBy;
+    OverriddenBy.IncludeObjC = AST.getLangOpts().ObjC;
     if (Index) {
       OverriddenBy.Predicate = RelationKind::OverriddenBy;
       for (const NamedDecl *ND : Decls) {
         // Special case: For virtual methods, report decl/def of overrides and
         // references to all overridden methods in complete type hierarchy.
         if (const auto *CMD = llvm::dyn_cast<CXXMethodDecl>(ND)) {
           if (CMD->isVirtual()) {
             if (auto ID = getSymbolID(CMD))
ReferencesResult findReferences(ParsedAST &AST, Position Pos, uint32_t Limit,
   }
   // Now query the index for references from other files.
   auto QueryIndex = [&](llvm::DenseSet<SymbolID> IDs, bool AllowAttributes,
                         bool AllowMainFileSymbols) {
     if (IDs.empty() || !Index || Results.HasMore)
       return;
     RefsRequest Req;
     Req.IDs = std::move(IDs);
+    Req.IncludeObjC = AST.getLangOpts().ObjC;
     if (Limit) {
       if (Limit < Results.References.size()) {
         // We've already filled our quota, still check the index to correctly
         // return the `HasMore` info.
         Req.Limit = 0;
       } else {
         // Query index only for the remaining size.
         Req.Limit = Limit - Results.References.size();

clang-tools-extra/clangd/index/Index.h

struct FuzzyFindRequest {
   llvm::Optional<uint32_t> Limit;
   /// If set to true, only symbols for completion support will be considered.
   bool RestrictForCodeCompletion = false;
   /// Contextually relevant files (e.g. the file we're code-completing in).
   /// Paths should be absolute.
   std::vector<std::string> ProximityPaths;
   /// Preferred types of symbols. These are raw representation of `OpaqueType`.
   std::vector<std::string> PreferredTypes;
+  /// Whether Objective-C symbols should be included in the search.
+  bool IncludeObjC = false;
 
   bool operator==(const FuzzyFindRequest &Req) const {
     return std::tie(Query, Scopes, Limit, RestrictForCodeCompletion,
-                    ProximityPaths, PreferredTypes) ==
+                    ProximityPaths, PreferredTypes, IncludeObjC) ==
            std::tie(Req.Query, Req.Scopes, Req.Limit,
                     Req.RestrictForCodeCompletion, Req.ProximityPaths,
-                    Req.PreferredTypes);
+                    Req.PreferredTypes, Req.IncludeObjC);
   }
   bool operator!=(const FuzzyFindRequest &Req) const { return !(*this == Req); }
 };
 bool fromJSON(const llvm::json::Value &Value, FuzzyFindRequest &Request,
               llvm::json::Path);
 llvm::json::Value toJSON(const FuzzyFindRequest &Request);
 
 struct LookupRequest {
   llvm::DenseSet<SymbolID> IDs;
+  /// Whether Objective-C symbols should be included in the lookup.
+  bool IncludeObjC = false;
 };
 
 struct RefsRequest {
   llvm::DenseSet<SymbolID> IDs;
   RefKind Filter = RefKind::All;
   /// If set, limit the number of refers returned from the index. The index may
   /// choose to return less than this, e.g. it tries to avoid returning stale
   /// results.
   llvm::Optional<uint32_t> Limit;
   /// If set, populates the container of the reference.
   /// Index implementations may chose to populate containers no matter what.
   bool WantContainer = false;
+  /// Whether Objective-C code should be included in the search.
+  bool IncludeObjC = false;
 };
 
 struct RelationsRequest {
   llvm::DenseSet<SymbolID> Subjects;
   RelationKind Predicate;
   /// If set, limit the number of relations returned from the index.
   llvm::Optional<uint32_t> Limit;
+  /// Whether Objective-C code should be included in the search.
+  bool IncludeObjC = false;
 };
 
 /// Describes what data is covered by an index.
 ///
 /// Indexes may contain symbols but not references from a file, etc.
 /// This affects merging: if a staler index contains a reference but a fresher
 /// one does not, we want to trust the fresher index *only* if it actually
 /// includes references in general.