Skip to content

Commit 9fa1760

Browse files
rintarorintaro
committed
Revert "Merge pull request swiftlang#27406 from nathawes/add-syntax-range-assertions"
This reverts commit 325204b, reversing changes made to 066bb61.
1 parent 0165b4f commit 9fa1760

9 files changed

+84
-113
lines changed

‎include/swift/Parse/ParsedRawSyntaxNode.h

Lines changed: 15 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -109,12 +109,10 @@ class ParsedRawSyntaxNode {
109109
}
110110

111111
ParsedRawSyntaxNode(syntax::SyntaxKind k, tok tokKind,
112-
CharSourceRange r, OpaqueSyntaxNode n,
113-
bool IsMissing = false)
112+
CharSourceRange r, OpaqueSyntaxNode n)
114113
: RecordedData{n, r},
115114
SynKind(uint16_t(k)), TokKind(uint16_t(tokKind)),
116-
DK(DataKind::Recorded),
117-
IsMissing(IsMissing) {
115+
DK(DataKind::Recorded) {
118116
assert(getKind() == k && "Syntax kind with too large value!");
119117
assert(getTokenKind() == tokKind && "Token kind with too large value!");
120118
}
@@ -199,14 +197,12 @@ class ParsedRawSyntaxNode {
199197
return copy;
200198
}
201199

202-
CharSourceRange getDeferredRange(bool includeTrivia) const {
200+
CharSourceRange getDeferredRange() const {
203201
switch (DK) {
204202
case DataKind::DeferredLayout:
205-
return getDeferredLayoutRange(includeTrivia);
203+
return getDeferredLayoutRange();
206204
case DataKind::DeferredToken:
207-
return includeTrivia
208-
? getDeferredTokenRangeWithTrivia()
209-
: getDeferredTokenRange();
205+
return getDeferredTokenRange();
210206
default:
211207
llvm_unreachable("node not deferred");
212208
}
@@ -231,19 +227,18 @@ class ParsedRawSyntaxNode {
231227

232228
// Deferred Layout Data ====================================================//
233229

234-
CharSourceRange getDeferredLayoutRange(bool includeTrivia) const {
230+
CharSourceRange getDeferredLayoutRange() const {
235231
assert(DK == DataKind::DeferredLayout);
236-
auto HasValidRange = [includeTrivia](const ParsedRawSyntaxNode &Child) {
237-
return !Child.isNull() && !Child.isMissing() &&
238-
Child.getDeferredRange(includeTrivia).isValid();
232+
assert(!DeferredLayout.Children.empty());
233+
auto getLastNonNullChild = [this]() -> const ParsedRawSyntaxNode & {
234+
for (auto &Child : llvm::reverse(getDeferredChildren()))
235+
if (!Child.isNull())
236+
return Child;
237+
llvm_unreachable("layout node without non-null children");
239238
};
240-
auto first = llvm::find_if(getDeferredChildren(), HasValidRange);
241-
if (first == getDeferredChildren().end())
242-
return CharSourceRange();
243-
auto last = llvm::find_if(llvm::reverse(getDeferredChildren()),
244-
HasValidRange);
245-
auto firstRange = first->getDeferredRange(includeTrivia);
246-
firstRange.widen(last->getDeferredRange(includeTrivia));
239+
auto firstRange = DeferredLayout.Children.front().getDeferredRange();
240+
auto lastRange = getLastNonNullChild().getDeferredRange();
241+
firstRange.widen(lastRange);
247242
return firstRange;
248243
}
249244
ArrayRef<ParsedRawSyntaxNode> getDeferredChildren() const {

‎include/swift/Parse/ParsedRawSyntaxRecorder.h

Lines changed: 0 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -73,10 +73,6 @@ class ParsedRawSyntaxRecorder {
7373
/// Used for incremental re-parsing.
7474
ParsedRawSyntaxNode lookupNode(size_t lexerOffset, SourceLoc loc,
7575
syntax::SyntaxKind kind);
76-
77-
#ifndef NDEBUG
78-
static void verifyElementRanges(ArrayRef<ParsedRawSyntaxNode> elements);
79-
#endif
8076
};
8177

8278
} // end namespace swift

‎include/swift/Parse/ParsedSyntaxBuilders.h.gyb

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -62,9 +62,9 @@ public:
6262
% end
6363

6464
Parsed${node.name} build();
65+
Parsed${node.name} makeDeferred();
6566

6667
private:
67-
Parsed${node.name} makeDeferred();
6868
Parsed${node.name} record();
6969
void finishLayout(bool deferred);
7070
};

‎include/swift/Parse/ParsedSyntaxRecorder.h.gyb

Lines changed: 12 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -43,22 +43,23 @@ struct ParsedSyntaxRecorder {
4343
% end
4444
% child_params = ', '.join(child_params)
4545
private:
46-
static Parsed${node.name} record${node.syntax_kind}(MutableArrayRef<ParsedRawSyntaxNode> layout,
46+
static Parsed${node.name} record${node.syntax_kind}(${child_params},
4747
ParsedRawSyntaxRecorder &rec);
48-
static Parsed${node.name} defer${node.syntax_kind}(MutableArrayRef<ParsedRawSyntaxNode> layout,
49-
SyntaxParsingContext &SPCtx);
5048
public:
49+
static Parsed${node.name} defer${node.syntax_kind}(${child_params},
50+
SyntaxParsingContext &SPCtx);
5151
static Parsed${node.name} make${node.syntax_kind}(${child_params},
5252
SyntaxParsingContext &SPCtx);
5353
% elif node.is_syntax_collection():
5454
private:
5555
static Parsed${node.name} record${node.syntax_kind}(
56-
MutableArrayRef<ParsedRawSyntaxNode> layout,
56+
MutableArrayRef<Parsed${node.collection_element_type}> elts,
5757
ParsedRawSyntaxRecorder &rec);
58+
59+
public:
5860
static Parsed${node.name} defer${node.syntax_kind}(
59-
MutableArrayRef<ParsedRawSyntaxNode> layout,
61+
MutableArrayRef<Parsed${node.collection_element_type}> elts,
6062
SyntaxParsingContext &SPCtx);
61-
public:
6263
static Parsed${node.name} make${node.syntax_kind}(
6364
MutableArrayRef<Parsed${node.collection_element_type}> elts,
6465
SyntaxParsingContext &SPCtx);
@@ -68,12 +69,14 @@ public:
6869
% elif node.is_unknown():
6970
private:
7071
static Parsed${node.name} record${node.syntax_kind}(
71-
MutableArrayRef<ParsedRawSyntaxNode> layout,
72+
MutableArrayRef<ParsedSyntax> elts,
7273
ParsedRawSyntaxRecorder &rec);
74+
75+
public:
7376
static Parsed${node.name} defer${node.syntax_kind}(
74-
MutableArrayRef<ParsedRawSyntaxNode> layout,
77+
MutableArrayRef<ParsedSyntax> elts,
7578
SyntaxParsingContext &SPCtx);
76-
public:
79+
7780
static Parsed${node.name} make${node.syntax_kind}(
7881
MutableArrayRef<ParsedSyntax> elts,
7982
SyntaxParsingContext &SPCtx);

‎lib/Parse/ParseExpr.cpp

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1498,8 +1498,8 @@ ParserResult<Expr> Parser::parseExprPrimary(Diag<> ID, bool isExprBasic) {
14981498
ParsedSyntaxRecorder::makeIdentifierPattern(
14991499
SyntaxContext->popToken(), *SyntaxContext);
15001500
ParsedExprSyntax ExprNode =
1501-
ParsedSyntaxRecorder::makeUnresolvedPatternExpr(std::move(PatternNode),
1502-
*SyntaxContext);
1501+
ParsedSyntaxRecorder::deferUnresolvedPatternExpr(std::move(PatternNode),
1502+
*SyntaxContext);
15031503
SyntaxContext->addSyntax(std::move(ExprNode));
15041504
return makeParserResult(new (Context) UnresolvedPatternExpr(pattern));
15051505
}

‎lib/Parse/ParseType.cpp

Lines changed: 5 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -399,7 +399,7 @@ Parser::TypeASTResult Parser::parseType(Diag<> MessageID,
399399
diagnose(Tok.getLoc(), DiagID)
400400
.fixItInsert(ArrowLoc, "throws ")
401401
.fixItRemove(Tok.getLoc());
402-
ignoreToken();
402+
Throws = consumeTokenSyntax();
403403
}
404404
ParserResult<TypeRepr> SecondHalf =
405405
parseType(diag::expected_type_function_result);
@@ -946,8 +946,7 @@ Parser::TypeResult Parser::parseOldStyleProtocolComposition() {
946946
replacement = "Any";
947947
} else {
948948
auto extractText = [&](ParsedTypeSyntax &Type) -> StringRef {
949-
auto SourceRange = Type.getRaw()
950-
.getDeferredRange(/*includeTrivia=*/false);
949+
auto SourceRange = Type.getRaw().getDeferredRange();
951950
return SourceMgr.extractText(SourceRange);
952951
};
953952
auto Begin = Protocols.begin();
@@ -1064,15 +1063,18 @@ Parser::TypeResult Parser::parseTypeTupleBody() {
10641063
// Consume a name.
10651064
NameLoc = Tok.getLoc();
10661065
Name = consumeArgumentLabelSyntax();
1066+
LocalJunk.push_back(Name->copyDeferred());
10671067

10681068
// If there is a second name, consume it as well.
10691069
if (Tok.canBeArgumentLabel()) {
10701070
SecondNameLoc = Tok.getLoc();
10711071
SecondName = consumeArgumentLabelSyntax();
1072+
LocalJunk.push_back(SecondName->copyDeferred());
10721073
}
10731074

10741075
// Consume the ':'.
10751076
if ((Colon = consumeTokenSyntaxIf(tok::colon))) {
1077+
LocalJunk.push_back(Colon->copyDeferred());
10761078
// If we succeed, then we successfully parsed a label.
10771079
if (Backtracking)
10781080
Backtracking->cancelBacktrack();
@@ -1089,18 +1091,6 @@ Parser::TypeResult Parser::parseTypeTupleBody() {
10891091
IsInOutObsoleted = false;
10901092
}
10911093

1092-
if (!Backtracking || !Backtracking->willBacktrack()) {
1093-
if (Name)
1094-
LocalJunk.push_back(Name->copyDeferred());
1095-
if (SecondName)
1096-
LocalJunk.push_back(SecondName->copyDeferred());
1097-
if (Colon)
1098-
LocalJunk.push_back(Colon->copyDeferred());
1099-
} else if (Backtracking && Backtracking->willBacktrack()) {
1100-
Name.reset();
1101-
SecondName.reset();
1102-
assert(!Colon.hasValue());
1103-
}
11041094
Backtracking.reset();
11051095

11061096
// Parse the type annotation.

‎lib/Parse/ParsedRawSyntaxRecorder.cpp

Lines changed: 1 addition & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -53,8 +53,7 @@ ParsedRawSyntaxNode
5353
ParsedRawSyntaxRecorder::recordMissingToken(tok tokenKind, SourceLoc loc) {
5454
CharSourceRange range{loc, 0};
5555
OpaqueSyntaxNode n = SPActions->recordMissingToken(tokenKind, loc);
56-
return ParsedRawSyntaxNode{SyntaxKind::Token, tokenKind, range, n,
57-
/*isMissing=*/true};
56+
return ParsedRawSyntaxNode{SyntaxKind::Token, tokenKind, range, n};
5857
}
5958

6059
static ParsedRawSyntaxNode
@@ -129,21 +128,3 @@ ParsedRawSyntaxRecorder::lookupNode(size_t lexerOffset, SourceLoc loc,
129128
CharSourceRange range{loc, unsigned(length)};
130129
return ParsedRawSyntaxNode{kind, tok::unknown, range, n};
131130
}
132-
133-
#ifndef NDEBUG
134-
void ParsedRawSyntaxRecorder::verifyElementRanges(ArrayRef<ParsedRawSyntaxNode> elements) {
135-
SourceLoc prevEndLoc;
136-
for (const auto &elem: elements) {
137-
if (elem.isMissing() || elem.isNull())
138-
continue;
139-
CharSourceRange range = elem.isRecorded()
140-
? elem.getRecordedRange()
141-
: elem.getDeferredRange(/*includeTrivia=*/true);
142-
if (range.isValid()) {
143-
assert((prevEndLoc.isInvalid() || range.getStart() == prevEndLoc)
144-
&& "Non-contiguous child ranges?");
145-
prevEndLoc = range.getEnd();
146-
}
147-
}
148-
}
149-
#endif

‎lib/Parse/ParsedSyntaxBuilders.cpp.gyb

Lines changed: 0 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -120,10 +120,6 @@ void Parsed${node.name}Builder::finishLayout(bool deferred) {
120120
}
121121
% end
122122
% end
123-
124-
#ifndef NDEBUG
125-
ParsedRawSyntaxRecorder::verifyElementRanges(Layout);
126-
#endif
127123
% end
128124
}
129125

‎lib/Parse/ParsedSyntaxRecorder.cpp.gyb

Lines changed: 48 additions & 38 deletions
Original file line numberDiff line numberDiff line change
@@ -90,21 +90,23 @@ bool ParsedSyntaxRecorder::formExactLayoutFor(syntax::SyntaxKind Kind,
9090
% child_params = ', '.join(child_params)
9191
% child_move_args = ', '.join(child_move_args)
9292
Parsed${node.name}
93-
ParsedSyntaxRecorder::record${node.syntax_kind}(MutableArrayRef<ParsedRawSyntaxNode> layout,
93+
ParsedSyntaxRecorder::record${node.syntax_kind}(${child_params},
9494
ParsedRawSyntaxRecorder &rec) {
95+
ParsedRawSyntaxNode layout[] = {
96+
% for child in node.children:
97+
% if child.is_optional:
98+
${child.name}.hasValue() ? ${child.name}->takeRaw() : ParsedRawSyntaxNode::null(),
99+
% else:
100+
${child.name}.takeRaw(),
101+
% end
102+
% end
103+
};
95104
auto raw = rec.recordRawSyntax(SyntaxKind::${node.syntax_kind}, layout);
96105
return Parsed${node.name}(std::move(raw));
97106
}
98107

99108
Parsed${node.name}
100-
ParsedSyntaxRecorder::defer${node.syntax_kind}(MutableArrayRef<ParsedRawSyntaxNode> layout, SyntaxParsingContext &SPCtx) {
101-
auto raw = ParsedRawSyntaxNode::makeDeferred(SyntaxKind::${node.syntax_kind}, layout, SPCtx);
102-
return Parsed${node.name}(std::move(raw));
103-
}
104-
105-
Parsed${node.name}
106-
ParsedSyntaxRecorder::make${node.syntax_kind}(${child_params},
107-
SyntaxParsingContext &SPCtx) {
109+
ParsedSyntaxRecorder::defer${node.syntax_kind}(${child_params}, SyntaxParsingContext &SPCtx) {
108110
ParsedRawSyntaxNode layout[] = {
109111
% for child in node.children:
110112
% if child.is_optional:
@@ -114,27 +116,41 @@ ParsedSyntaxRecorder::make${node.syntax_kind}(${child_params},
114116
% end
115117
% end
116118
};
117-
#ifndef NDEBUG
118-
ParsedRawSyntaxRecorder::verifyElementRanges(layout);
119-
#endif
119+
auto raw = ParsedRawSyntaxNode::makeDeferred(SyntaxKind::${node.syntax_kind}, llvm::makeMutableArrayRef(layout, ${len(node.children)}), SPCtx);
120+
return Parsed${node.name}(std::move(raw));
121+
}
122+
123+
Parsed${node.name}
124+
ParsedSyntaxRecorder::make${node.syntax_kind}(${child_params},
125+
SyntaxParsingContext &SPCtx) {
120126
if (SPCtx.shouldDefer())
121-
return defer${node.syntax_kind}(layout, SPCtx);
122-
return record${node.syntax_kind}(layout, SPCtx.getRecorder());
127+
return defer${node.syntax_kind}(${child_move_args}, SPCtx);
128+
return record${node.syntax_kind}(${child_move_args}, SPCtx.getRecorder());
123129
}
124130

125131
% elif node.is_syntax_collection():
126132
Parsed${node.name}
127133
ParsedSyntaxRecorder::record${node.syntax_kind}(
128-
MutableArrayRef<ParsedRawSyntaxNode> layout,
134+
MutableArrayRef<Parsed${node.collection_element_type}> elements,
129135
ParsedRawSyntaxRecorder &rec) {
136+
SmallVector<ParsedRawSyntaxNode, 16> layout;
137+
layout.reserve(elements.size());
138+
for (auto &element : elements) {
139+
layout.push_back(element.takeRaw());
140+
}
130141
auto raw = rec.recordRawSyntax(SyntaxKind::${node.syntax_kind}, layout);
131142
return Parsed${node.name}(std::move(raw));
132143
}
133144

134145
Parsed${node.name}
135146
ParsedSyntaxRecorder::defer${node.syntax_kind}(
136-
MutableArrayRef<ParsedRawSyntaxNode> layout,
147+
MutableArrayRef<Parsed${node.collection_element_type}> elements,
137148
SyntaxParsingContext &SPCtx) {
149+
SmallVector<ParsedRawSyntaxNode, 16> layout;
150+
layout.reserve(elements.size());
151+
for (auto &element : elements) {
152+
layout.push_back(element.takeRaw());
153+
}
138154
auto raw = ParsedRawSyntaxNode::makeDeferred(SyntaxKind::${node.syntax_kind},
139155
layout, SPCtx);
140156
return Parsed${node.name}(std::move(raw));
@@ -144,17 +160,9 @@ Parsed${node.name}
144160
ParsedSyntaxRecorder::make${node.syntax_kind}(
145161
MutableArrayRef<Parsed${node.collection_element_type}> elements,
146162
SyntaxParsingContext &SPCtx) {
147-
SmallVector<ParsedRawSyntaxNode, 16> layout;
148-
layout.reserve(elements.size());
149-
for (auto &element : elements) {
150-
layout.push_back(element.takeRaw());
151-
}
152-
#ifndef NDEBUG
153-
ParsedRawSyntaxRecorder::verifyElementRanges(layout);
154-
#endif
155163
if (SPCtx.shouldDefer())
156-
return defer${node.syntax_kind}(layout, SPCtx);
157-
return record${node.syntax_kind}(layout, SPCtx.getRecorder());
164+
return defer${node.syntax_kind}(elements, SPCtx);
165+
return record${node.syntax_kind}(elements, SPCtx.getRecorder());
158166
}
159167

160168
Parsed${node.name}
@@ -172,16 +180,26 @@ ParsedSyntaxRecorder::makeBlank${node.syntax_kind}(SourceLoc loc,
172180
% elif node.is_unknown():
173181
Parsed${node.name}
174182
ParsedSyntaxRecorder::record${node.syntax_kind}(
175-
MutableArrayRef<ParsedRawSyntaxNode> layout,
183+
MutableArrayRef<ParsedSyntax> elements,
176184
ParsedRawSyntaxRecorder &rec) {
185+
SmallVector<ParsedRawSyntaxNode, 16> layout;
186+
layout.reserve(elements.size());
187+
for (auto &element : elements) {
188+
layout.push_back(element.takeRaw());
189+
}
177190
auto raw = rec.recordRawSyntax(SyntaxKind::${node.syntax_kind}, layout);
178191
return Parsed${node.name}(std::move(raw));
179192
}
180193

181194
Parsed${node.name}
182195
ParsedSyntaxRecorder::defer${node.syntax_kind}(
183-
MutableArrayRef<ParsedRawSyntaxNode> layout,
196+
MutableArrayRef<ParsedSyntax> elements,
184197
SyntaxParsingContext &SPCtx) {
198+
SmallVector<ParsedRawSyntaxNode, 16> layout;
199+
layout.reserve(elements.size());
200+
for (auto &element : elements) {
201+
layout.push_back(element.takeRaw());
202+
}
185203
auto raw = ParsedRawSyntaxNode::makeDeferred(SyntaxKind::${node.syntax_kind}, layout, SPCtx);
186204
return Parsed${node.name}(std::move(raw));
187205
}
@@ -190,17 +208,9 @@ Parsed${node.name}
190208
ParsedSyntaxRecorder::make${node.syntax_kind}(
191209
MutableArrayRef<ParsedSyntax> elements,
192210
SyntaxParsingContext &SPCtx) {
193-
SmallVector<ParsedRawSyntaxNode, 16> layout;
194-
layout.reserve(elements.size());
195-
for (auto &element : elements) {
196-
layout.push_back(element.takeRaw());
197-
}
198-
#ifndef NDEBUG
199-
ParsedRawSyntaxRecorder::verifyElementRanges(layout);
200-
#endif
201211
if (SPCtx.shouldDefer())
202-
return defer${node.syntax_kind}(layout, SPCtx);
203-
return record${node.syntax_kind}(layout, SPCtx.getRecorder());
212+
return defer${node.syntax_kind}(elements, SPCtx);
213+
return record${node.syntax_kind}(elements, SPCtx.getRecorder());
204214
}
205215
% end
206216
% end

0 commit comments

Comments
 (0)