[clangd] Add provider info on symbol hover.

[VitaNuo]

Replace start with arrow for optional access.

[hokein]

Thanks, left a few comments on the implementation.

clang-tools-extra/clangd/Hover.cpp

1094

I'm not sure how we can do it. https://reviews.llvm.org/D143496 doesn't expose collectMacroReferences function, so we still duplicate this hacky implementations in two places, which is probably fine at the moment.

I think this will be fixed when we unify them with clangd's CollectMainFileMacros.

1096

On a second thought, I think we might not really need it. We handle the macro vs non-macro cases separately, and we only care about the symbol reference under the cursor.
so we can simply the implementation:

1. For macro case, we already have the located macro and Tok in the call site (on line1231), we can just construct a single include_cleaner::SymbolReference from them, and pass a single-element Macros and empty ASTRoots to the walkUsed API.

2. For non-macro case, we can just pass an empty macro references to walkUsed as we already know the symbol under the hover is not a macro.

1126

no need to do the isWrittenInMainFile check in the callback, the walkUsed implementation already does it.

1131

I don't get it, why variable names are non-explicit references?

1143

We're using the location as a heuristic to join the symbol (Decl) from two difference sources (clangd's hover impl, and include-cleaner lib impl)

This heuristics works most of time, but it will fail in the case where the symbol under the hover is a UsingDecl

// absl_string_view.h
namespace absl {
using std::string_view;
}

// main.cpp
#includle "absl_string_view.h"
absl::str^ing_view abc; // hover on string_view

• clangd's hover uses the underlying decl (std::string_view), see the pickDeclToUse function for details;
• include-cleaner lib reports the using decl (asbl::string_view);

As a result, we will show the #include of the using decl for the underlying decl in the hover card.

To solve the issue, I think we need to check the equality of Decl from hover and Decl from SymbolReference (comparing both getCanonicalDecl should be enough).

1156

We probably don't need to handle this main-file case specially, in practice, main-file is hardly included in the MainFileIncludes, so the following logic will filter the main-file as well.

1166

checking the spelled string can cause subtle behavior & bugs. A robust way is to use the include_cleaner::Includes.match API to determine a header is used or not (this is similar to what you did in https://reviews.llvm.org/D143496, we need to expose the transformation function convertIncludes)

1175

nit: I'd suggest adding a break even though it is the last case.

1184

I wonder whether we need to deduplicate the DirectlyIncludedProviders, reading the code, it might be possible that we add duplicated headers, but in practice, we should only have a single Ref reported, so the deduplication is probably not needed.

1184

nit: no need to check HI, it is always non-null as it is set by the above line.

1224

any reason add a null check here, the HI should always be non-null becase we have set it on Line1263.

1299

Is the code position intended? It looks like we're inserting the Provided by XXX text in the middle of the function return type and the function parameters, which seems weird to me. I think the function return type and parameters should group together.

Depending on the final UI, I think moving it before the ReturnType (right after the header) seems better than the current one.

1304

just use llvm::join(*ProviderInfo, ", ");

clang-tools-extra/clangd/Hover.h

72

I think we can get rid of the std::optional we can distinguish by checking the ProviderInfo.empty().

Since we have 1 header for most cases, let use llvm::SmallVector.

We can store the Inclusion* as the container element, and convert to string during the present() call.

[VitaNuo]

Implement the most recent version from the design document: always show a single provider, whether directly included or not (as long as there is a provider). Address review comments.

[VitaNuo]

Thank you for the comments! I've implemented the new version as per the design doc, as well as did my best to address the review comments.

clang-tools-extra/clangd/Hover.cpp

1096

This sounds like a great idea. Doing this now, thank you.

1131

I made a mistake in the wording, sorry. I meant something like this:

std::string Hello = ◊"Hello";

and wanted to prevent that hover over the string literal "Hello" shows provided by <string>.

In the current implementation, however, this is not the case even without the explicit check for reference type.

1143

Interesting case. I've tried it out, you're right indeed. And it seems like there's no way to pick the standard library header as provider, since include-cleaner doesn't report it (the absl header is the only candidate).

I guess we'll skip providing the header info in this case then.

1156

I believe we do need it. Otherwise, if you declare/define a new type in the main file (let's say main.cpp) and later use this type, you'd get provided by main.cpp in the hover, which seems pointless IMO.

1166

Using the convertIncludes function now for to find the best included provider.

1175

This is gone now.

1184

Since we have decided that we always report one header, no de-duplication necessary anymore :)

1224

sorry, probably some debugging artefact.

1299

No, was not intended. We seem to have agreed to put it in the header section, so this should be the case now.

1304

No need to join anything anymore, since we're showing a single header :)

clang-tools-extra/clangd/Hover.h

72

Ok, now since we have 1 header in all cases, there's definitely no need for std::optional. Let's just store a string and check that it's not empty before rendering.

[VitaNuo]

Rebase to main.

[hokein]

clang-tools-extra/clangd/Hover.cpp

1099

It seems that the walkUsed API might be not the best fit. walkUsed API has some special logic on handling different AST nodes, e.g. refs of operators are ignored, so if we hover on an operator ref, we will not show the providing header (which we should).

Our goal is to provide the information (header) where the symbol under the hover comes from (ref satisfaction is out of the scope). I think include_cleaner::headersForSymbol is a better fit for our purpose, and the implementation is simpler:

• on hover, we have the selected symbol (either a regular declaration or a macro)
• it is easy to construct a include_cleaner::Symbol from the selected symbol
• choose the first result from headersForSymbol

To do that we need to expose headersForSymbol from the internal AnalysisInternal.h.

[VitaNuo]

Re-work the patch to use include_cleaner::headersForSymbol.

[VitaNuo]

Thanks for the comments!

clang-tools-extra/clangd/Hover.cpp

1099

Thank you! I am using headersForSymbols now.

Ref satisfaction is not entirely out of scope.
If the provider is included, we would like to show this provider in the hover card, irrespective of the ranking.

If the provider is not included, we show the best provider from the whole list of possible providers.

The behavior is different, based on ref satisfaction.
Because of that, the implementation is actually not that much shorter than the version with walkUsed.

However, you're right that it solves the issue with operators (wasn't aware of that, thanks!). I've added a test case for the hover on operators.

