Skip to content

Commit a770356

Browse files
ahoppenahoppen
committed
[libSyntax] Inline commonly called methods in ParsedRawSyntaxRecorder
1 parent e1e0f54 commit a770356

File tree

2 files changed

+98
-113
lines changed

2 files changed

+98
-113
lines changed

‎include/swift/Parse/ParsedRawSyntaxRecorder.h

Lines changed: 98 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -21,8 +21,24 @@
2121

2222
#include "swift/Basic/LLVM.h"
2323
#include "swift/Parse/ParsedRawSyntaxNode.h"
24+
#include "swift/Parse/SyntaxParseActions.h"
25+
#include "swift/SyntaxParse/SyntaxTreeCreator.h"
2426
#include <memory>
2527

28+
/// Define a macro that creates a \c ParsedRawSyntaxNode. If \c
29+
/// PARSEDRAWSYNTAXNODE_VERIFY_RANGES is defined, it passes the \c Range
30+
/// parameter, otherwise it ignores it at the pre-processor level, which means
31+
/// that \c Range can be an invalid expression.
32+
#ifdef PARSEDRAWSYNTAXNODE_VERIFY_RANGES
33+
#define makeParsedRawSyntaxNode(Opaque, SynKind, TokKind, DataKind, IsMissing, \
34+
Range) \
35+
ParsedRawSyntaxNode(Opaque, SynKind, TokKind, DataKind, IsMissing, Range)
36+
#else
37+
#define makeParsedRawSyntaxNode(Opaque, SynKind, TokKind, DataKind, IsMissing, \
38+
Range) \
39+
ParsedRawSyntaxNode(Opaque, SynKind, TokKind, DataKind, IsMissing)
40+
#endif
41+
2642
namespace swift {
2743

2844
class CharSourceRange;
@@ -57,18 +73,50 @@ class ParsedRawSyntaxRecorder final {
5773
/// return the recorded node.
5874
/// This consumes the data from \c node, which is unusable after it has been
5975
/// recorded. The returned node should be used afterwards instead.
60-
ParsedRawSyntaxNode recordDeferredNode(ParsedRawSyntaxNode &node);
76+
ParsedRawSyntaxNode recordDeferredNode(ParsedRawSyntaxNode &node) {
77+
switch (node.getDataKind()) {
78+
case RecordedOrDeferredNode::Kind::Null:
79+
case RecordedOrDeferredNode::Kind::Recorded:
80+
llvm_unreachable("Not deferred");
81+
case RecordedOrDeferredNode::Kind::DeferredLayout: {
82+
OpaqueSyntaxNode Data = SPActions->recordDeferredLayout(node.takeData());
83+
return makeParsedRawSyntaxNode(Data, node.getKind(), node.getTokenKind(),
84+
ParsedRawSyntaxNode::DataKind::Recorded,
85+
node.isMissing(), node.getRange());
86+
}
87+
case RecordedOrDeferredNode::Kind::DeferredToken: {
88+
OpaqueSyntaxNode Data = SPActions->recordDeferredToken(node.takeData());
89+
return makeParsedRawSyntaxNode(Data, node.getKind(), node.getTokenKind(),
90+
ParsedRawSyntaxNode::DataKind::Recorded,
91+
node.isMissing(), node.getRange());
92+
}
93+
}
94+
}
6195

6296
public:
6397
explicit ParsedRawSyntaxRecorder(std::shared_ptr<SyntaxParseActions> spActions)
6498
: SPActions(std::move(spActions)) {}
6599

66100
ParsedRawSyntaxNode recordToken(const Token &tok, StringRef leadingTrivia,
67-
StringRef trailingTrivia);
101+
StringRef trailingTrivia) {
102+
return recordToken(tok.getKind(), tok.getRange(), leadingTrivia,
103+
trailingTrivia);
104+
}
68105

69106
ParsedRawSyntaxNode recordToken(tok tokenKind, CharSourceRange tokenRange,
70107
StringRef leadingTrivia,
71-
StringRef trailingTrivia);
108+
StringRef trailingTrivia) {
109+
SourceLoc offset =
110+
tokenRange.getStart().getAdvancedLoc(-leadingTrivia.size());
111+
unsigned length = leadingTrivia.size() + tokenRange.getByteLength() +
112+
trailingTrivia.size();
113+
CharSourceRange range(offset, length);
114+
OpaqueSyntaxNode n =
115+
SPActions->recordToken(tokenKind, leadingTrivia, trailingTrivia, range);
116+
return makeParsedRawSyntaxNode(n, syntax::SyntaxKind::Token, tokenKind,
117+
ParsedRawSyntaxNode::DataKind::Recorded,
118+
/*IsMissing=*/false, range);
119+
}
72120

