[Tooling/Inclusion] Use the StdSpecialSymbolMap.inc in the stdlib

[hokein]

Summary

Remove a special-case in clangd.

[kadircet]

clang/unittests/Tooling/StandardLibraryTest.cpp

65

can you also have a test checking header() is <cstddef>

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

else if (L.C11)
     Lang = tooling::stdlib::Lang::C;
   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 (Scope == "std::" && Name == "size_t")
-    return "<cstddef>";
   if (auto StdSym = tooling::stdlib::Symbol::named(Scope, Name, Lang))
     return StdSym->header().name();
   return "";
 }
 
 std::unique_ptr<CommentHandler>
 collectIWYUHeaderMaps(CanonicalIncludes *Includes) {
   class PragmaCommentHandler : public clang::CommentHandler {

clang-tools-extra/clangd/unittests/CanonicalIncludesTests.cpp

TEST(CanonicalIncludesTest, CXXStandardLibrary) {
   Language.CPlusPlus = true;
   CI.addSystemHeadersMapping(Language);
 
   // Usual standard library symbols are mapped correctly.
   EXPECT_EQ("<vector>", CI.mapSymbol("std::", "vector", Language));
   EXPECT_EQ("<cstdio>", CI.mapSymbol("std::", "printf", Language));
   // std::move is ambiguous, currently always mapped to <utility>
   EXPECT_EQ("<utility>", CI.mapSymbol("std::", "move", Language));
+  EXPECT_EQ("<cstddef>", CI.mapSymbol("std::", "size_t", Language));
   // Unknown std symbols aren't mapped.
   EXPECT_EQ("", CI.mapSymbol("std::", "notathing", Language));
   // iosfwd declares some symbols it doesn't own.
   EXPECT_EQ("<ostream>", CI.mapSymbol("std::", "ostream", Language));
   // And (for now) we assume it owns the others.
   auto InMemFS = llvm::makeIntrusiveRefCnt<llvm::vfs::InMemoryFileSystem>();
   FileManager Files(FileSystemOptions(), InMemFS);
   auto File = addFile(*InMemFS, Files, testPath("iosfwd"));

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

static int countSymbols(Lang Language) {
   llvm::DenseSet<llvm::StringRef> Set;
 #define SYMBOL(Name, NS, Header) Set.insert(#NS #Name);
   switch (Language) {
   case Lang::C:
 #include "CSymbolMap.inc"
     break;
   case Lang::CXX:
 #include "StdSymbolMap.inc"
+#include "StdSpecialSymbolMap.inc"
     break;
   }
 #undef SYMBOL
   return Set.size();
 }
 
 static int initialize(Lang Language) {
   SymbolHeaderMapping *Mapping = new SymbolHeaderMapping();
static int initialize(Lang Language) {
   };
 #define SYMBOL(Name, NS, Header) Add(#NS #Name, strlen(#NS), #Header);
   switch (Language) {
   case Lang::C:
 #include "CSymbolMap.inc"
     break;
   case Lang::CXX:
 #include "StdSymbolMap.inc"
+#include "StdSpecialSymbolMap.inc"
     break;
   }
 #undef SYMBOL
 
   Mapping->HeaderNames = new llvm::StringRef[Mapping->HeaderIDs->size()];
   for (const auto &E : *Mapping->HeaderIDs)
     Mapping->HeaderNames[E.second] = E.first;
 

clang/unittests/Tooling/StandardLibraryTest.cpp

TEST(StdlibTest, All) {
 
   EXPECT_EQ(Vector->header(), *VectorH);
   EXPECT_THAT(Vector->headers(), ElementsAre(*VectorH));
 
   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>"),
+                          stdlib::Header::named("<cwchar>"),
+                          stdlib::Header::named("<cuchar>"),
+                          stdlib::Header::named("<ctime>"),
+                          stdlib::Header::named("<cstdio>")));
+  EXPECT_EQ(stdlib::Symbol::named("std::", "size_t")->header(),
+            stdlib::Header::named("<cstddef>"));
 
   EXPECT_THAT(stdlib::Header::all(), Contains(*VectorH));
   EXPECT_THAT(stdlib::Symbol::all(), Contains(*Vector));
   EXPECT_TRUE(stdlib::Header::named("<stdint.h>", stdlib::Lang::CXX));
   EXPECT_FALSE(stdlib::Header::named("<ios646.h>", stdlib::Lang::CXX));
 }
 
 TEST(StdlibTest, CCompat) {