Coverage Report

Created: 2023-11-11 10:31

/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/lib/Frontend/ASTConsumers.cpp
Line
Count
Source (jump to first uncovered line)
1
//===--- ASTConsumers.cpp - ASTConsumer implementations -------------------===//
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
// AST Consumer Implementations.
10
//
11
//===----------------------------------------------------------------------===//
12
13
#include "clang/Frontend/ASTConsumers.h"
14
#include "clang/AST/AST.h"
15
#include "clang/AST/ASTConsumer.h"
16
#include "clang/AST/ASTContext.h"
17
#include "clang/AST/PrettyPrinter.h"
18
#include "clang/AST/RecordLayout.h"
19
#include "clang/AST/RecursiveASTVisitor.h"
20
#include "clang/Basic/Diagnostic.h"
21
#include "clang/Basic/SourceManager.h"
22
#include "llvm/Support/Path.h"
23
#include "llvm/Support/Timer.h"
24
#include "llvm/Support/raw_ostream.h"
25
using namespace clang;
26
27
//===----------------------------------------------------------------------===//
28
/// ASTPrinter - Pretty-printer and dumper of ASTs
29
30
namespace {
31
  class ASTPrinter : public ASTConsumer,
32
                     public RecursiveASTVisitor<ASTPrinter> {
33
    typedef RecursiveASTVisitor<ASTPrinter> base;
34
35
  public:
36
    enum Kind { DumpFull, Dump, Print, None };
37
    ASTPrinter(std::unique_ptr<raw_ostream> Out, Kind K,
38
               ASTDumpOutputFormat Format, StringRef FilterString,
39
               bool DumpLookups = false, bool DumpDeclTypes = false)
40
1.40k
        : Out(Out ? 
*Out769
:
llvm::outs()640
), OwnedOut(std::move(Out)),
41
1.40k
          OutputKind(K), OutputFormat(Format), FilterString(FilterString),
42
1.40k
          DumpLookups(DumpLookups), DumpDeclTypes(DumpDeclTypes) {}
43
44
1.42k
    void HandleTranslationUnit(ASTContext &Context) override {
45
1.42k
      TranslationUnitDecl *D = Context.getTranslationUnitDecl();
46
47
1.42k
      if (FilterString.empty())
48
1.29k
        return print(D);
49
50
129
      TraverseDecl(D);
51
129
    }
52
53
2.76k
    bool shouldWalkTypesOfTypeLocs() const { return false; }
54
55
4.46k
    bool TraverseDecl(Decl *D) {
56
4.46k
      if (D && 
filterMatches(D)4.45k
) {
57
792
        bool ShowColors = Out.has_colors();
58
792
        if (ShowColors)
59
0
          Out.changeColor(raw_ostream::BLUE);
60
61
792
        if (OutputFormat == ADOF_Default)
62
689
          Out << (OutputKind != Print ? "Dumping " : 
"Printing "0
) << getName(D)
63
689
              << ":\n";
64
65
792
        if (ShowColors)
66
0
          Out.resetColor();
67
792
        print(D);
68
792
        Out << "\n";
69
        // Don't traverse child nodes to avoid output duplication.
70
792
        return true;
71
792
      }
72
3.67k
      return base::TraverseDecl(D);
73
4.46k
    }
74
75
  private:
76
5.13k
    std::string getName(Decl *D) {
77
5.13k
      if (isa<NamedDecl>(D))
78
4.91k
        return cast<NamedDecl>(D)->getQualifiedNameAsString();
79
229
      return "";
80
5.13k
    }
81
4.45k
    bool filterMatches(Decl *D) {
82
4.45k
      return getName(D).find(FilterString) != std::string::npos;
83
4.45k
    }
84
2.08k
    void print(Decl *D) {
85
2.08k
      if (DumpLookups) {
86
17
        if (DeclContext *DC = dyn_cast<DeclContext>(D)) {
87
13
          if (DC == DC->getPrimaryContext())
88
7
            DC->dumpLookups(Out, OutputKind != None, OutputKind == DumpFull);
89
6
          else
90
6
            Out << "Lookup map is in primary DeclContext "
91
6
                << DC->getPrimaryContext() << "\n";
92
13
        } else
93
4
          Out << "Not a DeclContext\n";
94
2.07k
      } else if (OutputKind == Print) {
95
770
        PrintingPolicy Policy(D->getASTContext().getLangOpts());
96
770
        D->print(Out, Policy, /*Indentation=*/0, /*PrintInstantiation=*/true);
97
1.30k
      } else if (OutputKind != None) {
98
1.30k
        D->dump(Out, OutputKind == DumpFull, OutputFormat);
99
1.30k
      }
100
101
2.08k
      if (DumpDeclTypes) {
102
44
        Decl *InnerD = D;
103
44
        if (auto *TD = dyn_cast<TemplateDecl>(D))
104
44
          InnerD = TD->getTemplatedDecl();
105
106
        // FIXME: Support OutputFormat in type dumping.
107
        // FIXME: Support combining -ast-dump-decl-types with -ast-dump-lookups.
108
44
        if (auto *VD = dyn_cast<ValueDecl>(InnerD))
109
44
          VD->getType().dump(Out, VD->getASTContext());
110
44
        if (auto *TD = dyn_cast<TypeDecl>(InnerD))
111
0
          TD->getTypeForDecl()->dump(Out, TD->getASTContext());
112
44
      }
113
2.08k
    }
114
115
    raw_ostream &Out;
116
    std::unique_ptr<raw_ostream> OwnedOut;
117
118
    /// How to output individual declarations.
119
    Kind OutputKind;
120
121
    /// What format should the output take?
122
    ASTDumpOutputFormat OutputFormat;
123
124
    /// Which declarations or DeclContexts to display.
125
    std::string FilterString;
126
127
    /// Whether the primary output is lookup results or declarations. Individual
128
    /// results will be output with a format determined by OutputKind. This is
129
    /// incompatible with OutputKind == Print.
130
    bool DumpLookups;
131
132
    /// Whether to dump the type for each declaration dumped.
133
    bool DumpDeclTypes;
134
  };
135
136
  class ASTDeclNodeLister : public ASTConsumer,
137
                     public RecursiveASTVisitor<ASTDeclNodeLister> {
138
  public:
139
    ASTDeclNodeLister(raw_ostream *Out = nullptr)
140
1
        : Out(Out ? 
*Out0
: llvm::outs()) {}
141
142
1
    void HandleTranslationUnit(ASTContext &Context) override {
143
1
      TraverseDecl(Context.getTranslationUnitDecl());
144
1
    }
145
146
4
    bool shouldWalkTypesOfTypeLocs() const { return false; }
147
148
10
    bool VisitNamedDecl(NamedDecl *D) {
149
10
      D->printQualifiedName(Out);
150
10
      Out << '\n';
151
10
      return true;
152
10
    }
153
154
  private:
155
    raw_ostream &Out;
156
  };
157
} // end anonymous namespace
158
159
std::unique_ptr<ASTConsumer>
160
clang::CreateASTPrinter(std::unique_ptr<raw_ostream> Out,
161
770
                        StringRef FilterString) {
162
770
  return std::make_unique<ASTPrinter>(std::move(Out), ASTPrinter::Print,
163
770
                                       ADOF_Default, FilterString);
164
770
}
165
166
std::unique_ptr<ASTConsumer>
167
clang::CreateASTDumper(std::unique_ptr<raw_ostream> Out, StringRef FilterString,
168
                       bool DumpDecls, bool Deserialize, bool DumpLookups,
169
639
                       bool DumpDeclTypes, ASTDumpOutputFormat Format) {
170
639
  assert((DumpDecls || Deserialize || DumpLookups) && "nothing to dump");
171
639
  return std::make_unique<ASTPrinter>(
172
639
      std::move(Out),
173
639
      Deserialize ? 
ASTPrinter::DumpFull92
174
639
                  : 
DumpDecls547
?
ASTPrinter::Dump542
:
ASTPrinter::None5
,
175
639
      Format, FilterString, DumpLookups, DumpDeclTypes);
176
639
}
177
178
1
std::unique_ptr<ASTConsumer> clang::CreateASTDeclNodeLister() {
179
1
  return std::make_unique<ASTDeclNodeLister>(nullptr);
180
1
}
181
182
//===----------------------------------------------------------------------===//
183
/// ASTViewer - AST Visualization
184
185
namespace {
186
class ASTViewer : public ASTConsumer {
187
  ASTContext *Context = nullptr;
188
189
public:
190
0
  void Initialize(ASTContext &Context) override { this->Context = &Context; }
191
192
0
  bool HandleTopLevelDecl(DeclGroupRef D) override {
193
0
    for (DeclGroupRef::iterator I = D.begin(), E = D.end(); I != E; ++I)
194
0
      HandleTopLevelSingleDecl(*I);
195
0
    return true;
196
0
  }
197
198
  void HandleTopLevelSingleDecl(Decl *D);
199
};
200
}
201
202
0
void ASTViewer::HandleTopLevelSingleDecl(Decl *D) {
203
0
  if (isa<FunctionDecl>(D) || isa<ObjCMethodDecl>(D)) {
204
0
    D->print(llvm::errs());
205
206
0
    if (Stmt *Body = D->getBody()) {
207
0
      llvm::errs() << '\n';
208
0
      Body->viewAST();
209
0
      llvm::errs() << '\n';
210
0
    }
211
0
  }
212
0
}
213
214
0
std::unique_ptr<ASTConsumer> clang::CreateASTViewer() {
215
0
  return std::make_unique<ASTViewer>();
216
0
}