As an additional bonus, it also solves the issue with using decls as discussed in a different comment thread below. We can now say Provided by <string_view> in the hover card that pops up for the absl::string_view references because we are doing the analysis on the std::string_view decl.

1143

We're using the location as a heuristic to join the symbol (Decl) from two difference sources (clangd's hover impl, and include-cleaner lib impl)

This heuristics works most of time, but it will fail in the case where the symbol under the hover is a UsingDecl

// absl_string_view.h
namespace absl {
using std::string_view;
}

// main.cpp
#includle "absl_string_view.h"
absl::str^ing_view abc; // hover on string_view

• clangd's hover uses the underlying decl (std::string_view), see the pickDeclToUse function for details;
• include-cleaner lib reports the using decl (asbl::string_view);

As a result, we will show the #include of the using decl for the underlying decl in the hover card.

To solve the issue, I think we need to check the equality of Decl from hover and Decl from SymbolReference (comparing both getCanonicalDecl should be enough).

[hokein]

clang-tools-extra/clangd/Hover.cpp

1094

we can simplify the signature like (ParsedAST&, include_cleaner::Symbol&, HoverInfo&), constructing a Symbol in call site is trivial, and it can help simplify the implementation (no sanity check for two std::optional etc).

1099

Ref satisfaction is not entirely out of scope.

If the provider is included, we would like to show this provider in the hover card, irrespective of the ranking.

Ah, right, I missed this point.

Because of that, the implementation is actually not that much shorter than the version with walkUsed.

I think the implementation is still simpler, we don't need to non-trivial thing like comparing ref range with the selected range, and ref symbol declaration vs the selected symbol etc.

1138

MainFile provider is a special case (I don't recall the details).

IIUC, the model is:

1. a symbol usage that is satisfied (e.g. any of its providers that are directly included in the main file), we show the one with highest rank of these included providers
2. a symbol usage that is not satisfied (we choose the highest rank of all providers)
3. If the provider is the main-file, we don't show it in the hover card.

Based on 1), if the main-file provider is the highest, we will not show it in the hover based on 3). However, the current implementation doesn't match this behavior

• on L1123 ConvertedIncludes.match(H) is always false if H is a main-file, and we will choose a lower-rank provider if the main-file is the first element of Headers
• the logic here doesn't seem to work, we should do a break on L1139 rather than continue, which means we always use the Headers[0] element.

Not sure we have discussed 3), one alternative is to show the information for main-file provider as well, it seems fine to me that the hover shows provided by the current file text (not the full path).

[VitaNuo]

Address the review comments.

[VitaNuo]

thanks for the review!

clang-tools-extra/clangd/Hover.cpp

1094

thanks, that's right.

1099

I think the implementation is still simpler, we don't need to non-trivial thing like comparing ref range with the selected range, and ref symbol declaration vs the selected symbol etc.

Totally, I agree.

1138

we should do a break on L1139 rather than continue

Ok. I'm not sure if this is of great practical importance (what are the chances that the main file is the first provider, and there are more providers for the same symbol?),
but you're right that we shouldn't show the lower-ranked provider for this case.

one alternative is to show the information for main-file provider as well

Yeah, this is possible ofc, but I'm not sure what the use would be. The general intention of this feature (or feature set, even) is to help users eliminate unnecessary dependencies, and they can hardly get rid of the main file :)
So of the two options, I'd rather opt for not showing anything at all.

[hokein]

Thanks, left some comments on the unittest, I think we can make it simpler.

clang-tools-extra/clangd/Hover.cpp

1107

The position of this comment is a bit confusing:

• Headers is sorted by the ranking
• Matches the result returned by ConvertedIncludes.match is not sorted.

The comment here reads like the Matches is sorted! I think it is better to move it to the outer for-loop. The first element of Headers which satisfies !Matches.empty() is the best-ranked provider.

1118

now the for-range loop doesn't seem necessary, we could always use the Headers.front(), right?

1138

I'm not sure if this is of great practical importance

I think the code should match our mental model, otherwise it is hard to reason about whether the actual behavior is expected or a bug.

(what are the chances that the main file is the first provider, and there are more providers for the same symbol?),

I think the pattern is not rare (especially for headers), think of the case below.

#include "other.h" // other.h transitively includes the `foo.h`

class Foo;
const Foo& createFoo();

although the main-file provider is not the top1 given the current ranking implementation, we have a plan to address it, see the FIXME in https://github.com/llvm/llvm-project/blob/main/clang-tools-extra/include-cleaner/lib/FindHeaders.cpp#L219. After addressing the FIXME, the main-file could be the top1.

on L1123 ConvertedIncludes.match(H) is always false if H is a main-file, and we will choose a lower-rank provider if the main-file is the first element of Headers

This comment doesn't seem to be addressed, now it is L1105.

Given the following case, if the returned providers is [main-file, foo.h],
the current code will show foo.h in hover.
However, based on our mental model:

1. the main-file is one of the Foo providers, and it is the top1, we choose it
2. we don't show main-file provider in hover

-> we should not show any information in hover.

#include "foo.h"

class Foo;
Foo* b;  // hover on `Foo`.

1227

I wonder how well it works for the NamespaceDecl. NamespaceDecl is usually declared in many files, we will basically show a random provider in hover. We're not interested in NamesapceDecl, we probably need to ignore it.

No action required here, but this is something we should bear in mind.

clang-tools-extra/clangd/IncludeCleaner.cpp

291

let's keep it unchanged, we don't need any change for this function in this patch.

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

2897

I have some trouble following the test here:

• this is a long list of testcases (see my other comments)
• we construct each testcase with five fields, it is hard to track which content is for foo.h/bar.h/foobar.h

I'd suggest to find way to simplify it, some ideas

• we can use a fixed content foo.h, foo_fwd.h for all testcases (I guess something like below should be enough to cover the major cases), so that we don't need to specify all these content in every testcase.
• only test critical cases 1) symbol ref is satisfied (by the main-file provider or by regular headers) 2) symbol ref is not satisfied, verify we show first provider of Providers. And test 3 different symbol kinds (regular decl, macro, operator)

