Coverage Report

Created: 2023-11-11 10:31

/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/include/clang/Tooling/Inclusions/HeaderIncludes.h
Line
Count
Source
1
//===--- HeaderIncludes.h - Insert/Delete #includes for C++ code--*- 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
#ifndef LLVM_CLANG_TOOLING_INCLUSIONS_HEADERINCLUDES_H
10
#define LLVM_CLANG_TOOLING_INCLUSIONS_HEADERINCLUDES_H
11
12
#include "clang/Basic/SourceManager.h"
13
#include "clang/Tooling/Core/Replacement.h"
14
#include "clang/Tooling/Inclusions/IncludeStyle.h"
15
#include "llvm/Support/Path.h"
16
#include "llvm/Support/Regex.h"
17
#include <list>
18
#include <optional>
19
#include <unordered_map>
20
21
namespace clang {
22
namespace tooling {
23
24
/// This class manages priorities of C++ #include categories and calculates
25
/// priorities for headers.
26
/// FIXME(ioeric): move this class into implementation file when clang-format's
27
/// include sorting functions are also moved here.
28
class IncludeCategoryManager {
29
public:
30
  IncludeCategoryManager(const IncludeStyle &Style, StringRef FileName);
31
32
  /// Returns the priority of the category which \p IncludeName belongs to.
33
  /// If \p CheckMainHeader is true and \p IncludeName is a main header, returns
34
  /// 0. Otherwise, returns the priority of the matching category or INT_MAX.
35
  /// NOTE: this API is not thread-safe!
36
  int getIncludePriority(StringRef IncludeName, bool CheckMainHeader) const;
37
  int getSortIncludePriority(StringRef IncludeName, bool CheckMainHeader) const;
38
39
private:
40
  bool isMainHeader(StringRef IncludeName) const;
41
42
  const IncludeStyle Style;
43
  bool IsMainFile;
44
  std::string FileName;
45
  SmallVector<llvm::Regex, 4> CategoryRegexs;
46
};
47
48
enum class IncludeDirective { Include, Import };
49
50
/// Generates replacements for inserting or deleting #include directives in a
51
/// file.
52
class HeaderIncludes {
53
public:
54
  HeaderIncludes(llvm::StringRef FileName, llvm::StringRef Code,
55
                 const IncludeStyle &Style);
56
57
  /// Inserts an #include or #import directive of \p Header into the code.
58
  /// If \p IsAngled is true, \p Header will be quoted with <> in the directive;
59
  /// otherwise, it will be quoted with "".
60
  ///
61
  /// When searching for points to insert new header, this ignores #include's
62
  /// after the #include block(s) in the beginning of a file to avoid inserting
63
  /// headers into code sections where new #include's should not be added by
64
  /// default. These code sections include:
65
  ///   - raw string literals (containing #include).
66
  ///   - #if blocks.
67
  ///   - Special #include's among declarations (e.g. functions).
68
  ///
69
  /// Returns a replacement that inserts the new header into a suitable #include
70
  /// block of the same category. This respects the order of the existing
71
  /// #includes in the block; if the existing #includes are not already sorted,
72
  /// this will simply insert the #include in front of the first #include of the
73
  /// same category in the code that should be sorted after \p IncludeName. If
74
  /// \p IncludeName already exists (with exactly the same spelling), this
75
  /// returns std::nullopt.
76
  std::optional<tooling::Replacement> insert(llvm::StringRef Header,
77
                                             bool IsAngled,
78
                                             IncludeDirective Directive) const;
79
80
  /// Removes all existing #includes and #imports of \p Header quoted with <> if
81
  /// \p IsAngled is true or "" if \p IsAngled is false.
82
  /// This doesn't resolve the header file path; it only deletes #includes and
83
  /// #imports with exactly the same spelling.
84
  tooling::Replacements remove(llvm::StringRef Header, bool IsAngled) const;
85
86
  // Matches a whole #include directive.
87
  static const llvm::Regex IncludeRegex;
88
89
private:
90
  struct Include {
91
    Include(StringRef Name, tooling::Range R, IncludeDirective D)
92
200
        : Name(Name), R(R), Directive(D) {}
93
94
    // An include header quoted with either <> or "".
95
    std::string Name;
96
    // The range of the whole line of include directive including any leading
97
    // whitespaces and trailing comment.
98
    tooling::Range R;
99
    // Either #include or #import.
100
    IncludeDirective Directive;
101
  };
102
103
  void addExistingInclude(Include IncludeToAdd, unsigned NextLineOffset);
104
105
  std::string FileName;
106
  std::string Code;
107
108
  // Map from include name (quotation trimmed) to a list of existing includes
109
  // (in case there are more than one) with the name in the current file. <x>
110
  // and "x" will be treated as the same header when deleting #includes.
111
  // std::list is used for pointers stability (see IncludesByPriority)
112
  llvm::StringMap<std::list<Include>> ExistingIncludes;
113
114
  /// Map from priorities of #include categories to all #includes in the same
115
  /// category. This is used to find #includes of the same category when
116
  /// inserting new #includes. #includes in the same categories are sorted in
117
  /// in the order they appear in the source file.
118
  /// See comment for "FormatStyle::IncludeCategories" for details about include
119
  /// priorities.
120
  std::unordered_map<int, llvm::SmallVector<const Include *, 8>>
121
      IncludesByPriority;
122
123
  int FirstIncludeOffset;
124
  // All new headers should be inserted after this offset (e.g. after header
125
  // guards, file comment).
126
  unsigned MinInsertOffset;
127
  // Max insertion offset in the original code. For example, we want to avoid
128
  // inserting new #includes into the actual code section (e.g. after a
129
  // declaration).
130
  unsigned MaxInsertOffset;
131
  // True if we find the main-file header in the Code.
132
  bool MainIncludeFound;
133
  IncludeCategoryManager Categories;
134
  // Record the offset of the end of the last include in each category.
135
  std::unordered_map<int, int> CategoryEndOffsets;
136
137
  // All possible priorities.
138
  std::set<int> Priorities;
139
};
140
141
} // namespace tooling
142
} // namespace clang
143
144
#endif // LLVM_CLANG_TOOLING_INCLUSIONS_HEADERINCLUDES_H