73121
/// Record a missing token. \p loc can be invalid or an approximate location
74122
/// of where the token would be if not missing.
@@ -77,8 +125,39 @@ class ParsedRawSyntaxRecorder final {
77125
/// The provided \p elements are an exact layout appropriate for the syntax
78126
/// \p kind. Missing optional elements are represented with a null
79127
/// ParsedRawSyntaxNode object.
80-
ParsedRawSyntaxNode recordRawSyntax(syntax::SyntaxKind kind,
81-
MutableArrayRef<ParsedRawSyntaxNode> elements);
128+
ParsedRawSyntaxNode
129+
recordRawSyntax(syntax::SyntaxKind kind,
130+
MutableArrayRef<ParsedRawSyntaxNode> elements) {
131+
assert(kind != syntax::SyntaxKind::Token &&
132+
"Use recordToken to record a token");
133+
#ifdef PARSEDRAWSYNTAXNODE_VERIFY_RANGES
134+
auto range = ParsedRawSyntaxRecorder::verifyElementRanges(elements);
135+
#endif
136+
137+
SmallVector<OpaqueSyntaxNode, 16> subnodes;
138+
if (!elements.empty()) {
139+
for (auto &subnode : elements) {
140+
switch (subnode.getDataKind()) {
141+
case RecordedOrDeferredNode::Kind::Null:
142+
subnodes.push_back(nullptr);
143+
break;
144+
case RecordedOrDeferredNode::Kind::Recorded:
145+
subnodes.push_back(subnode.takeData());
146+
break;
147+
case RecordedOrDeferredNode::Kind::DeferredLayout:
148+
case RecordedOrDeferredNode::Kind::DeferredToken: {
149+
auto recorded = recordDeferredNode(subnode);
150+
subnodes.push_back(recorded.takeData());
151+
break;
152+
}
153+
}
154+
}
155+
}
156+
OpaqueSyntaxNode n = SPActions->recordRawSyntax(kind, subnodes);
157+
return makeParsedRawSyntaxNode(n, kind, tok::NUM_TOKENS,
158+
ParsedRawSyntaxNode::DataKind::Recorded,
159+
/*IsMissing=*/false, range);
160+
}
82161

83162
/// Record a raw syntax collecton without eny elements. \p loc can be invalid
84163
/// or an approximate location of where an element of the collection would be
@@ -98,7 +177,20 @@ class ParsedRawSyntaxRecorder final {
98177

99178
/// Form a deferred token node.
100179
ParsedRawSyntaxNode makeDeferred(Token tok, StringRef leadingTrivia,
101-
StringRef trailingTrivia);
180+
StringRef trailingTrivia) {
181+
CharSourceRange tokRange = tok.getRange();
182+
CharSourceRange RangeWithTrivia = CharSourceRange(
183+
tokRange.getStart().getAdvancedLoc(-leadingTrivia.size()),
184+
(unsigned)leadingTrivia.size() + tokRange.getByteLength() +
185+
(unsigned)trailingTrivia.size());
186+
auto Data = SPActions->makeDeferredToken(tok.getKind(), leadingTrivia,
187+
trailingTrivia, RangeWithTrivia,
188+
/*IsMissing=*/false);
189+
return makeParsedRawSyntaxNode(Data, syntax::SyntaxKind::Token,
190+
tok.getKind(),
191+
ParsedRawSyntaxNode::DataKind::DeferredToken,
192+
/*IsMissing=*/false, RangeWithTrivia);
193+
}
102194

103195
/// Form a deferred missing token node.
104196
ParsedRawSyntaxNode makeDeferredMissing(tok tokKind, SourceLoc loc);

‎lib/Parse/ParsedRawSyntaxRecorder.cpp

Lines changed: 0 additions & 107 deletions
Original file line numberDiff line numberDiff line change
@@ -27,63 +27,6 @@
2727
using namespace swift;
2828
using namespace swift::syntax;
2929

30-
/// Define a macro that creates a \c ParsedRawSyntaxNode. If \c
31-
/// PARSEDRAWSYNTAXNODE_VERIFY_RANGES is defined, it passes the \c Range
32-
/// parameter, otherwise it ignores it at the pre-processor level, which means
33-
/// that \c Range can be an invalid expression.
34-
#ifdef PARSEDRAWSYNTAXNODE_VERIFY_RANGES
35-
#define makeParsedRawSyntaxNode(Opaque, SynKind, TokKind, DataKind, IsMissing, \
36-
Range) \
37-
ParsedRawSyntaxNode(Opaque, SynKind, TokKind, DataKind, IsMissing, Range)
38-
#else
39-
#define makeParsedRawSyntaxNode(Opaque, SynKind, TokKind, DataKind, IsMissing, \
40-
Range) \
41-
ParsedRawSyntaxNode(Opaque, SynKind, TokKind, DataKind, IsMissing)
42-
#endif
43-
44-
ParsedRawSyntaxNode
45-
ParsedRawSyntaxRecorder::recordDeferredNode(ParsedRawSyntaxNode &node) {
46-
switch (node.getDataKind()) {
47-
case RecordedOrDeferredNode::Kind::Null:
48-
case RecordedOrDeferredNode::Kind::Recorded:
49-
llvm_unreachable("Not deferred");
50-
case RecordedOrDeferredNode::Kind::DeferredLayout: {
51-
OpaqueSyntaxNode Data = SPActions->recordDeferredLayout(node.takeData());
52-
return makeParsedRawSyntaxNode(Data, node.getKind(), node.getTokenKind(),
53-
ParsedRawSyntaxNode::DataKind::Recorded,
54-
node.isMissing(), node.getRange());
55-
}
56-
case RecordedOrDeferredNode::Kind::DeferredToken: {
57-
OpaqueSyntaxNode Data = SPActions->recordDeferredToken(node.takeData());
58-
return makeParsedRawSyntaxNode(Data, node.getKind(), node.getTokenKind(),
59-
ParsedRawSyntaxNode::DataKind::Recorded,
60-
node.isMissing(), node.getRange());
61-
}
62-
}
63-
}
64-
65-
ParsedRawSyntaxNode
66-
ParsedRawSyntaxRecorder::recordToken(const Token &tok, StringRef leadingTrivia,
67-
StringRef trailingTrivia) {
68-
return recordToken(tok.getKind(), tok.getRange(), leadingTrivia,
69-
trailingTrivia);
70-
}
71-
72-
ParsedRawSyntaxNode
73-
ParsedRawSyntaxRecorder::recordToken(tok tokKind, CharSourceRange tokRange,
74-
StringRef leadingTrivia,
75-
StringRef trailingTrivia) {
76-
SourceLoc offset = tokRange.getStart().getAdvancedLoc(-leadingTrivia.size());
77-
unsigned length =
78-
leadingTrivia.size() + tokRange.getByteLength() + trailingTrivia.size();
79-
CharSourceRange range(offset, length);
80-
OpaqueSyntaxNode n =
81-
SPActions->recordToken(tokKind, leadingTrivia, trailingTrivia, range);
82-
return makeParsedRawSyntaxNode(n, SyntaxKind::Token, tokKind,
83-
ParsedRawSyntaxNode::DataKind::Recorded,
84-
/*IsMissing=*/false, range);
85-
}
86-
8730
ParsedRawSyntaxNode
8831
ParsedRawSyntaxRecorder::recordMissingToken(tok tokenKind, SourceLoc loc) {
8932
OpaqueSyntaxNode n = SPActions->recordMissingToken(tokenKind, loc);
@@ -92,39 +35,6 @@ ParsedRawSyntaxRecorder::recordMissingToken(tok tokenKind, SourceLoc loc) {
9235
/*isMissing=*/true, CharSourceRange(loc, 0));
9336
}
9437

