[include-mapping] Implement language separation in stdlib recognizer library

[VitaNuo]

Remove comments.

[VitaNuo]

Minor improvements.

[hokein]

Can you add some tests in StandardLibraryTest.cpp?

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

30

using a map here seems like an overkill, we have just 2 elements, I'd just use two separate variables (CMapping, and CXXMapping)

123

nit: just for (Lang Language: {Lang::C, Lang::CXX}) or two statements initilize(Lang::C); and initialize(Lang::CXX);.

212

Do we need the ensureInitialized() here? looks like no needed, we have called it in the Recognizer constructor,

233

nit: just use LangOpts.CPlusPlus to check the language.

[VitaNuo]

Address review comments.

[VitaNuo]

Thanks for the comments!

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

30

what about the design idea that we might potentially want to extend this to multiple standards etc.? The idea is that it's extensible to ObjC, OpenCL... and so on and so forth, as has been discussed offline.

123

yes, same argument as above. I remember extensive discussions about the idea that we might want to extend this to multiple language versions etc. in the future.

212

you're right, not needed.

233

There's LangStandard::isCPlusPlus method that I've just discovered. That's probably even better.

[VitaNuo]

Add a couple more test cases to StandardLibraryTest.cpp.

[VitaNuo]

Added a couple of test cases.

[hokein]

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

30