// foo.h
#define FOO 1
class Foo {};
Foo& operator+(const Foo, const Foo);

// foo_fwd.h
class Foo;

// all.h
#include "foo.h"
#include "foo_fwd.h"

2901

we can git rid of the int foo() content in foo.h since this test only tests symbol refs that is satisfied by the main file.

2914

I guest this test is testing we chose a right ranking header, but it is hard to see why foo.h is better than bar.h, since both foo.h and bar.h content are identical, it is becase foo.h is better matching the symbol name (to make it more obvious, we could make foo.h contains a definition, or add a comment explaining it).

2922

unclear to me the intention of this testcase.

2948

this case seems to be duplicated with the first one, can be removed, I think.

3008

This will have macro-redefined warnings, foo.h is better than bar.h because the MACRO in main-file refers to the one defined in foo.h. Not sure the value of this testcase, I would suggest dropping it for simplicity.

The same for the below one.

3023

this seems to be duplicated with the first testcase, nothing related to macro, can be dropped as well.

3052

I'd just drop the IWYU-related test, since this patch has nothing to do with IWYU (we have the IWYU-specific tests in include-cleaner unittest).

3123

What's the difference between HIFoo and HIFooBar? Looks like they are the same.

I guess you want to check the <> and "" cases?

3139

I think we can simplify this test and merge it to the above TEST(Hover, Providers).

Just verifying the hover symbol respects the using decl is sufficient, something like

#include "foo.h"

namespace ns {
using ::Foo;
}

ns::F^oo d; // verify that provider in hover is the main-file.

[VitaNuo]

Address review comments, simplify test.
Take care of main file as provider handling:

• provider list [main-file,foo.h] and foo.h \#include'd - not show any providers on hover.
• provider list [foo.h,main-file] and foo.h \#include'd - "provided by foo.h".
• provider list [main-file, bar.h] and bar.h not \#include'd - not show any providers on hover.
• provider list [bar.h,main-file] and bar.h not \#include'd - "provided by bar.h".

[VitaNuo]

Thanks for the comments and the discussions!

clang-tools-extra/clangd/Hover.cpp

1118

Ok. It seems like I need to put an empty check on Headers, however, because contrary to the loop, front() might actually crash AFAIU.

1138

I think the pattern is not rare (especially for headers), think of the case below.

Makes sense, I didn't think about headers at all.

This comment doesn't seem to be addressed, now it is L1105.

Oops. See the current version please.

1227

Thank you.

clang-tools-extra/clangd/IncludeCleaner.cpp

291

oh it's not changed, just got moved because of the other two. But no worries, I can put it exactly in the previous position.

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

2897

Ok, I have simplified the test considerably. Please take a look.

2922

Testing that foo.h is ranked higher since it's providing the symbol directly. But maybe this makes no sense, I will remove it then.

2948

yeah this is also provided by the main file

3008

ok.

3023

ok.

3123

yes, thank you.

3139

Ok, I will translate this to a "foobar" example. But I think the correct answer in this example is actually foo.h since we want the provider of the underlying decl, not the using decl.

[hokein]

Thanks, this looks great, some more comments (most are nits)

clang-tools-extra/clangd/Hover.cpp

1099

maybe name it SortedProviders, it contains the main-file (calling Headers is a bit confusing).

1111

if we perform an early return inside the loop, the code can be simpler.

// Pickup the highest provider that satisfied the symbol usage, if available.
// If the main-file is the chosen provider, we deliberately do not display it (as it may cause too much noise, e.g. for local variables).
for (const auto & H : Headers) {
   if (isMainFile(H)) {
      return;
   }
   if (!Matches.empty()) {
      HI.Provider = Matches[0]->quote();
      return;
   } 
}

HI.Provider = spellHeader(AST...);

clang-tools-extra/clangd/Hover.h

71

nit: mention this header is with ""<>.

clang-tools-extra/clangd/IncludeCleaner.h

71

nit: can you add some document comment on these two functions?

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

2896

looks like [[]] is not used in the test, we only use the ^ point. Remove them?

2897

I think making the indentation like below is cleaer:

{Annotations(R"cpp(
               struct Foo {}; 
               int F = [[FO^O]]{};
             )cpp"),
 [](HoverInfo &HI) { HI.Provider = ""; }},

2911

The indentation of the code block doesn't seem to align with the above cases.

Unfortunately, clang-format doesn't format the codeblock inside the cpp()cpp string literal, we need to do it manually.

2938

I think this should be "", the using declaration is defined in main-file, main-file should be the only one provider, and we don't display main-file provider.

clang-tools-extra/include-cleaner/include/clang-include-cleaner/Analysis.h

16

we have been using forward declaration for the SourceLocation, we can add a forward declaration class SourceManager on Line 26, and get rid of the #include here.

84

since we move it from AnalysisInternal.h, can you remove the one in AnalysisInternal.h? I think we need to add #include "Analysis.h" to AnalysisInternal.h.

[VitaNuo]

Address review comments.

[VitaNuo]

Thanks for the review!

clang-tools-extra/clangd/Hover.cpp

1099

I think RankedProviders is better, they are not exactly sorted.

1111

Not really, this is not what we'd agreed upon.

Consider the provider list [foo.h, main-file], foo.h _not_ being #include'd.
The above code will return without a provider, but we would actually like to return foo.h.

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

2938

This is the same situation as absl::string_view vs. std::string_view, I believe.
The decl that is used in hover is class Foo {}; from foo.h, so foo.h is correct AFAIU.

[hokein]

Thanks, this looks great! Please fix the code style of the unit-test (see my other comment) before landing it.

clang-tools-extra/clangd/Hover.cpp

1111

Yeah, you're right. I don't remember what I thought on writing the comment.

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

2894

Can you follow the the indentation-style of R"cpp()cpp" from the above TEST(Hover, NoHover) example? It would be nice to be consistent.

We can save the explicit Annotations word here by changing the type of Code from Annotations to const char* const, and constructing the Annotations object inside the for-loop.