95-
ParsedRawSyntaxNode
96-
ParsedRawSyntaxRecorder::recordRawSyntax(SyntaxKind kind,
97-
MutableArrayRef<ParsedRawSyntaxNode> elements) {
98-
assert(kind != SyntaxKind::Token && "Use recordToken to record a token");
99-
#ifdef PARSEDRAWSYNTAXNODE_VERIFY_RANGES
100-
auto range = ParsedRawSyntaxRecorder::verifyElementRanges(elements);
101-
#endif
102-
103-
SmallVector<OpaqueSyntaxNode, 16> subnodes;
104-
if (!elements.empty()) {
105-
for (auto &subnode : elements) {
106-
switch (subnode.getDataKind()) {
107-
case RecordedOrDeferredNode::Kind::Null:
108-
subnodes.push_back(nullptr);
109-
break;
110-
case RecordedOrDeferredNode::Kind::Recorded:
111-
subnodes.push_back(subnode.takeData());
112-
break;
113-
case RecordedOrDeferredNode::Kind::DeferredLayout:
114-
case RecordedOrDeferredNode::Kind::DeferredToken: {
115-
auto recorded = recordDeferredNode(subnode);
116-
subnodes.push_back(recorded.takeData());
117-
break;
118-
}
119-
}
120-
}
121-
}
122-
OpaqueSyntaxNode n = SPActions->recordRawSyntax(kind, subnodes);
123-
return makeParsedRawSyntaxNode(n, kind, tok::NUM_TOKENS,
124-
ParsedRawSyntaxNode::DataKind::Recorded,
125-
/*IsMissing=*/false, range);
126-
}
127-
12838
ParsedRawSyntaxNode
12939
ParsedRawSyntaxRecorder::recordEmptyRawSyntaxCollection(SyntaxKind kind,
13040
SourceLoc loc) {
@@ -159,23 +69,6 @@ ParsedRawSyntaxNode ParsedRawSyntaxRecorder::makeDeferred(
15969
/*IsMissing=*/false, range);
16070
}
16171

