clang  6.0.0svn
ASTSelection.h
Go to the documentation of this file.
1 //===--- ASTSelection.h - Clang refactoring library -----------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #ifndef LLVM_CLANG_TOOLING_REFACTOR_AST_SELECTION_H
11 #define LLVM_CLANG_TOOLING_REFACTOR_AST_SELECTION_H
12 
14 #include "clang/Basic/LLVM.h"
16 #include <vector>
17 
18 namespace clang {
19 
20 class ASTContext;
21 
22 namespace tooling {
23 
24 enum class SourceSelectionKind {
25  /// A node that's not selected.
26  None,
27 
28  /// A node that's considered to be selected because the whole selection range
29  /// is inside of its source range.
31  /// A node that's considered to be selected because the start of the selection
32  /// range is inside its source range.
34  /// A node that's considered to be selected because the end of the selection
35  /// range is inside its source range.
37 
38  /// A node that's considered to be selected because the node is entirely in
39  /// the selection range.
41 };
42 
43 /// Represents a selected AST node.
44 ///
45 /// AST selection is represented using a tree of \c SelectedASTNode. The tree
46 /// follows the top-down shape of the actual AST. Each selected node has
47 /// a selection kind. The kind might be none as the node itself might not
48 /// actually be selected, e.g. a statement in macro whose child is in a macro
49 /// argument.
53  std::vector<SelectedASTNode> Children;
54 
56  SourceSelectionKind SelectionKind)
57  : Node(Node), SelectionKind(SelectionKind) {}
58  SelectedASTNode(SelectedASTNode &&) = default;
59  SelectedASTNode &operator=(SelectedASTNode &&) = default;
60 
61  void dump(llvm::raw_ostream &OS = llvm::errs()) const;
62 
63  using ReferenceType = std::reference_wrapper<const SelectedASTNode>;
64 };
65 
66 /// Traverses the given ASTContext and creates a tree of selected AST nodes.
67 ///
68 /// \returns None if no nodes are selected in the AST, or a selected AST node
69 /// that corresponds to the TranslationUnitDecl otherwise.
71  SourceRange SelectionRange);
72 
73 /// An AST selection value that corresponds to a selection of a set of
74 /// statements that belong to one body of code (like one function).
75 ///
76 /// For example, the following selection in the source.
77 ///
78 /// \code
79 /// void function() {
80 /// // selection begin:
81 /// int x = 0;
82 /// {
83 /// // selection end
84 /// x = 1;
85 /// }
86 /// x = 2;
87 /// }
88 /// \endcode
89 ///
90 /// Would correspond to a code range selection of statements "int x = 0"
91 /// and the entire compound statement that follows it.
92 ///
93 /// A \c CodeRangeASTSelection value stores references to the full
94 /// \c SelectedASTNode tree and should not outlive it.
96 public:
98  CodeRangeASTSelection &operator=(CodeRangeASTSelection &&) = default;
99 
100  /// Returns the parent hierarchy (top to bottom) for the selected nodes.
102 
103  /// Returns the number of selected statements.
104  size_t size() const {
105  if (!AreChildrenSelected)
106  return 1;
107  return SelectedNode.get().Children.size();
108  }
109 
110  const Stmt *operator[](size_t I) const {
111  if (!AreChildrenSelected) {
112  assert(I == 0 && "Invalid index");
113  return SelectedNode.get().Node.get<Stmt>();
114  }
115  return SelectedNode.get().Children[I].Node.get<Stmt>();
116  }
117 
118  /// Returns true when a selected code range is in a function-like body
119  /// of code, like a function, method or a block.
120  ///
121  /// This function can be used to test against selected expressions that are
122  /// located outside of a function, e.g. global variable initializers, default
123  /// argument values, or even template arguments.
124  ///
125  /// Use the \c getFunctionLikeNearestParent to get the function-like parent
126  /// declaration.
127  bool isInFunctionLikeBodyOfCode() const;
128 
129  /// Returns the nearest function-like parent declaration or null if such
130  /// declaration doesn't exist.
131  const Decl *getFunctionLikeNearestParent() const;
132 
134  create(SourceRange SelectionRange, const SelectedASTNode &ASTSelection);
135 
136 private:
139  bool AreChildrenSelected)
140  : SelectedNode(SelectedNode), Parents(Parents.begin(), Parents.end()),
141  AreChildrenSelected(AreChildrenSelected) {}
142 
143  /// The reference to the selected node (or reference to the selected
144  /// child nodes).
145  SelectedASTNode::ReferenceType SelectedNode;
146  /// The parent hierarchy (top to bottom) for the selected noe.
148  /// True only when the children of the selected node are actually selected.
149  bool AreChildrenSelected;
150 };
151 
152 } // end namespace tooling
153 } // end namespace clang
154 
155 #endif // LLVM_CLANG_TOOLING_REFACTOR_AST_SELECTION_H
Represents a selected AST node.
Definition: ASTSelection.h:50
Stmt - This represents one statement.
Definition: Stmt.h:66
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:86
ArrayRef< SelectedASTNode::ReferenceType > getParents()
Returns the parent hierarchy (top to bottom) for the selected nodes.
Definition: ASTSelection.h:101
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:149
SelectedASTNode(const ast_type_traits::DynTypedNode &Node, SourceSelectionKind SelectionKind)
Definition: ASTSelection.h:55
A node that&#39;s considered to be selected because the whole selection range is inside of its source ran...
Optional< SelectedASTNode > findSelectedASTNodes(const ASTContext &Context, SourceRange SelectionRange)
Traverses the given ASTContext and creates a tree of selected AST nodes.
static void dump(llvm::raw_ostream &OS, StringRef FunctionName, ArrayRef< CounterExpression > Expressions, ArrayRef< CounterMappingRegion > Regions)
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified...
ast_type_traits::DynTypedNode Node
Definition: ASTSelection.h:51
const Stmt * operator[](size_t I) const
Definition: ASTSelection.h:110
An AST selection value that corresponds to a selection of a set of statements that belong to one body...
Definition: ASTSelection.h:95
A node that&#39;s considered to be selected because the start of the selection range is inside its source...
A node that&#39;s considered to be selected because the node is entirely in the selection range...
Dataflow Directional Tag Classes.
A node that&#39;s considered to be selected because the end of the selection range is inside its source r...
std::unique_ptr< DiagnosticConsumer > create(StringRef OutputFile, DiagnosticOptions *Diags, bool MergeChildRecords=false)
Returns a DiagnosticConsumer that serializes diagnostics to a bitcode file.
size_t size() const
Returns the number of selected statements.
Definition: ASTSelection.h:104
A dynamically typed AST node container.
SourceSelectionKind SelectionKind
Definition: ASTSelection.h:52
Defines the clang::SourceLocation class and associated facilities.
std::reference_wrapper< const SelectedASTNode > ReferenceType
Definition: ASTSelection.h:63
std::vector< SelectedASTNode > Children
Definition: ASTSelection.h:53
A node that&#39;s not selected.
A trivial tuple used to represent a source range.