I think having a generic Lang enum structure is sufficient for the future extension, and I don't think we're going to add other languages in the foreseeable future (that's why I value the simple implementation at the beginning).

But you're right, getting the implementation right is probably a good idea. I'd like to remove the DenseMap, just use a raw array, something like below should work

enum Lang {
   C = 0,
   CXX,

   LastValue = CXX,
};

// access by e.g. LanguageMappings[static_cast<unsigned>(Lang::C)].
static SymbolHeaderMapping* LanguageMappings[static_cast<unsigned>(Lang::LastValue) + 1];

233

sorry if I was not clearer -- there is a bit CPlusPlus in the LangOptions which already does the equivalent thing (see https://github.com/llvm/llvm-project/blob/main/clang/lib/Basic/LangOptions.cpp#L107).

So we can just use if (D->getLangOpts().CPlusPlus).

clang/unittests/Tooling/StandardLibraryTest.cpp

138

nit: just EXPECT_FALSE(stdlib::Symbol::named("", "int16_t"))), following the existing pattern L46.

145

The existing TEST(StdlibTest, All) test seems like a good umbrella for the this test and the above test, how about moving them to the All test?

[VitaNuo]

Address review comments.

[VitaNuo]

Remove extra include.

[VitaNuo]

Thanks for the comments!

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

30

Ok, this will need some casting, but I don't have a strong opinion.

233

Ah ok, thanks.

clang/unittests/Tooling/StandardLibraryTest.cpp

138

Right, thanks.

145

Ok, I've moved everything to existing test cases.

[hokein]

Thanks, this looks good to me!

This requires some work to rebase for https://github.com/llvm/llvm-project/commit/e1aaa314a46cd303019da117bfd330611d5b7a84, I will rebase it and land it for you.

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

30

yeah, it is the sad bit, but I think it is OK.

[hokein]

rebase to main

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

 namespace clang {
 class Decl;
 class NamespaceDecl;
 class DeclContext;
 namespace tooling {
 namespace stdlib {
 
 class Symbol;
+enum class Lang { C = 0, CXX, LastValue = CXX };
 
 // A standard library header, such as <iostream>
 // Lightweight class, in fact just an index into a table.
 // C++ and C Library compatibility headers are considered different: e.g.
 // "<cstdio>" and "<stdio.h>" (and their symbols) are treated differently.
 class Header {
 public:
-  static std::vector<Header> all();
+  static std::vector<Header> all(Lang L = Lang::CXX);
   // Name should contain the angle brackets, e.g. "<vector>".
-  static std::optional<Header> named(llvm::StringRef Name);
+  static std::optional<Header> named(llvm::StringRef Name,
+                                     Lang Language = Lang::CXX);
 
   friend llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Header &H) {
     return OS << H.name();
   }
   llvm::StringRef name() const;
 
 private:
-  Header(unsigned ID) : ID(ID) {}
+  Header(unsigned ID, Lang Language) : ID(ID), Language(Language) {}
   unsigned ID;
+  Lang Language;
+
   friend Symbol;
   friend llvm::DenseMapInfo<Header>;
   friend bool operator==(const Header &L, const Header &R) {
     return L.ID == R.ID;
   }
 };
 
 // A top-level standard library symbol, such as std::vector
 // Lightweight class, in fact just an index into a table.
 // C++ and C Standard Library symbols are considered distinct: e.g. std::printf
 // and ::printf are not treated as the same symbol.
 // The symbols do not contain macros right now, we don't have a reliable index
 // for them.
 class Symbol {
 public:
-  static std::vector<Symbol> all();
+  static std::vector<Symbol> all(Lang L = Lang::CXX);
   /// \p Scope should have the trailing "::", for example:
   /// named("std::chrono::", "system_clock")
-  static std::optional<Symbol> named(llvm::StringRef Scope,
-                                      llvm::StringRef Name);
+  static std::optional<Symbol>
+  named(llvm::StringRef Scope, llvm::StringRef Name, Lang Language = Lang::CXX);
 
   friend llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Symbol &S) {
     return OS << S.qualified_name();
   }
   llvm::StringRef scope() const;
   llvm::StringRef name() const;
   llvm::StringRef qualified_name() const;
   // The preferred header for this symbol (e.g. the suggested insertion).
   Header header() const;
   // Some symbols may be provided by multiple headers.
   llvm::SmallVector<Header> headers() const;
 
 private:
-  Symbol(unsigned ID) : ID(ID) {}
+  Symbol(unsigned ID, Lang Language) : ID(ID), Language(Language) {}
   unsigned ID;
+  Lang Language;
+
   friend class Recognizer;
   friend llvm::DenseMapInfo<Symbol>;
   friend bool operator==(const Symbol &L, const Symbol &R) {
     return L.ID == R.ID;
   }
 };
 
 // A functor to find the stdlib::Symbol associated with a decl.

 } // namespace stdlib
 } // namespace tooling
 } // namespace clang
 
 namespace llvm {
 
 template <> struct DenseMapInfo<clang::tooling::stdlib::Header> {
   static inline clang::tooling::stdlib::Header getEmptyKey() {
-    return clang::tooling::stdlib::Header(-1);
+    return clang::tooling::stdlib::Header(-1,
+                                          clang::tooling::stdlib::Lang::CXX);
   }
   static inline clang::tooling::stdlib::Header getTombstoneKey() {
-    return clang::tooling::stdlib::Header(-2);
+    return clang::tooling::stdlib::Header(-2,
+                                          clang::tooling::stdlib::Lang::CXX);
   }
   static unsigned getHashValue(const clang::tooling::stdlib::Header &H) {
     return hash_value(H.ID);
   }
   static bool isEqual(const clang::tooling::stdlib::Header &LHS,
                       const clang::tooling::stdlib::Header &RHS) {
     return LHS == RHS;
   }
 };
 
 template <> struct DenseMapInfo<clang::tooling::stdlib::Symbol> {
   static inline clang::tooling::stdlib::Symbol getEmptyKey() {
-    return clang::tooling::stdlib::Symbol(-1);
+    return clang::tooling::stdlib::Symbol(-1,
+                                          clang::tooling::stdlib::Lang::CXX);
   }
   static inline clang::tooling::stdlib::Symbol getTombstoneKey() {
-    return clang::tooling::stdlib::Symbol(-2);
+    return clang::tooling::stdlib::Symbol(-2,
+                                          clang::tooling::stdlib::Lang::CXX);
   }
   static unsigned getHashValue(const clang::tooling::stdlib::Symbol &S) {
     return hash_value(S.ID);
   }
   static bool isEqual(const clang::tooling::stdlib::Symbol &LHS,
                       const clang::tooling::stdlib::Symbol &RHS) {
     return LHS == RHS;
   }
 };
 } // namespace llvm
 
 #endif // LLVM_CLANG_TOOLING_INCLUSIONS_STANDARDLIBRARY_H

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/StringRef.h"
 #include "llvm/Support/Casting.h"
 
 namespace clang {
 namespace tooling {
 namespace stdlib {
 
-// Header::ID => header name
-static llvm::StringRef *HeaderNames;
+namespace {
+// Symbol name -> Symbol::ID, within a namespace.
+using NSSymbolMap = llvm::DenseMap<llvm::StringRef, unsigned>;
+
+// A Mapping per language.
+struct SymbolHeaderMapping {
+  llvm::StringRef *HeaderNames = nullptr;
   // Header name => Header::ID
-static llvm::DenseMap<llvm::StringRef, unsigned> *HeaderIDs;
+  llvm::DenseMap<llvm::StringRef, unsigned> *HeaderIDs;
 
-static unsigned SymbolCount = 0;
+  unsigned SymbolCount = 0;
   // Symbol::ID => symbol qualified_name/name/scope
-static struct SymbolName {
+  struct SymbolName {
     const char *Data;  // std::vector
     unsigned ScopeLen; // ~~~~~
     unsigned NameLen;  //      ~~~~~~
-} *SymbolNames;
+  } *SymbolNames = nullptr;
   // Symbol name -> Symbol::ID, within a namespace.
-using NSSymbolMap = llvm::DenseMap<llvm::StringRef, unsigned>;
-static llvm::DenseMap<llvm::StringRef, NSSymbolMap *> *NamespaceSymbols;
+  llvm::DenseMap<llvm::StringRef, NSSymbolMap *> *NamespaceSymbols = nullptr;
   // Symbol::ID => Header::ID
-static unsigned *SymbolHeaderIDs;
+  unsigned *SymbolHeaderIDs = nullptr;
+};
+} // namespace
+static SymbolHeaderMapping
+    *LanguageMappings[static_cast<unsigned>(Lang::LastValue) + 1];
+static const SymbolHeaderMapping *getMappingPerLang(Lang L) {
+  return LanguageMappings[static_cast<unsigned>(L)];
+}
 
-static int initialize() {
-  SymbolCount = 0;
-#define SYMBOL(Name, NS, Header) ++SymbolCount;
+static int countSymbols(Lang Language) {
+  unsigned SymCount = 0;
+#define SYMBOL(Name, NS, Header) ++SymCount;
+  switch (Language) {
+  case Lang::C:
 #include "clang/Tooling/Inclusions/CSymbolMap.inc"
+    break;
+  case Lang::CXX:
 #include "clang/Tooling/Inclusions/StdSymbolMap.inc"
+    break;
+  }
 #undef SYMBOL
-  SymbolNames =
-      new std::remove_reference_t<decltype(*SymbolNames)>[SymbolCount];
-  SymbolHeaderIDs =
-      new std::remove_reference_t<decltype(*SymbolHeaderIDs)>[SymbolCount];
-  NamespaceSymbols = new std::remove_reference_t<decltype(*NamespaceSymbols)>;
-  HeaderIDs = new std::remove_reference_t<decltype(*HeaderIDs)>;
+  return SymCount;
+}
 
+static int initialize(Lang Language) {
+  SymbolHeaderMapping *Mapping = new SymbolHeaderMapping();
+  LanguageMappings[static_cast<unsigned>(Language)] = Mapping;
+
+  unsigned SymCount = countSymbols(Language);
+  Mapping->SymbolCount = SymCount;
+  Mapping->SymbolNames =
+      new std::remove_reference_t<decltype(*Mapping->SymbolNames)>[SymCount];
+  Mapping->SymbolHeaderIDs = new std::remove_reference_t<
+      decltype(*Mapping->SymbolHeaderIDs)>[SymCount];
+  Mapping->NamespaceSymbols =
+      new std::remove_reference_t<decltype(*Mapping->NamespaceSymbols)>;
+  Mapping->HeaderIDs =
+      new std::remove_reference_t<decltype(*Mapping->HeaderIDs)>;
   auto AddNS = [&](llvm::StringRef NS) -> NSSymbolMap & {
-    auto R = NamespaceSymbols->try_emplace(NS, nullptr);
+    auto R = Mapping->NamespaceSymbols->try_emplace(NS, nullptr);
     if (R.second)
       R.first->second = new NSSymbolMap();
     return *R.first->second;
   };
 
   auto AddHeader = [&](llvm::StringRef Header) -> unsigned {
-    return HeaderIDs->try_emplace(Header, HeaderIDs->size()).first->second;
+    return Mapping->HeaderIDs->try_emplace(Header, Mapping->HeaderIDs->size())
+        .first->second;
   };
 
   auto Add = [&, SymIndex(0)](llvm::StringRef QName, unsigned NSLen,
                               llvm::StringRef HeaderName) mutable {
     // Correct "Nonefoo" => foo.
     // FIXME: get rid of "None" from the generated mapping files.
     if (QName.take_front(NSLen) == "None") {
       QName = QName.drop_front(NSLen);
       NSLen = 0;
     }
 
-    SymbolNames[SymIndex] = {QName.data(), NSLen,
-                             static_cast<unsigned int>(QName.size() - NSLen)};
-    SymbolHeaderIDs[SymIndex] = AddHeader(HeaderName);
+    Mapping->SymbolNames[SymIndex] = {
+        QName.data(), NSLen, static_cast<unsigned int>(QName.size() - NSLen)};
+    Mapping->SymbolHeaderIDs[SymIndex] = AddHeader(HeaderName);
 
     NSSymbolMap &NSSymbols = AddNS(QName.take_front(NSLen));
     NSSymbols.try_emplace(QName.drop_front(NSLen), SymIndex);
 
     ++SymIndex;
   };
 #define SYMBOL(Name, NS, Header) Add(#NS #Name, strlen(#NS), #Header);
+  switch (Language) {
+  case Lang::C:
 #include "clang/Tooling/Inclusions/CSymbolMap.inc"
+    break;
+  case Lang::CXX:
 #include "clang/Tooling/Inclusions/StdSymbolMap.inc"
+    break;
+  }
 #undef SYMBOL
 
-  HeaderNames = new llvm::StringRef[HeaderIDs->size()];
-  for (const auto &E : *HeaderIDs)
-    HeaderNames[E.second] = E.first;
+  Mapping->HeaderNames = new llvm::StringRef[Mapping->HeaderIDs->size()];
+  for (const auto &E : *Mapping->HeaderIDs)
+    Mapping->HeaderNames[E.second] = E.first;
 
   return 0;
 }
 
 static void ensureInitialized() {
-  static int Dummy = initialize();
+  static int Dummy = []() {
+    for (unsigned L = 0; L <= static_cast<unsigned>(Lang::LastValue); ++L)
+      initialize(static_cast<Lang>(L));
+    return 0;
+  }();
   (void)Dummy;
 }
 
-std::vector<Header> Header::all() {
+std::vector<Header> Header::all(Lang L) {
   ensureInitialized();
   std::vector<Header> Result;
-  Result.reserve(HeaderIDs->size());
-  for (unsigned I = 0, E = HeaderIDs->size(); I < E; ++I)
-    Result.push_back(Header(I));
+  const auto *Mapping = getMappingPerLang(L);
+  Result.reserve(Mapping->HeaderIDs->size());
+  for (unsigned I = 0, E = Mapping->HeaderIDs->size(); I < E; ++I)
+    Result.push_back(Header(I, L));
   return Result;
 }
-std::optional<Header> Header::named(llvm::StringRef Name) {
+std::optional<Header> Header::named(llvm::StringRef Name, Lang L) {
   ensureInitialized();
-  auto It = HeaderIDs->find(Name);
-  if (It == HeaderIDs->end())
+  const auto *Mapping = getMappingPerLang(L);
+  auto It = Mapping->HeaderIDs->find(Name);
+  if (It == Mapping->HeaderIDs->end())
     return std::nullopt;
-  return Header(It->second);
+  return Header(It->second, L);
+}
+llvm::StringRef Header::name() const {
+  return getMappingPerLang(Language)->HeaderNames[ID];
 }
-llvm::StringRef Header::name() const { return HeaderNames[ID]; }
 
-std::vector<Symbol> Symbol::all() {
+std::vector<Symbol> Symbol::all(Lang L) {
   ensureInitialized();
   std::vector<Symbol> Result;
-  Result.reserve(SymbolCount);
-  for (unsigned I = 0, E = SymbolCount; I < E; ++I)
-    Result.push_back(Symbol(I));
+  const auto *Mapping = getMappingPerLang(L);
+  Result.reserve(Mapping->SymbolCount);
+  for (unsigned I = 0, E = Mapping->SymbolCount; I < E; ++I)
+    Result.push_back(Symbol(I, L));
   return Result;
 }
 llvm::StringRef Symbol::scope() const {
-  SymbolName &S = SymbolNames[ID];
+  auto &S = getMappingPerLang(Language)->SymbolNames[ID];
   return StringRef(S.Data, S.ScopeLen);
 }
 llvm::StringRef Symbol::name() const {
-  SymbolName &S = SymbolNames[ID];
+  auto &S = getMappingPerLang(Language)->SymbolNames[ID];
   return StringRef(S.Data + S.ScopeLen, S.NameLen);
 }
 llvm::StringRef Symbol::qualified_name() const {
-  SymbolName &S = SymbolNames[ID];
+  auto &S = getMappingPerLang(Language)->SymbolNames[ID];
   return StringRef(S.Data, S.ScopeLen + S.NameLen);
 }
-std::optional<Symbol> Symbol::named(llvm::StringRef Scope,
-                                     llvm::StringRef Name) {
+std::optional<Symbol> Symbol::named(llvm::StringRef Scope, llvm::StringRef Name,
+                                    Lang L) {
   ensureInitialized();
-  if (NSSymbolMap *NSSymbols = NamespaceSymbols->lookup(Scope)) {
+
+  if (NSSymbolMap *NSSymbols =
+          getMappingPerLang(L)->NamespaceSymbols->lookup(Scope)) {
     auto It = NSSymbols->find(Name);
     if (It != NSSymbols->end())
-      return Symbol(It->second);
+      return Symbol(It->second, L);
   }
   return std::nullopt;
 }
-Header Symbol::header() const { return Header(SymbolHeaderIDs[ID]); }
+Header Symbol::header() const {
+  return Header(getMappingPerLang(Language)->SymbolHeaderIDs[ID], Language);
+}
 llvm::SmallVector<Header> Symbol::headers() const {
   return {header()}; // FIXME: multiple in case of ambiguity
 }
 
 Recognizer::Recognizer() { ensureInitialized(); }
 
 NSSymbolMap *Recognizer::namespaceSymbols(const NamespaceDecl *D) {
+  if (!D)
+    return nullptr;
+  Lang Language;
+  if (D->getLangOpts().CPlusPlus)
+    Language = Lang::CXX;
+  else if (D->getLangOpts().C11)
+    Language = Lang::C;
+  else
+    return nullptr;
+
   auto It = NamespaceCache.find(D);
   if (It != NamespaceCache.end())
     return It->second;
 
   NSSymbolMap *Result = [&]() -> NSSymbolMap * {
-    if (D && D->isAnonymousNamespace())
+    if (D->isAnonymousNamespace())
       return nullptr;
     // Print the namespace and its parents ommitting inline scopes.
     std::string Scope;
     for (const auto *ND = D; ND;
          ND = llvm::dyn_cast_or_null<NamespaceDecl>(ND->getParent()))
       if (!ND->isInlineNamespace() && !ND->isAnonymousNamespace())
         Scope = ND->getName().str() + "::" + Scope;
-    return NamespaceSymbols->lookup(Scope);
+    return getMappingPerLang(Language)->NamespaceSymbols->lookup(Scope);
   }();
   NamespaceCache.try_emplace(D, Result);
   return Result;
 }
 
 std::optional<Symbol> Recognizer::operator()(const Decl *D) {
   // If D is std::vector::iterator, `vector` is the outer symbol to look up.
   // We keep all the candidate DCs as some may turn out to be anon enums.
   // Do this resolution lazily as we may turn out not to have a std namespace.
   llvm::SmallVector<const DeclContext *> IntermediateDecl;
   const DeclContext *DC = D->getDeclContext();
   while (DC && !DC->isNamespace()) {
     if (NamedDecl::classofKind(DC->getDeclKind()))
       IntermediateDecl.push_back(DC);
     DC = DC->getParent();
   }
   NSSymbolMap *Symbols = namespaceSymbols(cast_or_null<NamespaceDecl>(DC));
   if (!Symbols)
     return std::nullopt;
 
llvm::StringRef Name = [&]() -> llvm::StringRef {
     return "";
   }();
   if (Name.empty())
     return std::nullopt;
 
   auto It = Symbols->find(Name);
   if (It == Symbols->end())
     return std::nullopt;
-  return Symbol(It->second);
+  return Symbol(It->second, D->getLangOpts().CPlusPlus? Lang::CXX : Lang::C);
 }
 
 } // namespace stdlib
 } // namespace tooling
 } // namespace clang

clang/unittests/Tooling/StandardLibraryTest.cpp

 
 TEST(StdlibTest, All) {
   auto VectorH = stdlib::Header::named("<vector>");
   EXPECT_TRUE(VectorH);
   EXPECT_EQ(VectorH->name(), "<vector>");
   EXPECT_EQ(llvm::to_string(*VectorH), "<vector>");
   EXPECT_FALSE(stdlib::Header::named("HeadersTests.cpp"));
 
+  EXPECT_TRUE(stdlib::Header::named("<vector>", stdlib::Lang::CXX));
+  EXPECT_FALSE(stdlib::Header::named("<vector>", stdlib::Lang::C));
+
   auto Vector = stdlib::Symbol::named("std::", "vector");
   EXPECT_TRUE(Vector);
   EXPECT_EQ(Vector->scope(), "std::");
   EXPECT_EQ(Vector->name(), "vector");
   EXPECT_EQ(Vector->qualified_name(), "std::vector");
   EXPECT_EQ(llvm::to_string(*Vector), "std::vector");
   EXPECT_FALSE(stdlib::Symbol::named("std::", "dongle"));
   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_THAT(stdlib::Header::all(), Contains(*VectorH));
   EXPECT_THAT(stdlib::Symbol::all(), Contains(*Vector));
+  EXPECT_FALSE(stdlib::Header::named("<stdint.h>"));
+  EXPECT_FALSE(stdlib::Header::named("<stdint.h>", stdlib::Lang::CXX));
+  EXPECT_TRUE(stdlib::Header::named("<stdint.h>", stdlib::Lang::C));
+
+  EXPECT_FALSE(stdlib::Symbol::named("", "int16_t"));
+  EXPECT_FALSE(stdlib::Symbol::named("", "int16_t", stdlib::Lang::CXX));
+  EXPECT_TRUE(stdlib::Symbol::named("", "int16_t", stdlib::Lang::C));
 }
 
 TEST(StdlibTest, Recognizer) {
   TestAST AST(R"cpp(
     namespace std {
     inline namespace inl {
 
     template <typename>
TEST(StdlibTest, Recognizer) {
   auto *Sec = cast<VarDecl>(lookup(AST, "sec")).getType()->getAsCXXRecordDecl();
   auto *CDivT =
       cast<VarDecl>(lookup(AST, "div")).getType()->getAsCXXRecordDecl();
 
   stdlib::Recognizer Recognizer;
 
   EXPECT_EQ(Recognizer(&VectorNonstd), std::nullopt);
   EXPECT_EQ(Recognizer(Vec), stdlib::Symbol::named("std::", "vector"));
+  EXPECT_EQ(Recognizer(Vec),
+            stdlib::Symbol::named("std::", "vector", stdlib::Lang::CXX));
   EXPECT_EQ(Recognizer(Nest), stdlib::Symbol::named("std::", "vector"));
   EXPECT_EQ(Recognizer(Clock),
             stdlib::Symbol::named("std::chrono::", "system_clock"));
   EXPECT_EQ(Recognizer(CDivT), stdlib::Symbol::named("", "div_t"));
+  EXPECT_EQ(Recognizer(CDivT),
+            stdlib::Symbol::named("", "div_t", stdlib::Lang::C));
   EXPECT_EQ(Recognizer(Sec), std::nullopt);
 }
 
 } // namespace
 } // namespace tooling
 } // namespace clang