162-
/// Create a deferred token node.
163-
ParsedRawSyntaxNode
164-
ParsedRawSyntaxRecorder::makeDeferred(Token tok, StringRef leadingTrivia,
165-
StringRef trailingTrivia) {
166-
CharSourceRange tokRange = tok.getRange();
167-
CharSourceRange RangeWithTrivia = CharSourceRange(
168-
tokRange.getStart().getAdvancedLoc(-leadingTrivia.size()),
169-
(unsigned)leadingTrivia.size() + tokRange.getByteLength() +
170-
(unsigned)trailingTrivia.size());
171-
auto Data =
172-
SPActions->makeDeferredToken(tok.getKind(), leadingTrivia, trailingTrivia,
173-
RangeWithTrivia, /*IsMissing=*/false);
174-
return makeParsedRawSyntaxNode(Data, SyntaxKind::Token, tok.getKind(),
175-
ParsedRawSyntaxNode::DataKind::DeferredToken,
176-
/*IsMissing=*/false, RangeWithTrivia);
177-
}
178-
17972
ParsedRawSyntaxNode
18073
ParsedRawSyntaxRecorder::makeDeferredMissing(tok tokKind, SourceLoc loc) {
18174
auto Data = SPActions->makeDeferredToken(

0 commit comments

Comments
 (0)