Skip to content

Commit 387d2a9

Browse files
Catfish-ManCatfish-Man
authored
Merge pull request #27203 from CodaFi/movin-on-up
Revert #26937, #27190, and #27132
2 parents bf1ab6c + d8aaf29 commit 387d2a9

27 files changed

+330
-501
lines changed

‎include/swift/Parse/HiddenLibSyntaxAction.h

Lines changed: 0 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -70,8 +70,6 @@ class HiddenLibSyntaxAction : public SyntaxParseActions {
7070
std::pair<size_t, OpaqueSyntaxNode>
7171
lookupNode(size_t lexerOffset, syntax::SyntaxKind kind) override;
7272

73-
void discardRecordedNode(OpaqueSyntaxNode node) override;
74-
7573
OpaqueSyntaxNodeKind getOpaqueKind() override {
7674
return ExplicitAction->getOpaqueKind();
7775
}

‎include/swift/Parse/LibSyntaxGenerator.h

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -44,7 +44,7 @@ class LibSyntaxGenerator {
4444

4545
auto Recorded = Recorder.recordToken(Kind, Range, LeadingTriviaPieces,
4646
TrailingTriviaPieces);
47-
auto Raw = static_cast<RawSyntax *>(Recorded.takeOpaqueNode());
47+
auto Raw = static_cast<RawSyntax *>(Recorded.getOpaqueNode());
4848
return make<TokenSyntax>(Raw);
4949
}
5050

@@ -55,7 +55,7 @@ class LibSyntaxGenerator {
5555
auto Children = Node.getDeferredChildren();
5656

5757
auto Recorded = Recorder.recordRawSyntax(Kind, Children);
58-
RC<RawSyntax> Raw {static_cast<RawSyntax *>(Recorded.takeOpaqueNode()) };
58+
RC<RawSyntax> Raw {static_cast<RawSyntax *>(Recorded.getOpaqueNode()) };
5959
Raw->Release(); // -1 since it's transfer of ownership.
6060
return make<SyntaxNode>(Raw);
6161
}

‎include/swift/Parse/ParsedRawSyntaxNode.h

Lines changed: 7 additions & 96 deletions
Original file line numberDiff line numberDiff line change
@@ -51,7 +51,7 @@ class ParsedRawSyntaxNode {
5151
CharSourceRange Range;
5252
};
5353
struct DeferredLayoutNode {
54-
MutableArrayRef<ParsedRawSyntaxNode> Children;
54+
ArrayRef<ParsedRawSyntaxNode> Children;
5555
};
5656
struct DeferredTokenNode {
5757
const ParsedTriviaPiece *TriviaPieces;
@@ -73,8 +73,8 @@ class ParsedRawSyntaxNode {
7373
bool IsMissing = false;
7474

7575
ParsedRawSyntaxNode(syntax::SyntaxKind k,
76-
MutableArrayRef<ParsedRawSyntaxNode> deferredNodes)
77-
: DeferredLayout({deferredNodes}),
76+
ArrayRef<ParsedRawSyntaxNode> deferredNodes)
77+
: DeferredLayout{deferredNodes},
7878
SynKind(uint16_t(k)), TokKind(uint16_t(tok::unknown)),
7979
DK(DataKind::DeferredLayout) {
8080
assert(getKind() == k && "Syntax kind with too large value!");
@@ -97,8 +97,6 @@ class ParsedRawSyntaxNode {
9797
assert(DeferredToken.NumTrailingTrivia == numTrailingTrivia &&
9898
"numLeadingTrivia is too large value!");
9999
}
100-
ParsedRawSyntaxNode(ParsedRawSyntaxNode &other) = delete;
101-
ParsedRawSyntaxNode &operator=(ParsedRawSyntaxNode &other) = delete;
102100

103101
public:
104102
ParsedRawSyntaxNode()
@@ -117,35 +115,6 @@ class ParsedRawSyntaxNode {
117115
assert(getTokenKind() == tokKind && "Token kind with too large value!");
118116
}
119117

120-
ParsedRawSyntaxNode &operator=(ParsedRawSyntaxNode &&other) {
121-
assert(DK != DataKind::Recorded);
122-
switch (other.DK) {
123-
case DataKind::Null:
124-
break;
125-
case DataKind::Recorded:
126-
RecordedData = std::move(other.RecordedData);
127-
break;
128-
case DataKind::DeferredLayout:
129-
DeferredLayout = std::move(other.DeferredLayout);
130-
break;
131-
case DataKind::DeferredToken:
132-
DeferredToken = std::move(other.DeferredToken);
133-
break;
134-
}
135-
SynKind = std::move(other.SynKind);
136-
TokKind = std::move(other.TokKind);
137-
DK = std::move(other.DK);
138-
IsMissing = std::move(other.IsMissing);
139-
other.reset();
140-
return *this;
141-
}
142-
ParsedRawSyntaxNode(ParsedRawSyntaxNode &&other) : ParsedRawSyntaxNode() {
143-
*this = std::move(other);
144-
}
145-
~ParsedRawSyntaxNode() {
146-
assert(DK != DataKind::Recorded);
147-
}
148-
149118
syntax::SyntaxKind getKind() const { return syntax::SyntaxKind(SynKind); }
150119
tok getTokenKind() const { return tok(TokKind); }
151120

@@ -167,36 +136,6 @@ class ParsedRawSyntaxNode {
167136
/// Primary used for a deferred missing token.
168137
bool isMissing() const { return IsMissing; }
169138

170-
void reset() {
171-
RecordedData = {};
172-
SynKind = uint16_t(syntax::SyntaxKind::Unknown);
173-
TokKind = uint16_t(tok::unknown);
174-
DK = DataKind::Null;
175-
IsMissing = false;
176-
}
177-
178-
ParsedRawSyntaxNode unsafeCopy() const {
179-
ParsedRawSyntaxNode copy;
180-
switch (DK) {
181-
case DataKind::DeferredLayout:
182-
copy.DeferredLayout = DeferredLayout;
183-
break;
184-
case DataKind::DeferredToken:
185-
copy.DeferredToken = DeferredToken;
186-
break;
187-
case DataKind::Recorded:
188-
copy.RecordedData = RecordedData;
189-
break;
190-
case DataKind::Null:
191-
break;
192-
}
193-
copy.SynKind = SynKind;
194-
copy.TokKind = TokKind;
195-
copy.DK = DK;
196-
copy.IsMissing = IsMissing;
197-
return copy;
198-
}
199-
200139
CharSourceRange getDeferredRange() const {
201140
switch (DK) {
202141
case DataKind::DeferredLayout:
@@ -214,24 +153,18 @@ class ParsedRawSyntaxNode {
214153
assert(isRecorded());
215154
return RecordedData.Range;
216155
}
217-
const OpaqueSyntaxNode &getOpaqueNode() const {
156+
OpaqueSyntaxNode getOpaqueNode() const {
218157
assert(isRecorded());
219158
return RecordedData.OpaqueNode;
220159
}
221-
OpaqueSyntaxNode takeOpaqueNode() {
222-
assert(isRecorded());
223-
auto opaque = RecordedData.OpaqueNode;
224-
reset();
225-
return opaque;
226-
}
227160

228161
// Deferred Layout Data ====================================================//
229162

230163
CharSourceRange getDeferredLayoutRange() const {
231164
assert(DK == DataKind::DeferredLayout);
232165
assert(!DeferredLayout.Children.empty());
233-
auto getLastNonNullChild = [this]() -> const ParsedRawSyntaxNode & {
234-
for (auto &Child : llvm::reverse(getDeferredChildren()))
166+
auto getLastNonNullChild = [this]() {
167+
for (auto &&Child : llvm::reverse(getDeferredChildren()))
235168
if (!Child.isNull())
236169
return Child;
237170
llvm_unreachable("layout node without non-null children");
@@ -245,28 +178,6 @@ class ParsedRawSyntaxNode {
245178
assert(DK == DataKind::DeferredLayout);
246179
return DeferredLayout.Children;
247180
}
248-
MutableArrayRef<ParsedRawSyntaxNode> getDeferredChildren() {
249-
assert(DK == DataKind::DeferredLayout);
250-
return DeferredLayout.Children;
251-
}
252-
ParsedRawSyntaxNode copyDeferred() const {
253-
ParsedRawSyntaxNode copy;
254-
switch (DK) {
255-
case DataKind::DeferredLayout:
256-
copy.DeferredLayout = DeferredLayout;
257-
break;
258-
case DataKind::DeferredToken:
259-
copy.DeferredToken = DeferredToken;
260-
break;
261-
default:
262-
llvm_unreachable("node not deferred");
263-
}
264-
copy.SynKind = SynKind;
265-
copy.TokKind = TokKind;
266-
copy.DK = DK;
267-
copy.IsMissing = IsMissing;
268-
return copy;
269-
}
270181

271182
// Deferred Token Data =====================================================//
272183

@@ -303,7 +214,7 @@ class ParsedRawSyntaxNode {
303214

304215
/// Form a deferred syntax layout node.
305216
static ParsedRawSyntaxNode makeDeferred(syntax::SyntaxKind k,
306-
MutableArrayRef<ParsedRawSyntaxNode> deferredNodes,
217+
ArrayRef<ParsedRawSyntaxNode> deferredNodes,
307218
SyntaxParsingContext &ctx);
308219

309220
/// Form a deferred token node.

‎include/swift/Parse/ParsedRawSyntaxRecorder.h

Lines changed: 1 addition & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -60,16 +60,14 @@ class ParsedRawSyntaxRecorder {
6060
/// \p kind. Missing optional elements are represented with a null
6161
/// ParsedRawSyntaxNode object.
6262
ParsedRawSyntaxNode recordRawSyntax(syntax::SyntaxKind kind,
63-
MutableArrayRef<ParsedRawSyntaxNode> elements);
63+
ArrayRef<ParsedRawSyntaxNode> elements);
6464

6565
/// Record a raw syntax collecton without eny elements. \p loc can be invalid
6666
/// or an approximate location of where an element of the collection would be
6767
/// if not missing.
6868
ParsedRawSyntaxNode recordEmptyRawSyntaxCollection(syntax::SyntaxKind kind,
6969
SourceLoc loc);
7070

71-
void discardRecordedNode(ParsedRawSyntaxNode &node);
72-
7371
/// Used for incremental re-parsing.
7472
ParsedRawSyntaxNode lookupNode(size_t lexerOffset, SourceLoc loc,
7573
syntax::SyntaxKind kind);

‎include/swift/Parse/ParsedSyntax.h

Lines changed: 2 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -26,7 +26,6 @@ class ParsedSyntax {
2626
: RawNode(std::move(rawNode)) {}
2727

2828
const ParsedRawSyntaxNode &getRaw() const { return RawNode; }
29-
ParsedRawSyntaxNode takeRaw() { return std::move(RawNode); }
3029
syntax::SyntaxKind getKind() const { return RawNode.getKind(); }
3130

3231
/// Returns true if the syntax node is of the given type.
@@ -40,7 +39,7 @@ class ParsedSyntax {
4039
template <typename T>
4140
T castTo() const {
4241
assert(is<T>() && "castTo<T>() node of incompatible type!");
43-
return T { RawNode.copyDeferred() };
42+
return T { RawNode };
4443
}
4544

4645
/// If this Syntax node is of the right kind, cast and return it,
@@ -53,10 +52,6 @@ class ParsedSyntax {
5352
return llvm::None;
5453
}
5554

56-
ParsedSyntax copyDeferred() const {
57-
return ParsedSyntax { RawNode.copyDeferred() };
58-
}
59-
6055
static bool kindof(syntax::SyntaxKind Kind) {
6156
return true;
6257
}
@@ -70,7 +65,7 @@ class ParsedSyntax {
7065
class ParsedTokenSyntax final : public ParsedSyntax {
7166
public:
7267
explicit ParsedTokenSyntax(ParsedRawSyntaxNode rawNode)
73-
: ParsedSyntax(std::move(rawNode)) {}
68+
: ParsedSyntax(rawNode) {}
7469

7570
tok getTokenKind() const {
7671
return getRaw().getTokenKind();

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

Lines changed: 11 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -53,32 +53,32 @@ public:
5353
% elif node.is_syntax_collection():
5454
private:
5555
static Parsed${node.name} record${node.syntax_kind}(
56-
MutableArrayRef<Parsed${node.collection_element_type}> elts,
56+
ArrayRef<Parsed${node.collection_element_type}> elts,
5757
ParsedRawSyntaxRecorder &rec);
5858

5959
public:
6060
static Parsed${node.name} defer${node.syntax_kind}(
61-
MutableArrayRef<Parsed${node.collection_element_type}> elts,
61+
ArrayRef<Parsed${node.collection_element_type}> elts,
6262
SyntaxParsingContext &SPCtx);
6363
static Parsed${node.name} make${node.syntax_kind}(
64-
MutableArrayRef<Parsed${node.collection_element_type}> elts,
64+
ArrayRef<Parsed${node.collection_element_type}> elts,
6565
SyntaxParsingContext &SPCtx);
6666

6767
static Parsed${node.name} makeBlank${node.syntax_kind}(SourceLoc loc,
6868
SyntaxParsingContext &SPCtx);
6969
% elif node.is_unknown():
7070
private:
7171
static Parsed${node.name} record${node.syntax_kind}(
72-
MutableArrayRef<ParsedSyntax> elts,
72+
ArrayRef<ParsedSyntax> elts,
7373
ParsedRawSyntaxRecorder &rec);
7474

7575
public:
7676
static Parsed${node.name} defer${node.syntax_kind}(
77-
MutableArrayRef<ParsedSyntax> elts,
77+
ArrayRef<ParsedSyntax> elts,
7878
SyntaxParsingContext &SPCtx);
7979

8080
static Parsed${node.name} make${node.syntax_kind}(
81-
MutableArrayRef<ParsedSyntax> elts,
81+
ArrayRef<ParsedSyntax> elts,
8282
SyntaxParsingContext &SPCtx);
8383
% end
8484
% end
@@ -95,21 +95,18 @@ public:
9595
/// optional trailing comma.
9696
static ParsedTupleTypeElementSyntax
9797
makeTupleTypeElement(ParsedTypeSyntax Type,
98-
Optional<ParsedTokenSyntax> TrailingComma,
99-
SyntaxParsingContext &SPCtx);
98+
Optional<ParsedTokenSyntax> TrailingComma,
99+
SyntaxParsingContext &SPCtx);
100100

101101
/// The provided \c elements are in the appropriate order for the syntax
102102
/// \c kind's layout but optional elements are not be included.
103103
/// This function will form the exact layout based on the provided elements,
104104
/// substituting missing parts with a null ParsedRawSyntaxNode object.
105105
///
106106
/// \returns true if the layout could be formed, false otherwise.
107-
static bool
108-
formExactLayoutFor(syntax::SyntaxKind kind,
109-
MutableArrayRef<ParsedRawSyntaxNode> elements,
110-
function_ref<void(syntax::SyntaxKind,
111-
MutableArrayRef<ParsedRawSyntaxNode>)>
112-
receiver);
107+
static bool formExactLayoutFor(syntax::SyntaxKind kind,
108+
ArrayRef<ParsedRawSyntaxNode> elements,
109+
function_ref<void(syntax::SyntaxKind, ArrayRef<ParsedRawSyntaxNode>)> receiver);
113110
};
114111
}
115112

‎include/swift/Parse/SyntaxParseActions.h

Lines changed: 0 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -61,13 +61,6 @@ class SyntaxParseActions {
6161
ArrayRef<OpaqueSyntaxNode> elements,
6262
CharSourceRange range) = 0;
6363

64-
/// Discard raw syntax node.
65-
///
66-
/// FIXME: This breaks invariant that any recorded node will be a part of the
67-
/// result SourceFile syntax. This method is a temporary workaround, and
68-
/// should be removed when we fully migrate to libSyntax parsing.
69-
virtual void discardRecordedNode(OpaqueSyntaxNode node) = 0;
70-
7164
/// Used for incremental re-parsing.
7265
virtual std::pair<size_t, OpaqueSyntaxNode>
7366
lookupNode(size_t lexerOffset, syntax::SyntaxKind kind) {

0 commit comments

Comments
 (0)