Coverage Report

Created: 2020-02-25 14:32

/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/include/clang/Tooling/Transformer/SourceCodeBuilders.h
Line
Count
Source
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_SOURCE_CODE_BUILDERS_H_
15
#define LLVM_CLANG_TOOLING_TRANSFORMER_SOURCE_CODE_BUILDERS_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
16
inline bool needParensBeforeDotOrArrow(const Expr &E) {
40
16
  return mayEverNeedParens(E);
41
16
}
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
48
/// \name Basic code-string generation utilities.
49
/// @{
50
51
/// Builds source for an expression, adding parens if needed for unambiguous
52
/// parsing.
53
llvm::Optional<std::string> buildParens(const Expr &E,
54
                                        const ASTContext &Context);
55
56
/// Builds idiomatic source for the dereferencing of `E`: prefix with `*` but
57
/// simplify when it already begins with `&`.  \returns empty string on failure.
58
llvm::Optional<std::string> buildDereference(const Expr &E,
59
                                             const ASTContext &Context);
60
61
/// Builds idiomatic source for taking the address of `E`: prefix with `&` but
62
/// simplify when it already begins with `*`.  \returns empty string on failure.
63
llvm::Optional<std::string> buildAddressOf(const Expr &E,
64
                                           const ASTContext &Context);
65
66
/// Adds a dot to the end of the given expression, but adds parentheses when
67
/// needed by the syntax, and simplifies to `->` when possible, e.g.:
68
///
69
///  `x` becomes `x.`
70
///  `*a` becomes `a->`
71
///  `a+b` becomes `(a+b).`
72
llvm::Optional<std::string> buildDot(const Expr &E, const ASTContext &Context);
73
74
/// Adds an arrow to the end of the given expression, but adds parentheses
75
/// when needed by the syntax, and simplifies to `.` when possible, e.g.:
76
///
77
///  `x` becomes `x->`
78
///  `&a` becomes `a.`
79
///  `a+b` becomes `(a+b)->`
80
llvm::Optional<std::string> buildArrow(const Expr &E,
81
                                       const ASTContext &Context);
82
/// @}
83
84
} // namespace tooling
85
} // namespace clang
86
#endif // LLVM_CLANG_TOOLING_TRANSFORMER_SOURCE_CODE_BUILDERS_H_