Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
14 pmbaty 1
//===--- SourceCodeBuilders.h - Source-code building facilities -*- 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
/// This file collects facilities for generating source code strings.
11
///
12
//===----------------------------------------------------------------------===//
13
 
14
#ifndef LLVM_CLANG_TOOLING_TRANSFORMER_SOURCECODEBUILDERS_H
15
#define LLVM_CLANG_TOOLING_TRANSFORMER_SOURCECODEBUILDERS_H
16
 
17
#include "clang/AST/ASTContext.h"
18
#include "clang/AST/Expr.h"
19
#include <string>
20
 
21
namespace clang {
22
namespace tooling {
23
 
24
/// \name Code analysis utilities.
25
/// @{
26
/// Ignores implicit object-construction expressions in addition to the normal
27
/// implicit expressions that are ignored.
28
const Expr *reallyIgnoreImplicit(const Expr &E);
29
 
30
/// Determines whether printing this expression in *any* expression requires
31
/// parentheses to preserve its meaning. This analyses is necessarily
32
/// conservative because it lacks information about the target context.
33
bool mayEverNeedParens(const Expr &E);
34
 
35
/// Determines whether printing this expression to the left of a dot or arrow
36
/// operator requires a parentheses to preserve its meaning. Given that
37
/// dot/arrow are (effectively) the highest precedence, this is equivalent to
38
/// asking whether it ever needs parens.
39
inline bool needParensBeforeDotOrArrow(const Expr &E) {
40
  return mayEverNeedParens(E);
41
}
42
 
43
/// Determines whether printing this expression to the right of a unary operator
44
/// requires a parentheses to preserve its meaning.
45
bool needParensAfterUnaryOperator(const Expr &E);
46
 
47
// Recognizes known types (and sugared versions thereof) that overload the `*`
48
// and `->` operator. Below is the list of currently included types, but it is
49
// subject to change:
50
//
51
// * std::unique_ptr, std::shared_ptr, std::weak_ptr,
52
// * std::optional, absl::optional, llvm::Optional,
53
// * absl::StatusOr, llvm::Expected.
54
bool isKnownPointerLikeType(QualType Ty, ASTContext &Context);
55
/// @}
56
 
57
/// \name Basic code-string generation utilities.
58
/// @{
59
 
60
/// Builds source for an expression, adding parens if needed for unambiguous
61
/// parsing.
62
std::optional<std::string> buildParens(const Expr &E,
63
                                       const ASTContext &Context);
64
 
65
/// Builds idiomatic source for the dereferencing of `E`: prefix with `*` but
66
/// simplify when it already begins with `&`.  \returns empty string on failure.
67
std::optional<std::string> buildDereference(const Expr &E,
68
                                            const ASTContext &Context);
69
 
70
/// Builds idiomatic source for taking the address of `E`: prefix with `&` but
71
/// simplify when it already begins with `*`.  \returns empty string on failure.
72
std::optional<std::string> buildAddressOf(const Expr &E,
73
                                          const ASTContext &Context);
74
 
75
/// Adds a dot to the end of the given expression, but adds parentheses when
76
/// needed by the syntax, and simplifies to `->` when possible, e.g.:
77
///
78
///  `x` becomes `x.`
79
///  `*a` becomes `a->`
80
///  `a+b` becomes `(a+b).`
81
///
82
/// DEPRECATED. Use `buildAccess`.
83
std::optional<std::string> buildDot(const Expr &E, const ASTContext &Context);
84
 
85
/// Adds an arrow to the end of the given expression, but adds parentheses
86
/// when needed by the syntax, and simplifies to `.` when possible, e.g.:
87
///
88
///  `x` becomes `x->`
89
///  `&a` becomes `a.`
90
///  `a+b` becomes `(a+b)->`
91
///
92
/// DEPRECATED. Use `buildAccess`.
93
std::optional<std::string> buildArrow(const Expr &E, const ASTContext &Context);
94
 
95
/// Specifies how to classify pointer-like types -- like values or like pointers
96
/// -- with regard to generating member-access syntax.
97
enum class PLTClass : bool {
98
  Value,
99
  Pointer,
100
};
101
 
102
/// Adds an appropriate access operator (`.`, `->` or nothing, in the case of
103
/// implicit `this`) to the end of the given expression. Adds parentheses when
104
/// needed by the syntax and simplifies when possible. If `PLTypeClass` is
105
/// `Pointer`, for known pointer-like types (see `isKnownPointerLikeType`),
106
/// treats `operator->` and `operator*` like the built-in `->` and `*`
107
/// operators.
108
///
109
///  `x` becomes `x->` or `x.`, depending on `E`'s type
110
///  `a+b` becomes `(a+b)->` or `(a+b).`, depending on `E`'s type
111
///  `&a` becomes `a.`
112
///  `*a` becomes `a->`
113
std::optional<std::string>
114
buildAccess(const Expr &E, ASTContext &Context,
115
            PLTClass Classification = PLTClass::Pointer);
116
/// @}
117
 
118
} // namespace tooling
119
} // namespace clang
120
#endif // LLVM_CLANG_TOOLING_TRANSFORMER_SOURCECODEBUILDERS_H