[Tooling/Inclusion] Handle std::get symbol.

[hokein]

Summary

Currently, we handle it as a symbol without a header. In general, for
the include-cleaner case, the std::get comes with the type header, it is
safe to ignore it.

[kadircet]

thanks!

clang-tools-extra/clangd/index/CanonicalIncludes.cpp

llvm::StringRef CanonicalIncludes::mapSymbol(llvm::StringRef Scope,
   else
     return "";
   // FIXME: remove the following special cases when the tooling stdlib supports
   // them.
   // There are two std::move()s, this is by far the most common.
   if (Scope == "std::" && Name == "move")
     return "<utility>";
   if (auto StdSym = tooling::stdlib::Symbol::named(Scope, Name, Lang))
-    return StdSym->header().name();
+    if (auto Header = StdSym->header())
+      return Header->name();
   return "";
 }
 
 std::unique_ptr<CommentHandler>
 collectIWYUHeaderMaps(CanonicalIncludes *Includes) {
   class PragmaCommentHandler : public clang::CommentHandler {
   public:
     PragmaCommentHandler(CanonicalIncludes *Includes) : Includes(Includes) {}

clang/include/clang/Tooling/Inclusions/StandardLibrary.h

public:
 
   friend llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Symbol &S) {
     return OS << S.qualifiedName();
   }
   llvm::StringRef scope() const;
   llvm::StringRef name() const;
   llvm::StringRef qualifiedName() const;
   // The preferred header for this symbol (e.g. the suggested insertion).
-  Header header() const;
+  std::optional<Header> header() const;
   // Some symbols may be provided by multiple headers.
   llvm::SmallVector<Header> headers() const;
 
 private:
   Symbol(unsigned ID, Lang Language) : ID(ID), Language(Language) {}
   unsigned ID;
   Lang Language;
 

clang/lib/Tooling/Inclusions/Stdlib/StandardLibrary.cpp

 //===--- StandardLibrary.cpp ------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Tooling/Inclusions/StandardLibrary.h"
 #include "clang/AST/Decl.h"
 #include "clang/Basic/LangOptions.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Casting.h"
+#include <optional>
 
 namespace clang {
 namespace tooling {
 namespace stdlib {
 
 namespace {
 // Symbol name -> Symbol::ID, within a namespace.
 using NSSymbolMap = llvm::DenseMap<llvm::StringRef, unsigned>;
if (SymIndex >= 0 &&
              "The symbol has been added before, make sure entries in the .inc "
              "file are grouped by symbol name!");
     } else {
       // First symbol or new symbol, increment next available index.
       ++SymIndex;
     }
     Mapping->SymbolNames[SymIndex] = {
         QName.data(), NSLen, static_cast<unsigned int>(QName.size() - NSLen)};
+    if (!HeaderName.empty())
        Mapping->SymbolHeaderIDs[SymIndex].push_back(AddHeader(HeaderName));
 
     NSSymbolMap &NSSymbols = AddNS(QName.take_front(NSLen));
     NSSymbols.try_emplace(QName.drop_front(NSLen), SymIndex);
   };
 #define SYMBOL(Name, NS, Header) Add(#NS #Name, strlen(#NS), #Header);
   switch (Language) {
   case Lang::C:
 #include "CSymbolMap.inc"
std::optional<Symbol> Symbol::named(llvm::StringRef Scope, llvm::StringRef Name,
   if (NSSymbolMap *NSSymbols =
           getMappingPerLang(L)->NamespaceSymbols->lookup(Scope)) {
     auto It = NSSymbols->find(Name);
     if (It != NSSymbols->end())
       return Symbol(It->second, L);
   }
   return std::nullopt;
 }
-Header Symbol::header() const {
-  return Header(getMappingPerLang(Language)->SymbolHeaderIDs[ID][0], Language);
+std::optional<Header> Symbol::header() const {
+  const auto& Headers = getMappingPerLang(Language)->SymbolHeaderIDs[ID];
+  if (Headers.empty())
+    return std::nullopt;
+  return Header(Headers.front(), Language);
 }
 llvm::SmallVector<Header> Symbol::headers() const {
   llvm::SmallVector<Header> Results;
   for (auto HeaderID : getMappingPerLang(Language)->SymbolHeaderIDs[ID])
     Results.emplace_back(Header(HeaderID, Language));
   return Results;
 }
 

clang/lib/Tooling/Inclusions/Stdlib/StdSpecialSymbolMap.inc

 SYMBOL(ssize, std::, <regex>)
 SYMBOL(ssize, std::, <set>)
 SYMBOL(ssize, std::, <span>)
 SYMBOL(ssize, std::, <string>)
 SYMBOL(ssize, std::, <string_view>)
 SYMBOL(ssize, std::, <unordered_map>)
 SYMBOL(ssize, std::, <unordered_set>)
 SYMBOL(ssize, std::, <vector>)
+
+// std::get has a few variants for different types (tuple, array, pair etc)
+// which is tricky to disambiguate without type information.
+// Don't set any header for it, as it comes with the type header.
+SYMBOL(get, std::, /*no headers*/)

clang/unittests/Tooling/StandardLibraryTest.cpp

TEST(StdlibTest, All) {
   EXPECT_FALSE(stdlib::Symbol::named("clang::", "ASTContext"));
 
   EXPECT_TRUE(stdlib::Symbol::named("std::", "vector", stdlib::Lang::CXX));
   EXPECT_FALSE(stdlib::Symbol::named("std::", "vector", stdlib::Lang::C));
 
   EXPECT_EQ(Vector->header(), *VectorH);
   EXPECT_THAT(Vector->headers(), ElementsAre(*VectorH));
 
+  EXPECT_TRUE(stdlib::Symbol::named("std::", "get"));
+  EXPECT_FALSE(stdlib::Symbol::named("std::", "get")->header());
+
   EXPECT_THAT(stdlib::Symbol::named("std::", "basic_iostream")->headers(),
               ElementsAre(stdlib::Header::named("<istream>"),
                           stdlib::Header::named("<iostream>"),
                           stdlib::Header::named("<iosfwd>")));
   EXPECT_THAT(stdlib::Symbol::named("std::", "size_t")->headers(),
               ElementsAre(stdlib::Header::named("<cstddef>"),
                           stdlib::Header::named("<cstdlib>"),
                           stdlib::Header::named("<cstring>"),