llvm-project

1
//===--- HeaderSourceSwitch.cpp - --------------------------------*- C++-*-===//
2
//
3
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4
// See https://llvm.org/LICENSE.txt for license information.
5
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6
//
7
//===----------------------------------------------------------------------===//
8

9
#include "HeaderSourceSwitch.h"
10
#include "AST.h"
11
#include "SourceCode.h"
12
#include "index/SymbolCollector.h"
13
#include "support/Logger.h"
14
#include "support/Path.h"
15
#include "clang/AST/Decl.h"
16
#include <optional>
17

18
namespace clang {
19
namespace clangd {
20

21
std::optional<Path> getCorrespondingHeaderOrSource(
22
    PathRef OriginalFile, llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS) {
23
  llvm::StringRef SourceExtensions[] = {".cpp", ".c", ".cc", ".cxx",
24
                                        ".c++", ".m", ".mm"};
25
  llvm::StringRef HeaderExtensions[] = {".h", ".hh", ".hpp", ".hxx", ".inc"};
26

27
  llvm::StringRef PathExt = llvm::sys::path::extension(OriginalFile);
28

29
  // Lookup in a list of known extensions.
30
  bool IsSource = llvm::any_of(SourceExtensions, [&PathExt](PathRef SourceExt) {
31
    return SourceExt.equals_insensitive(PathExt);
32
  });
33

34
  bool IsHeader = llvm::any_of(HeaderExtensions, [&PathExt](PathRef HeaderExt) {
35
    return HeaderExt.equals_insensitive(PathExt);
36
  });
37

38
  // We can only switch between the known extensions.
39
  if (!IsSource && !IsHeader)
40
    return std::nullopt;
41

42
  // Array to lookup extensions for the switch. An opposite of where original
43
  // extension was found.
44
  llvm::ArrayRef<llvm::StringRef> NewExts;
45
  if (IsSource)
46
    NewExts = HeaderExtensions;
47
  else
48
    NewExts = SourceExtensions;
49

50
  // Storage for the new path.
51
  llvm::SmallString<128> NewPath = OriginalFile;
52

53
  // Loop through switched extension candidates.
54
  for (llvm::StringRef NewExt : NewExts) {
55
    llvm::sys::path::replace_extension(NewPath, NewExt);
56
    if (VFS->exists(NewPath))
57
      return Path(NewPath);
58

59
    // Also check NewExt in upper-case, just in case.
60
    llvm::sys::path::replace_extension(NewPath, NewExt.upper());
61
    if (VFS->exists(NewPath))
62
      return Path(NewPath);
63
  }
64
  return std::nullopt;
65
}
66

67
std::optional<Path> getCorrespondingHeaderOrSource(PathRef OriginalFile,
68
                                                   ParsedAST &AST,
69
                                                   const SymbolIndex *Index) {
70
  if (!Index) {
71
    // FIXME: use the AST to do the inference.
72
    return std::nullopt;
73
  }
74
  LookupRequest Request;
75
  // Find all symbols present in the original file.
76
  for (const auto *D : getIndexableLocalDecls(AST)) {
77
    if (auto ID = getSymbolID(D))
78
      Request.IDs.insert(ID);
79
  }
80
  llvm::StringMap<int> Candidates; // Target path => score.
81
  auto AwardTarget = [&](const char *TargetURI) {
82
    if (auto TargetPath = URI::resolve(TargetURI, OriginalFile)) {
83
      if (!pathEqual(*TargetPath, OriginalFile)) // exclude the original file.
84
        ++Candidates[*TargetPath];
85
    } else {
86
      elog("Failed to resolve URI {0}: {1}", TargetURI, TargetPath.takeError());
87
    }
88
  };
89
  // If we switch from a header, we are looking for the implementation
90
  // file, so we use the definition loc; otherwise we look for the header file,
91
  // we use the decl loc;
92
  //
93
  // For each symbol in the original file, we get its target location (decl or
94
  // def) from the index, then award that target file.
95
  bool IsHeader = isHeaderFile(OriginalFile, AST.getLangOpts());
96
  Index->lookup(Request, [&](const Symbol &Sym) {
97
    if (IsHeader)
98
      AwardTarget(Sym.Definition.FileURI);
99
    else
100
      AwardTarget(Sym.CanonicalDeclaration.FileURI);
101
  });
102
  // FIXME: our index doesn't have any interesting information (this could be
103
  // that the background-index is not finished), we should use the decl/def
104
  // locations from the AST to do the inference (from .cc to .h).
105
  if (Candidates.empty())
106
    return std::nullopt;
107

108
  // Pickup the winner, who contains most of symbols.
109
  // FIXME: should we use other signals (file proximity) to help score?
110
  auto Best = Candidates.begin();
111
  for (auto It = Candidates.begin(); It != Candidates.end(); ++It) {
112
    if (It->second > Best->second)
113
      Best = It;
114
    else if (It->second == Best->second && It->first() < Best->first())
115
      // Select the first one in the lexical order if we have multiple
116
      // candidates.
117
      Best = It;
118
  }
119
  return Path(Best->first());
120
}
121

122
std::vector<const Decl *> getIndexableLocalDecls(ParsedAST &AST) {
123
  std::vector<const Decl *> Results;
124
  std::function<void(Decl *)> TraverseDecl = [&](Decl *D) {
125
    auto *ND = llvm::dyn_cast<NamedDecl>(D);
126
    if (!ND || ND->isImplicit())
127
      return;
128
    if (!SymbolCollector::shouldCollectSymbol(*ND, D->getASTContext(), {},
129
                                              /*IsMainFileSymbol=*/false))
130
      return;
131
    if (!llvm::isa<FunctionDecl>(ND)) {
132
      // Visit the children, but we skip function decls as we are not interested
133
      // in the function body.
134
      if (auto *Scope = llvm::dyn_cast<DeclContext>(ND)) {
135
        for (auto *D : Scope->decls())
136
          TraverseDecl(D);
137
      }
138
    }
139
    if (llvm::isa<NamespaceDecl>(D))
140
      return; // namespace is indexable, but we're not interested.
141
    Results.push_back(D);
142
  };
143
  // Traverses the ParsedAST directly to collect all decls present in the main
144
  // file.
145
  for (auto *TopLevel : AST.getLocalTopLevelDecls())
146
    TraverseDecl(TopLevel);
147
  return Results;
148
}
149

150
} // namespace clangd
151
} // namespace clang
152