clang 22.0.0git
PrettyPrinter.h
Go to the documentation of this file.
1//===--- PrettyPrinter.h - Classes for aiding with AST printing -*- 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// This file defines helper types for AST pretty-printing.
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_CLANG_AST_PRETTYPRINTER_H
14#define LLVM_CLANG_AST_PRETTYPRINTER_H
15
16#include "clang/Basic/LLVM.h"
18
19namespace clang {
20
21class DeclContext;
22class LangOptions;
23class Stmt;
24
26public:
27 virtual ~PrinterHelper();
28 virtual bool handledStmt(Stmt* E, raw_ostream& OS) = 0;
29};
30
31/// Callbacks to use to customize the behavior of the pretty-printer.
33protected:
34 ~PrintingCallbacks() = default;
35
36public:
37 /// Remap a path to a form suitable for printing.
38 virtual std::string remapPath(StringRef Path) const {
39 return std::string(Path);
40 }
41
42 /// When printing type to be inserted into code in specific context, this
43 /// callback can be used to avoid printing the redundant part of the
44 /// qualifier. For example, when inserting code inside namespace foo, we
45 /// should print bar::SomeType instead of foo::bar::SomeType.
46 /// To do this, shouldPrintScope should return true on "foo" NamespaceDecl.
47 /// The printing stops at the first isScopeVisible() == true, so there will
48 /// be no calls with outer scopes.
49 virtual bool isScopeVisible(const DeclContext *DC) const { return false; }
50};
51
52/// Describes how types, statements, expressions, and declarations should be
53/// printed.
54///
55/// This type is intended to be small and suitable for passing by value.
56/// It is very frequently copied.
59
60 /// Create a default printing policy for the specified language.
76 MSWChar(LO.MicrosoftExt && !LO.WChar), IncludeNewlines(true),
83
84 /// Adjust this printing policy for cases where it's known that we're
85 /// printing C++ code (for instance, if AST dumping reaches a C++-only
86 /// construct). This should not be used if a real LangOptions object is
87 /// available.
89 SuppressTagKeyword = true;
90 Bool = true;
92 }
93
94 /// The number of spaces to use to indent each line.
95 unsigned Indentation : 8;
96
97 /// Whether we should suppress printing of the actual specifiers for
98 /// the given type or declaration.
99 ///
100 /// This flag is only used when we are printing declarators beyond
101 /// the first declarator within a declaration group. For example, given:
102 ///
103 /// \code
104 /// const int *x, *y;
105 /// \endcode
106 ///
107 /// SuppressSpecifiers will be false when printing the
108 /// declaration for "x", so that we will print "int *x"; it will be
109 /// \c true when we print "y", so that we suppress printing the
110 /// "const int" type specifier and instead only print the "*y".
111 LLVM_PREFERRED_TYPE(bool)
113
114 /// Whether type printing should skip printing the tag keyword.
115 ///
116 /// This is used when printing the inner type of elaborated types,
117 /// (as the tag keyword is part of the elaborated type):
118 ///
119 /// \code
120 /// struct Geometry::Point;
121 /// \endcode
122 LLVM_PREFERRED_TYPE(bool)
123 unsigned SuppressTagKeyword : 1;
124
125 /// When true, include the body of a tag definition.
126 ///
127 /// This is used to place the definition of a struct
128 /// in the middle of another declaration as with:
129 ///
130 /// \code
131 /// typedef struct { int x, y; } Point;
132 /// \endcode
133 LLVM_PREFERRED_TYPE(bool)
135
136 /// Suppresses printing of scope specifiers.
137 LLVM_PREFERRED_TYPE(bool)
138 unsigned SuppressScope : 1;
139
140 /// Suppress printing parts of scope specifiers that are never
141 /// written, e.g., for anonymous namespaces.
142 LLVM_PREFERRED_TYPE(bool)
144
145 /// Suppress printing parts of scope specifiers that correspond
146 /// to inline namespaces.
147 /// If Redundant, where the name is unambiguous with the specifier removed.
148 /// If All, even if the name is ambiguous with the specifier
149 /// removed.
150 LLVM_PREFERRED_TYPE(SuppressInlineNamespaceMode)
152
153 /// Suppress printing of variable initializers.
154 ///
155 /// This flag is used when printing the loop variable in a for-range
156 /// statement. For example, given:
157 ///
158 /// \code
159 /// for (auto x : coll)
160 /// \endcode
161 ///
162 /// SuppressInitializers will be true when printing "auto x", so that the
163 /// internal initializer constructed for x will not be printed.
164 LLVM_PREFERRED_TYPE(bool)
166
167 /// Whether we should print the sizes of constant array expressions as written
168 /// in the sources.
169 ///
170 /// This flag determines whether array types declared as
171 ///
172 /// \code
173 /// int a[4+10*10];
174 /// char a[] = "A string";
175 /// \endcode
176 ///
177 /// will be printed as written or as follows:
178 ///
179 /// \code
180 /// int a[104];
181 /// char a[9] = "A string";
182 /// \endcode
183 LLVM_PREFERRED_TYPE(bool)
185
186 /// When printing an anonymous tag name, also print the location of that
187 /// entity (e.g., "enum <anonymous at t.h:10:5>"). Otherwise, just prints
188 /// "(anonymous)" for the name.
189 LLVM_PREFERRED_TYPE(bool)
191
192 /// When true, suppress printing of the __strong lifetime qualifier in ARC.
193 LLVM_PREFERRED_TYPE(bool)
195
196 /// When true, suppress printing of lifetime qualifier in ARC.
197 LLVM_PREFERRED_TYPE(bool)
199
200 /// When true, suppresses printing template arguments in names of C++
201 /// constructors.
202 LLVM_PREFERRED_TYPE(bool)
204
205 /// When true, attempt to suppress template arguments that match the default
206 /// argument for the parameter.
207 LLVM_PREFERRED_TYPE(bool)
209
210 /// Whether we can use 'bool' rather than '_Bool' (even if the language
211 /// doesn't actually have 'bool', because, e.g., it is defined as a macro).
212 LLVM_PREFERRED_TYPE(bool)
213 unsigned Bool : 1;
214
215 /// Whether we should use 'nullptr' rather than '0' as a null pointer
216 /// constant.
217 LLVM_PREFERRED_TYPE(bool)
218 unsigned Nullptr : 1;
219
220 /// Whether 'nullptr_t' is in namespace 'std' or not.
221 LLVM_PREFERRED_TYPE(bool)
223
224 /// Whether we can use 'restrict' rather than '__restrict'.
225 LLVM_PREFERRED_TYPE(bool)
226 unsigned Restrict : 1;
227
228 /// Whether we can use 'alignof' rather than '__alignof'.
229 LLVM_PREFERRED_TYPE(bool)
230 unsigned Alignof : 1;
231
232 /// Whether we can use '_Alignof' rather than '__alignof'.
233 LLVM_PREFERRED_TYPE(bool)
234 unsigned UnderscoreAlignof : 1;
235
236 /// Whether we should use '(void)' rather than '()' for a function prototype
237 /// with zero parameters.
238 LLVM_PREFERRED_TYPE(bool)
240
241 /// Whether nested templates must be closed like 'a<b<c> >' rather than
242 /// 'a<b<c>>'.
243 LLVM_PREFERRED_TYPE(bool)
245
246 /// Provide a 'terse' output.
247 ///
248 /// For example, in this mode we don't print function bodies, class members,
249 /// declarations inside namespaces etc. Effectively, this should print
250 /// only the requested declaration.
251 LLVM_PREFERRED_TYPE(bool)
252 unsigned TerseOutput : 1;
253
254 /// When true, do certain refinement needed for producing proper declaration
255 /// tag; such as, do not print attributes attached to the declaration.
256 ///
257 LLVM_PREFERRED_TYPE(bool)
259
260 /// When true, print the half-precision floating-point type as 'half'
261 /// instead of '__fp16'
262 LLVM_PREFERRED_TYPE(bool)
263 unsigned Half : 1;
264
265 /// When true, print the built-in wchar_t type as __wchar_t. For use in
266 /// Microsoft mode when wchar_t is not available.
267 LLVM_PREFERRED_TYPE(bool)
268 unsigned MSWChar : 1;
269
270 /// When true, include newlines after statements like "break", etc.
271 LLVM_PREFERRED_TYPE(bool)
272 unsigned IncludeNewlines : 1;
273
274 /// Use whitespace and punctuation like MSVC does. In particular, this prints
275 /// anonymous namespaces as `anonymous namespace' and does not insert spaces
276 /// after template arguments.
277 LLVM_PREFERRED_TYPE(bool)
278 unsigned MSVCFormatting : 1;
279
280 /// Whether we should print the constant expressions as written in the
281 /// sources.
282 ///
283 /// This flag determines whether constants expressions like
284 ///
285 /// \code
286 /// 0x10
287 /// 2.5e3
288 /// \endcode
289 ///
290 /// will be printed as written or as follows:
291 ///
292 /// \code
293 /// 0x10
294 /// 2.5e3
295 /// \endcode
296 LLVM_PREFERRED_TYPE(bool)
297 unsigned ConstantsAsWritten : 1;
298
299 /// When true, don't print the implicit 'self' or 'this' expressions.
300 LLVM_PREFERRED_TYPE(bool)
302
303 /// When true, print the fully qualified name of function declarations.
304 /// This is the opposite of SuppressScope and thus overrules it.
305 LLVM_PREFERRED_TYPE(bool)
306 unsigned FullyQualifiedName : 1;
307
308 /// Whether to print entities as written or canonically.
309 LLVM_PREFERRED_TYPE(bool)
310 unsigned PrintAsCanonical : 1;
311
312 /// Whether to print an InjectedClassNameType with template arguments or as
313 /// written. When a template argument is unnamed, printing it results in
314 /// invalid C++ code.
315 LLVM_PREFERRED_TYPE(bool)
317
318 /// Whether to use C++ template preferred_name attributes when printing
319 /// templates.
320 LLVM_PREFERRED_TYPE(bool)
321 unsigned UsePreferredNames : 1;
322
323 /// Whether to use type suffixes (eg: 1U) on integral non-type template
324 /// parameters.
325 LLVM_PREFERRED_TYPE(bool)
327
328 /// Whether to strip underscores when printing reserved parameter names.
329 /// e.g. std::vector<class _Tp> becomes std::vector<class Tp>.
330 /// This only affects parameter names, and so describes a compatible API.
331 LLVM_PREFERRED_TYPE(bool)
333
334 /// Whether to print the entire array initializers, especially on non-type
335 /// template parameters, no matter how many elements there are.
336 LLVM_PREFERRED_TYPE(bool)
338
339 /// Whether to print enumerator non-type template parameters with a matching
340 /// enumerator name or via cast of an integer.
341 LLVM_PREFERRED_TYPE(bool)
342 unsigned UseEnumerators : 1;
343
344 /// Whether or not we're printing known HLSL code and should print HLSL
345 /// sugared types when possible.
346 LLVM_PREFERRED_TYPE(bool)
347 unsigned UseHLSLTypes : 1;
348
349 /// Callbacks to use to allow the behavior of printing to be customized.
350 const PrintingCallbacks *Callbacks = nullptr;
351};
352
353} // end namespace clang
354
355#endif
IndirectLocalPath & Path
Expr * E
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.
Defines the clang::LangOptions interface.
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1449
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:434
virtual bool handledStmt(Stmt *E, raw_ostream &OS)=0
virtual ~PrinterHelper()
Callbacks to use to customize the behavior of the pretty-printer.
Definition: PrettyPrinter.h:32
virtual std::string remapPath(StringRef Path) const
Remap a path to a form suitable for printing.
Definition: PrettyPrinter.h:38
virtual bool isScopeVisible(const DeclContext *DC) const
When printing type to be inserted into code in specific context, this callback can be used to avoid p...
Definition: PrettyPrinter.h:49
Stmt - This represents one statement.
Definition: Stmt.h:85
The JSON file list parser is used to communicate input to InstallAPI.
@ CPlusPlus
Definition: LangStandard.h:55
@ CPlusPlus11
Definition: LangStandard.h:56
#define true
Definition: stdbool.h:25
#define false
Definition: stdbool.h:26
Describes how types, statements, expressions, and declarations should be printed.
Definition: PrettyPrinter.h:57
unsigned SuppressUnwrittenScope
Suppress printing parts of scope specifiers that are never written, e.g., for anonymous namespaces.
unsigned FullyQualifiedName
When true, print the fully qualified name of function declarations.
unsigned MSVCFormatting
Use whitespace and punctuation like MSVC does.
unsigned SuppressDefaultTemplateArgs
When true, attempt to suppress template arguments that match the default argument for the parameter.
unsigned SplitTemplateClosers
Whether nested templates must be closed like 'a<b<c> >' rather than 'a<b<c>>'.
unsigned PolishForDeclaration
When true, do certain refinement needed for producing proper declaration tag; such as,...
unsigned PrintInjectedClassNameWithArguments
Whether to print an InjectedClassNameType with template arguments or as written.
void adjustForCPlusPlus()
Adjust this printing policy for cases where it's known that we're printing C++ code (for instance,...
Definition: PrettyPrinter.h:88
unsigned UseVoidForZeroParams
Whether we should use '(void)' rather than '()' for a function prototype with zero parameters.
unsigned Alignof
Whether we can use 'alignof' rather than '__alignof'.
unsigned AnonymousTagLocations
When printing an anonymous tag name, also print the location of that entity (e.g.,...
unsigned CleanUglifiedParameters
Whether to strip underscores when printing reserved parameter names.
unsigned SuppressSpecifiers
Whether we should suppress printing of the actual specifiers for the given type or declaration.
unsigned Nullptr
Whether we should use 'nullptr' rather than '0' as a null pointer constant.
unsigned ConstantArraySizeAsWritten
Whether we should print the sizes of constant array expressions as written in the sources.
unsigned SuppressTagKeyword
Whether type printing should skip printing the tag keyword.
unsigned AlwaysIncludeTypeForTemplateArgument
Whether to use type suffixes (eg: 1U) on integral non-type template parameters.
unsigned Bool
Whether we can use 'bool' rather than '_Bool' (even if the language doesn't actually have 'bool',...
unsigned UsePreferredNames
Whether to use C++ template preferred_name attributes when printing templates.
unsigned SuppressStrongLifetime
When true, suppress printing of the __strong lifetime qualifier in ARC.
unsigned Restrict
Whether we can use 'restrict' rather than '__restrict'.
unsigned UseEnumerators
Whether to print enumerator non-type template parameters with a matching enumerator name or via cast ...
unsigned UseHLSLTypes
Whether or not we're printing known HLSL code and should print HLSL sugared types when possible.
unsigned NullptrTypeInNamespace
Whether 'nullptr_t' is in namespace 'std' or not.
unsigned SuppressInlineNamespace
Suppress printing parts of scope specifiers that correspond to inline namespaces.
unsigned SuppressScope
Suppresses printing of scope specifiers.
unsigned EntireContentsOfLargeArray
Whether to print the entire array initializers, especially on non-type template parameters,...
const PrintingCallbacks * Callbacks
Callbacks to use to allow the behavior of printing to be customized.
unsigned ConstantsAsWritten
Whether we should print the constant expressions as written in the sources.
unsigned IncludeNewlines
When true, include newlines after statements like "break", etc.
unsigned Indentation
The number of spaces to use to indent each line.
Definition: PrettyPrinter.h:95
unsigned Half
When true, print the half-precision floating-point type as 'half' instead of '__fp16'.
PrintingPolicy(const LangOptions &LO)
Create a default printing policy for the specified language.
Definition: PrettyPrinter.h:61
unsigned SuppressInitializers
Suppress printing of variable initializers.
unsigned IncludeTagDefinition
When true, include the body of a tag definition.
unsigned TerseOutput
Provide a 'terse' output.
unsigned SuppressTemplateArgsInCXXConstructors
When true, suppresses printing template arguments in names of C++ constructors.
unsigned PrintAsCanonical
Whether to print entities as written or canonically.
unsigned UnderscoreAlignof
Whether we can use '_Alignof' rather than '__alignof'.
unsigned MSWChar
When true, print the built-in wchar_t type as __wchar_t.
unsigned SuppressImplicitBase
When true, don't print the implicit 'self' or 'this' expressions.
unsigned SuppressLifetimeQualifiers
When true, suppress printing of lifetime qualifier in ARC.