Coverage Report

Created: 2022-07-16 07:03

/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/include/clang/Tooling/Inclusions/StandardLibrary.h
Line
Count
Source (jump to first uncovered line)
1
//===--- StandardLibrary.h --------------------------------------*- 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
/// \file
10
/// Provides an interface for querying information about C and C++ Standard
11
/// Library headers and symbols.
12
///
13
//===----------------------------------------------------------------------===//
14
15
#ifndef LLVM_CLANG_TOOLING_INCLUSIONS_STANDARDLIBRARY_H
16
#define LLVM_CLANG_TOOLING_INCLUSIONS_STANDARDLIBRARY_H
17
18
#include "clang/AST/Decl.h"
19
#include "llvm/ADT/Optional.h"
20
#include "llvm/ADT/StringRef.h"
21
#include "llvm/Support/raw_ostream.h"
22
#include <string>
23
24
namespace clang {
25
namespace tooling {
26
namespace stdlib {
27
28
class Symbol;
29
30
// A standard library header, such as <iostream>
31
// Lightweight class, in fact just an index into a table.
32
// C++ and C Library compatibility headers are considered different: e.g.
33
// "<cstdio>" and "<stdio.h>" (and their symbols) are treated differently.
34
class Header {
35
public:
36
  // Name should contain the angle brackets, e.g. "<vector>".
37
  static llvm::Optional<Header> named(llvm::StringRef Name);
38
39
  friend llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Header &H) {
40
    return OS << H.name();
41
  }
42
  llvm::StringRef name() const;
43
44
private:
45
3
  Header(unsigned ID) : ID(ID) {}
46
  unsigned ID;
47
  friend Symbol;
48
  friend llvm::DenseMapInfo<Header>;
49
  friend bool operator==(const Header &L, const Header &R) {
50
    return L.ID == R.ID;
51
  }
52
};
53
54
// A top-level standard library symbol, such as std::vector
55
// Lightweight class, in fact just an index into a table.
56
// C++ and C Standard Library symbols are considered distinct: e.g. std::printf
57
// and ::printf are not treated as the same symbol.
58
// The symbols do not contain macros right now, we don't have a reliable index
59
// for them.
60
class Symbol {
61
public:
62
  /// \p Scope should have the trailing "::", for example:
63
  /// named("std::chrono::", "system_clock")
64
  static llvm::Optional<Symbol> named(llvm::StringRef Scope,
65
                                      llvm::StringRef Name);
66
67
  friend llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Symbol &S) {
68
    return OS << S.scope() << S.name();
69
  }
70
  llvm::StringRef scope() const;
71
  llvm::StringRef name() const;
72
  // The preferred header for this symbol (e.g. the suggested insertion).
73
  Header header() const;
74
  // Some symbols may be provided by multiple headers.
75
  llvm::SmallVector<Header> headers() const;
76
77
private:
78
7
  Symbol(unsigned ID) : ID(ID) {}
79
  unsigned ID;
80
  friend class Recognizer;
81
  friend llvm::DenseMapInfo<Symbol>;
82
  friend bool operator==(const Symbol &L, const Symbol &R) {
83
    return L.ID == R.ID;
84
  }
85
};
86
87
// A functor to find the stdlib::Symbol associated with a decl.
88
//
89
// For non-top-level decls (std::vector<int>::iterator), returns the top-level
90
// symbol (std::vector).
91
class Recognizer {
92
public:
93
  Recognizer();
94
  llvm::Optional<Symbol> operator()(const Decl *D);
95
96
private:
97
  using NSSymbolMap = llvm::DenseMap<llvm::StringRef, unsigned>;
98
  NSSymbolMap *namespaceSymbols(const NamespaceDecl *D);
99
  llvm::DenseMap<const DeclContext *, NSSymbolMap *> NamespaceCache;
100
};
101
102
} // namespace stdlib
103
} // namespace tooling
104
} // namespace clang
105
106
namespace llvm {
107
108
template <> struct DenseMapInfo<clang::tooling::stdlib::Header> {
109
0
  static inline clang::tooling::stdlib::Header getEmptyKey() {
110
0
    return clang::tooling::stdlib::Header(-1);
111
0
  }
112
0
  static inline clang::tooling::stdlib::Header getTombstoneKey() {
113
0
    return clang::tooling::stdlib::Header(-2);
114
0
  }
115
0
  static unsigned getHashValue(const clang::tooling::stdlib::Header &H) {
116
0
    return hash_value(H.ID);
117
0
  }
118
  static bool isEqual(const clang::tooling::stdlib::Header &LHS,
119
0
                      const clang::tooling::stdlib::Header &RHS) {
120
0
    return LHS == RHS;
121
0
  }
122
};
123
124
template <> struct DenseMapInfo<clang::tooling::stdlib::Symbol> {
125
0
  static inline clang::tooling::stdlib::Symbol getEmptyKey() {
126
0
    return clang::tooling::stdlib::Symbol(-1);
127
0
  }
128
0
  static inline clang::tooling::stdlib::Symbol getTombstoneKey() {
129
0
    return clang::tooling::stdlib::Symbol(-2);
130
0
  }
131
0
  static unsigned getHashValue(const clang::tooling::stdlib::Symbol &S) {
132
0
    return hash_value(S.ID);
133
0
  }
134
  static bool isEqual(const clang::tooling::stdlib::Symbol &LHS,
135
0
                      const clang::tooling::stdlib::Symbol &RHS) {
136
0
    return LHS == RHS;
137
0
  }
138
};
139
} // namespace llvm
140
141
#endif // LLVM_CLANG_TOOLING_INCLUSIONS_STANDARDLIBRARY_H