2938

oh, right. I missed that fact that the target on Hover here is the underlying decl of the using decl, can you add a comment clarifying the hover here is showing the underlying decl?

clang-tools-extra/clangd/Hover.h

 //===--- Hover.h - Information about code at the cursor location -*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_HOVER_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_HOVER_H
 
 #include "ParsedAST.h"
 #include "Protocol.h"
 #include "support/Markup.h"
 #include "clang/Index/IndexSymbol.h"
 #include <optional>
+#include <string>
 
 namespace clang {
 namespace clangd {
 
 /// Contains detailed information about a Symbol. Especially useful when
 /// generating hover responses. It can be rendered as a hover panel, or
 /// embedding clients can use the structured information to provide their own
 /// UI.
struct HoverInfo {
   /// Contains all of the enclosing namespaces, empty string means global
   /// namespace.
   std::optional<std::string> NamespaceScope;
   /// Remaining named contexts in symbol's qualified name, empty string means
   /// symbol is not local.
   std::string LocalScope;
   /// Name of the symbol, does not contain any "::".
   std::string Name;
+  /// Header providing the symbol (best match). Contains ""<>.
+  std::string Provider;
   std::optional<Range> SymRange;
   index::SymbolKind Kind = index::SymbolKind::Unknown;
   std::string Documentation;
   /// Source code containing the definition of the symbol.
   std::string Definition;
   const char *DefinitionLanguage = "cpp";
   /// Access specifier for declarations inside class/struct/unions, empty for
   /// others.

clang-tools-extra/clangd/Hover.cpp

 //===--- Hover.cpp - Information about code at the cursor location --------===//
 //
 // 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 "Hover.h"
 
 #include "AST.h"
 #include "CodeCompletionStrings.h"
 #include "Config.h"
 #include "FindTarget.h"
+#include "IncludeCleaner.h"
 #include "ParsedAST.h"
 #include "Selection.h"
 #include "SourceCode.h"
+#include "clang-include-cleaner/Analysis.h"
+#include "clang-include-cleaner/Types.h"
 #include "index/SymbolCollector.h"
+#include "support/Logger.h"
 #include "support/Markup.h"
+#include "support/Trace.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTDiagnostic.h"
 #include "clang/AST/ASTTypeTraits.h"
 #include "clang/AST/Attr.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclBase.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjC.h"

 #include "clang/Basic/TokenKinds.h"
 #include "clang/Index/IndexSymbol.h"
 #include "clang/Tooling/Syntax/Tokens.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Casting.h"
+#include "llvm/Support/Error.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/raw_ostream.h"
 #include <optional>
 #include <string>
+#include <vector>
 
 namespace clang {
 namespace clangd {
 namespace {
 
 PrintingPolicy getPrintingPolicy(PrintingPolicy Base) {
   Base.AnonymousTagLocations = false;
   Base.TerseOutput = true;
const NamedDecl *pickDeclToUse(llvm::ArrayRef<const NamedDecl *> Candidates) {
   auto BaseDecls = llvm::make_filter_range(
       Candidates, [](const NamedDecl *D) { return llvm::isa<UsingDecl>(D); });
   if (std::distance(BaseDecls.begin(), BaseDecls.end()) == 1)
     return *BaseDecls.begin();
 
   return Candidates.front();
 }
 
+void maybeAddSymbolProviders(ParsedAST &AST, HoverInfo &HI,
+                             include_cleaner::Symbol Sym) {
+  trace::Span Tracer("Hover::maybeAddSymbolProviders");
+
+  const SourceManager &SM = AST.getSourceManager();
+  llvm::SmallVector<include_cleaner::Header> RankedProviders =
+      include_cleaner::headersForSymbol(Sym, SM, AST.getPragmaIncludes());
+  if (RankedProviders.empty())
+    return;
+
+  std::string Result;
+  include_cleaner::Includes ConvertedIncludes =
+      convertIncludes(SM, AST.getIncludeStructure().MainFileIncludes);
+  for (const auto &P : RankedProviders) {
+    if (P.kind() == include_cleaner::Header::Physical &&
+        P.physical() == SM.getFileEntryForID(SM.getMainFileID()))
+      // Main file ranked higher than any #include'd file
+      break;
+
+    // Pick the best-ranked #include'd provider
+    auto Matches = ConvertedIncludes.match(P);
+    if (!Matches.empty()) {
+      Result = Matches[0]->quote();
+      break;
+    }
+  }
+
+  if (!Result.empty()) {
+    HI.Provider = std::move(Result);
+    return;
+  }
+
+  // Pick the best-ranked non-#include'd provider
+  const auto &H = RankedProviders.front();
+  if (H.kind() == include_cleaner::Header::Physical &&
+      H.physical() == SM.getFileEntryForID(SM.getMainFileID()))
+    // Do not show main file as provider, otherwise we'll show provider info
+    // on local variables, etc.
+    return;
+
+  HI.Provider = spellHeader(AST, SM.getFileEntryForID(SM.getMainFileID()), H);
+}
+
 } // namespace
 
 std::optional<HoverInfo> getHover(ParsedAST &AST, Position Pos,
                                   const format::FormatStyle &Style,
                                   const SymbolIndex *Index) {
   PrintingPolicy PP =
       getPrintingPolicy(AST.getASTContext().getPrintingPolicy());
   const SourceManager &SM = AST.getSourceManager();
   auto CurLoc = sourceLocationInMainFile(SM, Pos);
   if (!CurLoc) {
     llvm::consumeError(CurLoc.takeError());
     return std::nullopt;
   }
   const auto &TB = AST.getTokens();
   auto TokensTouchingCursor = syntax::spelledTokensTouching(*CurLoc, TB);
   // Early exit if there were no tokens around the cursor.
   if (TokensTouchingCursor.empty())
     return std::nullopt;
 
   // Show full header file path if cursor is on include directive.
   for (const auto &Inc : AST.getIncludeStructure().MainFileIncludes) {
     if (Inc.Resolved.empty() || Inc.HashLine != Pos.line)
       continue;
     HoverInfo HI;
     HI.Name = std::string(llvm::sys::path::filename(Inc.Resolved));
     // FIXME: We don't have a fitting value for Kind.
     HI.Definition =
         URIForFile::canonicalize(Inc.Resolved, AST.tuPath()).file().str();
     HI.DefinitionLanguage = "";
     return HI;
   }
 
   // To be used as a backup for highlighting the selected token, we use back as
   // it aligns better with biases elsewhere (editors tend to send the position
   // for the left of the hovered token).
   CharSourceRange HighlightRange =
       TokensTouchingCursor.back().range(SM).toCharRange(SM);
   std::optional<HoverInfo> HI;
   // Macros and deducedtype only works on identifiers and auto/decltype keywords
   // respectively. Therefore they are only trggered on whichever works for them,
   // similar to SelectionTree::create().
   for (const auto &Tok : TokensTouchingCursor) {
     if (Tok.kind() == tok::identifier) {
       // Prefer the identifier token as a fallback highlighting range.
       HighlightRange = Tok.range(SM).toCharRange(SM);
       if (auto M = locateMacroAt(Tok, AST.getPreprocessor())) {
         HI = getHoverContents(*M, Tok, AST);
+        if (auto DefLoc = M->Info->getDefinitionLoc(); DefLoc.isValid()) {
+          include_cleaner::Macro IncludeCleanerMacro{
+              AST.getPreprocessor().getIdentifierInfo(Tok.text(SM)), DefLoc};
+          maybeAddSymbolProviders(AST, *HI,
+                                  include_cleaner::Symbol{IncludeCleanerMacro});
+        }
         break;
       }
     } else if (Tok.kind() == tok::kw_auto || Tok.kind() == tok::kw_decltype) {
       if (auto Deduced = getDeducedType(AST.getASTContext(), Tok.location())) {
         HI = getDeducedTypeHoverContents(*Deduced, Tok, AST.getASTContext(), PP,
                                          Index);
         HighlightRange = Tok.range(SM).toCharRange(SM);
         break;
if (const SelectionTree::Node *N = ST.commonAncestor()) {
       auto Decls = explicitReferenceTargets(N->ASTNode, DeclRelation::Alias,
                                             AST.getHeuristicResolver());
       if (const auto *DeclToUse = pickDeclToUse(Decls)) {
         HI = getHoverContents(DeclToUse, PP, Index, TB);
         // Layout info only shown when hovering on the field/class itself.
         if (DeclToUse == N->ASTNode.get<Decl>())
           addLayoutInfo(*DeclToUse, *HI);
         // Look for a close enclosing expression to show the value of.
         if (!HI->Value)
           HI->Value = printExprValue(N, AST.getASTContext());
         maybeAddCalleeArgInfo(N, *HI, PP);
+        maybeAddSymbolProviders(AST, *HI, include_cleaner::Symbol{*DeclToUse});
       } else if (const Expr *E = N->ASTNode.get<Expr>()) {
         HI = getHoverContents(N, E, AST, PP, Index);
       } else if (const Attr *A = N->ASTNode.get<Attr>()) {
         HI = getHoverContents(A, AST);
       }
       // FIXME: support hovers for other nodes?
       //  - built-in types
     }
markup::Document HoverInfo::present() const {
   // level 1 and 2 headers in a huge font, see
   // https://github.com/microsoft/vscode/issues/88417 for details.
   markup::Paragraph &Header = Output.addHeading(3);
   if (Kind != index::SymbolKind::Unknown)
     Header.appendText(index::getSymbolKindString(Kind)).appendSpace();
   assert(!Name.empty() && "hover triggered on a nameless symbol");
   Header.appendCode(Name);
 
+  if (!Provider.empty()) {
+    markup::Paragraph &DI = Output.addParagraph();
+    DI.appendText("provided by");
+    DI.appendSpace();
+    DI.appendCode(Provider);
+    Output.addRuler();
+  }
+
   // Put a linebreak after header to increase readability.
   Output.addRuler();
   // Print Types on their own lines to reduce chances of getting line-wrapped by
   // editor, as they might be long.
   if (ReturnType) {
     // For functions we display signature in a list form, e.g.:
     // → `x`
     // Parameters:
     // - `bool param1`
     // - `int param2 = 5`
     Output.addParagraph().appendText("→ ").appendCode(
         llvm::to_string(*ReturnType));
   }
 
   if (Parameters && !Parameters->empty()) {
     Output.addParagraph().appendText("Parameters: ");
     markup::BulletList &L = Output.addBulletList();
     for (const auto &Param : *Parameters)
       L.addItem().addParagraph().appendCode(llvm::to_string(Param));
   }
 
   // Don't print Type after Parameters or ReturnType as this will just duplicate
   // the information
   if (Type && !ReturnType && !Parameters)
     Output.addParagraph().appendText("Type: ").appendCode(
         llvm::to_string(*Type));
 
   if (Value) {

clang-tools-extra/clangd/IncludeCleaner.h

 /// removal. This is off by default for now due to implementation limitations:
 /// - macros are not tracked
 /// - symbol names without a unique associated header are not tracked
 /// - references to std-namespaced C types are not properly tracked:
 ///   instead of std::size_t -> <cstddef> we see ::size_t -> <stddef.h>
 /// FIXME: remove this hack once the implementation is good enough.
 void setIncludeCleanerAnalyzesStdlib(bool B);
 
+/// Converts the clangd include representation to include-cleaner
+/// include representation.
+include_cleaner::Includes
+convertIncludes(const SourceManager &SM,
+                const llvm::ArrayRef<Inclusion> Includes);
+
+/// Determines the header spelling of an include-cleaner header
+/// representation. The spelling contains the ""<> characters.
+std::string spellHeader(ParsedAST &AST, const FileEntry *MainFile,
+                        include_cleaner::Header Provider);
 } // namespace clangd
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_INCLUDECLEANER_H

clang-tools-extra/clangd/IncludeCleaner.cpp

static bool mayConsiderUnused(const Inclusion &Inc, ParsedAST &AST,
 
   if (isFilteredByConfig(Cfg, Inc.Resolved)) {
     dlog("{0} header is filtered out by the configuration", FE->getName());
     return false;
   }
   return true;
 }
 
-include_cleaner::Includes
-convertIncludes(const SourceManager &SM,
-                const llvm::ArrayRef<Inclusion> MainFileIncludes) {
-  include_cleaner::Includes Includes;
-  for (const Inclusion &Inc : MainFileIncludes) {
-    include_cleaner::Include TransformedInc;
-    llvm::StringRef WrittenRef = llvm::StringRef(Inc.Written);
-    TransformedInc.Spelled = WrittenRef.trim("\"<>");
-    TransformedInc.HashLocation =
-        SM.getComposedLoc(SM.getMainFileID(), Inc.HashOffset);
-    TransformedInc.Line = Inc.HashLine + 1;
-    TransformedInc.Angled = WrittenRef.starts_with("<");
-    auto FE = SM.getFileManager().getFile(Inc.Resolved);
-    if (!FE) {
-      elog("IncludeCleaner: Failed to get an entry for resolved path {0}: {1}",
-           Inc.Resolved, FE.getError().message());
-      continue;
-    }
-    TransformedInc.Resolved = *FE;
-    Includes.add(std::move(TransformedInc));
-  }
-  return Includes;
-}
-
-std::string spellHeader(ParsedAST &AST, const FileEntry *MainFile,
-                        include_cleaner::Header Provider) {
-  if (Provider.kind() == include_cleaner::Header::Physical) {
-    if (auto CanonicalPath =
-            getCanonicalPath(Provider.physical(), AST.getSourceManager())) {
-      std::string SpelledHeader =
-          llvm::cantFail(URI::includeSpelling(URI::create(*CanonicalPath)));
-      if (!SpelledHeader.empty())
-        return SpelledHeader;
-    }
-  }
-  return include_cleaner::spellHeader(
-      Provider, AST.getPreprocessor().getHeaderSearchInfo(), MainFile);
-}
-
 std::vector<include_cleaner::SymbolReference>
 collectMacroReferences(ParsedAST &AST) {
   const auto &SM = AST.getSourceManager();
   //  FIXME: !!this is a hacky way to collect macro references.
   std::vector<include_cleaner::SymbolReference> Macros;
   auto &PP = AST.getPreprocessor();
   for (const syntax::Token &Tok :
        AST.getTokens().spelledTokens(SM.getMainFileID())) {
for (const auto *Inc : UnusedIncludes) {
     F.Edits.emplace_back();
     F.Edits.back().range.start.line = Inc->HashLine;
     F.Edits.back().range.end.line = Inc->HashLine + 1;
   }
   return Result;
 }
 } // namespace
 
+include_cleaner::Includes
+convertIncludes(const SourceManager &SM,
+                const llvm::ArrayRef<Inclusion> Includes) {
+  include_cleaner::Includes ConvertedIncludes;
+  for (const Inclusion &Inc : Includes) {
+    include_cleaner::Include TransformedInc;
+    llvm::StringRef WrittenRef = llvm::StringRef(Inc.Written);
+    TransformedInc.Spelled = WrittenRef.trim("\"<>");
+    TransformedInc.HashLocation =
+        SM.getComposedLoc(SM.getMainFileID(), Inc.HashOffset);
+    TransformedInc.Line = Inc.HashLine + 1;
+    TransformedInc.Angled = WrittenRef.starts_with("<");
+    auto FE = SM.getFileManager().getFile(Inc.Resolved);
+    if (!FE) {
+      elog("IncludeCleaner: Failed to get an entry for resolved path {0}: {1}",
+           Inc.Resolved, FE.getError().message());
+      continue;
+    }
+    TransformedInc.Resolved = *FE;
+    ConvertedIncludes.add(std::move(TransformedInc));
+  }
+  return ConvertedIncludes;
+}
+
+std::string spellHeader(ParsedAST &AST, const FileEntry *MainFile,
+                        include_cleaner::Header Provider) {
+  if (Provider.kind() == include_cleaner::Header::Physical) {
+    if (auto CanonicalPath =
+            getCanonicalPath(Provider.physical(), AST.getSourceManager())) {
+      std::string SpelledHeader =
+          llvm::cantFail(URI::includeSpelling(URI::create(*CanonicalPath)));
+      if (!SpelledHeader.empty())
+        return SpelledHeader;
+    }
+  }
+  return include_cleaner::spellHeader(
+      Provider, AST.getPreprocessor().getHeaderSearchInfo(), MainFile);
+}
 
 std::vector<const Inclusion *>
 getUnused(ParsedAST &AST,
           const llvm::DenseSet<IncludeStructure::HeaderID> &ReferencedFiles,
           const llvm::StringSet<> &ReferencedPublicHeaders) {
   trace::Span Tracer("IncludeCleaner::getUnused");
   const Config &Cfg = Config::current();
   std::vector<const Inclusion *> Unused;

clang-tools-extra/clangd/Preamble.cpp

public:
   }
 
   void BeforeExecute(CompilerInstance &CI) override {
     CanonIncludes.addSystemHeadersMapping(CI.getLangOpts());
     LangOpts = &CI.getLangOpts();
     SourceMgr = &CI.getSourceManager();
     PP = &CI.getPreprocessor();
     Includes.collect(CI);
-    if (Config::current().Diagnostics.UnusedIncludes ==
-                Config::IncludesPolicy::Strict ||
-            Config::current().Diagnostics.MissingIncludes ==
-            Config::IncludesPolicy::Strict)
-      Pragmas.record(CI);
     if (BeforeExecuteCallback)
       BeforeExecuteCallback(CI);
   }
 
   std::unique_ptr<PPCallbacks> createPPCallbacks() override {
     assert(SourceMgr && LangOpts && PP &&
            "SourceMgr, LangOpts and PP must be set at this point");
 

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

 //===-- HoverTests.cpp ----------------------------------------------------===//
 //
 // 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 "AST.h"
 #include "Annotations.h"
 #include "Config.h"
 #include "Hover.h"
 #include "TestIndex.h"
 #include "TestTU.h"
 #include "index/MemIndex.h"
 #include "clang/AST/Attr.h"
+#include "clang/Format/Format.h"
 #include "clang/Index/IndexSymbol.h"
 #include "llvm/ADT/StringRef.h"
 
-#include "gmock/gmock.h"
 #include "gtest/gtest.h"
+#include <functional>
 #include <string>
 #include <vector>
 
 namespace clang {
 namespace clangd {
 namespace {
 
 using PassMode = HoverInfo::PassType::PassMode;
 
+std::string guard(llvm::StringRef Code) {
+  return "#pragma once\n" + Code.str();
+}
+
 TEST(Hover, Structured) {
   struct {
     const char *const Code;
     const std::function<void(HoverInfo &)> ExpectedBuilder;
   } Cases[] = {
       // Global scope.
       {R"cpp(
           // Best foo ever.
for (const auto &Case : Cases) {
     EXPECT_EQ(H->ReturnType, Expected.ReturnType);
     EXPECT_EQ(H->Parameters, Expected.Parameters);
     EXPECT_EQ(H->TemplateParameters, Expected.TemplateParameters);
     EXPECT_EQ(H->SymRange, Expected.SymRange);
     EXPECT_EQ(H->Value, Expected.Value);
   }
 }
 
+TEST(Hover, Providers) {
+  struct {
+    const char *Code;
+    const std::function<void(HoverInfo &)> ExpectedBuilder;
+  } Cases[] = {{R"cpp(
+                            struct Foo {};                     
+                            Foo F = Fo^o{};
+                          )cpp",
+                [](HoverInfo &HI) { HI.Provider = ""; }},
+               {R"cpp(
+                            #include "foo.h"                   
+                            Foo F = Fo^o{};
+                          )cpp",
+                [](HoverInfo &HI) { HI.Provider = "\"foo.h\""; }},
+               {R"cpp(
+                            #include "all.h"  
+                            Foo F = Fo^o{};
+                          )cpp",
+                [](HoverInfo &HI) { HI.Provider = "\"foo.h\""; }},
+               {R"cpp(
+                            #define FOO 5
+                            int F = ^FOO;
+                          )cpp",
+                [](HoverInfo &HI) { HI.Provider = ""; }},
+               {R"cpp(
+                            #include "foo.h"
+                            int F = ^FOO;
+                          )cpp",
+                [](HoverInfo &HI) { HI.Provider = "\"foo.h\""; }},
+               {R"cpp(
+                            #include "all.h"
+                            int F = ^FOO;
+                          )cpp",
+                [](HoverInfo &HI) { HI.Provider = "\"foo.h\""; }},
+               {R"cpp(
+                            #include "foo.h"    
+                            Foo A;
+                            Foo B;
+                            Foo C = A ^+ B;
+                          )cpp",
+                [](HoverInfo &HI) { HI.Provider = "\"foo.h\""; }},
+               // Hover selects the underlying decl of the using decl
+               {R"cpp(
+                            #include "foo.h"
+                            namespace ns {
+                              using ::Foo;
+                            }
+                            ns::F^oo d;
+                          )cpp",
+                [](HoverInfo &HI) { HI.Provider = "\"foo.h\""; }}};
+
+  for (const auto &Case : Cases) {
+    Annotations Code{Case.Code};
+    SCOPED_TRACE(Code.code());
+
+    TestTU TU;
+    TU.Filename = "foo.cpp";
+    TU.Code = Code.code();
+    TU.AdditionalFiles["foo.h"] = guard(R"cpp(
+                                                #define FOO 1
+                                                class Foo {};
+                                                Foo& operator+(const Foo, const Foo);
+                                              )cpp");
+    TU.AdditionalFiles["all.h"] = guard("#include \"foo.h\"");
+
+    auto AST = TU.build();
+    auto H = getHover(AST, Code.point(), format::getLLVMStyle(), nullptr);
+    ASSERT_TRUE(H);
+    HoverInfo Expected;
+    Case.ExpectedBuilder(Expected);
+    SCOPED_TRACE(H->present().asMarkdown());
+    EXPECT_EQ(H->Provider, Expected.Provider);
+  }
+}
+
+TEST(Hover, ParseProviderInfo) {
+  HoverInfo HIFoo;
+  HIFoo.Name = "foo";
+  HIFoo.Provider = "\"foo.h\"";
+
+  HoverInfo HIFooBar;
+  HIFooBar.Name = "foo";
+  HIFooBar.Provider = "<bar.h>";
+  struct Case {
+    HoverInfo HI;
+    llvm::StringRef ExpectedMarkdown;
+  } Cases[] = {{HIFoo, "### `foo`  \nprovided by `\"foo.h\"`"},
+               {HIFooBar, "### `foo`  \nprovided by `<bar.h>`"}};
+
+  for (const auto &Case : Cases)
+    EXPECT_EQ(Case.HI.present().asMarkdown(), Case.ExpectedMarkdown);
+}
+
 TEST(Hover, DocsFromIndex) {
   Annotations T(R"cpp(
   template <typename T> class X {};
   void foo() {
     auto t = X<int>();
     X^<int> w;
     (void)w;
   })cpp");
auto Index =
       MemIndex::build(std::move(Symbols).build(), RefSlab(), RelationSlab());
 
   for (const auto &P : T.points()) {
     auto H = getHover(AST, P, format::getLLVMStyle(), Index.get());
     ASSERT_TRUE(H);
     EXPECT_EQ(H->Documentation, IndexSym.Documentation);
   }
 }
 
 TEST(Hover, DocsFromAST) {
   Annotations T(R"cpp(
   // doc
   template <typename T> class X {};
   // doc
   template <typename T> void bar() {}
   // doc
   template <typename T> T baz;
   void foo() {
     au^to t = X<int>();
     X^<int>();
     b^ar<int>();
     au^to T = ba^z<X<int>>;
     ba^z<int> = 0;
   })cpp");
 
   TestTU TU = TestTU::withCode(T.code());
   auto AST = TU.build();
   for (const auto &P : T.points()) {
     auto H = getHover(AST, P, format::getLLVMStyle(), nullptr);
     ASSERT_TRUE(H);
     EXPECT_EQ(H->Documentation, "doc");
   }
TEST(Hover, NoCrash) {
   for (const auto &P : T.points())
     getHover(AST, P, format::getLLVMStyle(), nullptr);
 }
 
 TEST(Hover, DocsFromMostSpecial) {
   Annotations T(R"cpp(
   // doc1
   template <typename T> class $doc1^X {};
   // doc2
   template <> class $doc2^X<int> {};
   // doc3
   template <typename T> class $doc3^X<T*> {};
   void foo() {
     X$doc1^<char>();
     X$doc2^<int>();
     X$doc3^<int*>();
   })cpp");
template <typename T, typename C = bool> class Foo {})",
             HI.Kind = index::SymbolKind::Function;
             HI.Name = "foo";
             HI.Type = {"type", "c_type"};
             HI.ReturnType = {"ret_type", "can_ret_type"};
             HI.Parameters.emplace();
             HoverInfo::Param P;
             HI.Parameters->push_back(P);
             P.Type = {"type", "can_type"};
             HI.Parameters->push_back(P);
             P.Name = "foo";
             HI.Parameters->push_back(P);
             P.Default = "default";
             HI.Parameters->push_back(P);
             HI.NamespaceScope = "ns::";
             HI.Definition = "ret_type foo(params) {}";
           },
           "function foo\n"
           "\n"
           "→ ret_type (aka can_ret_type)\n"
           "Parameters:\n"
           "- \n"
           "- type (aka can_type)\n"
           "- type foo (aka can_type)\n"
           "- type foo = default (aka can_type)\n"
           "\n"
           "// In namespace ns\n"
           "ret_type foo(params) {}",
       },
       {
           [](HoverInfo &HI) {
             HI.Kind = index::SymbolKind::Field;
             HI.LocalScope = "test::Bar::";
             HI.Value = "value";
for (const auto &C : Cases) {
     markup::Document Output;
     parseDocumentation(C.Documentation, Output);
 
     EXPECT_EQ(Output.asMarkdown(), C.ExpectedRenderMarkdown);
     EXPECT_EQ(Output.asPlainText(), C.ExpectedRenderPlainText);
   }
 }
 
-// This is a separate test as headings don't create any differences in plaintext
-// mode.
+// This is a separate test as headings don't create any differences in
+// plaintext mode.
 TEST(Hover, PresentHeadings) {
   HoverInfo HI;
   HI.Kind = index::SymbolKind::Variable;
   HI.Name = "foo";
 
   EXPECT_EQ(HI.present().asMarkdown(), "### variable `foo`");
 }
 

clang-tools-extra/include-cleaner/include/clang-include-cleaner/Analysis.h

 //===--- Analysis.h - Analyze symbol references in AST ------------- 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
 //
 //===----------------------------------------------------------------------===//
 /// A library that provides usage analysis for symbols based on AST analysis.
 //===----------------------------------------------------------------------===//
 
 #ifndef CLANG_INCLUDE_CLEANER_ANALYSIS_H
 #define CLANG_INCLUDE_CLEANER_ANALYSIS_H
 
 #include "clang-include-cleaner/Record.h"
 #include "clang-include-cleaner/Types.h"
 #include "clang/Format/Format.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/STLFunctionalExtras.h"
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/MemoryBufferRef.h"
 #include <variant>
 
 namespace clang {
 class SourceLocation;
+class SourceManager;
 class Decl;
 class FileEntry;
 class HeaderSearch;
 namespace tooling {
 class Replacements;
 struct IncludeStyle;
 } // namespace tooling
 namespace include_cleaner {

 /// Removes unused includes and inserts missing ones in the main file.
 /// Returns the modified main-file code.
 /// The FormatStyle must be C++ or ObjC (to support include ordering).
 std::string fixIncludes(const AnalysisResults &Results, llvm::StringRef Code,
                         const format::FormatStyle &IncludeStyle);
 
 std::string spellHeader(const Header &H, HeaderSearch &HS,
                         const FileEntry *Main);
+
+/// Gets all the providers for a symbol by traversing each location.
+/// Returned headers are sorted by relevance, first element is the most
+/// likely provider for the symbol.
+llvm::SmallVector<Header> headersForSymbol(const Symbol &S,
+                                           const SourceManager &SM,
+                                           const PragmaIncludes *PI);
+
 } // namespace include_cleaner
 } // namespace clang
 
 #endif

clang-tools-extra/include-cleaner/lib/AnalysisInternal.h

 // (AST => AST Node => Symbol is one API to avoid materializing DynTypedNodes).
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef CLANG_INCLUDE_CLEANER_ANALYSISINTERNAL_H
 #define CLANG_INCLUDE_CLEANER_ANALYSISINTERNAL_H
 
 #include "TypesInternal.h"
+#include "clang-include-cleaner/Analysis.h"
 #include "clang-include-cleaner/Record.h"
 #include "clang-include-cleaner/Types.h"
 #include "llvm/ADT/STLFunctionalExtras.h"
 #include <vector>
 
 namespace clang {
 class ASTContext;
 class Decl;

 /// Finds the headers that provide the symbol location.
 llvm::SmallVector<Hinted<Header>> findHeaders(const SymbolLocation &Loc,
                                               const SourceManager &SM,
                                               const PragmaIncludes *PI);
 
 /// A set of locations that provides the declaration.
 std::vector<Hinted<SymbolLocation>> locateSymbol(const Symbol &S);
 
-/// Gets all the providers for a symbol by traversing each location.
-/// Returned headers are sorted by relevance, first element is the most
-/// likely provider for the symbol.
-llvm::SmallVector<Header> headersForSymbol(const Symbol &S,
-                                           const SourceManager &SM,
-                                           const PragmaIncludes *PI);
-
 /// Write an HTML summary of the analysis to the given stream.
 void writeHTMLReport(FileID File, const Includes &,
                      llvm::ArrayRef<Decl *> Roots,
                      llvm::ArrayRef<SymbolReference> MacroRefs, ASTContext &Ctx,
                      HeaderSearch &HS, PragmaIncludes *PI,
                      llvm::raw_ostream &OS);
 
 } // namespace include_cleaner
 } // namespace clang
 
 #endif