Skip to content

Commit 4e44e68

Browse files
ahoppenahoppen
committed
[libSyntax] Store shared SyntaxParsingContext data in RootContextData
1 parent 2decf8f commit 4e44e68

File tree

2 files changed

+60
-39
lines changed

2 files changed

+60
-39
lines changed

‎include/swift/Parse/SyntaxParsingContext.h‎

Lines changed: 32 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -75,9 +75,17 @@ class alignas(1 << SyntaxAlignInBits) SyntaxParsingContext {
7575
// Storage for Collected parts.
7676
std::vector<RC<RawSyntax>> Storage;
7777

78+
SyntaxArena &Arena;
79+
80+
/// A cache of nodes that can be reused when creating the current syntax
81+
/// tree
82+
SyntaxParsingCache *SyntaxCache = nullptr;
83+
7884
RootContextData(SourceFile &SF, DiagnosticEngine &Diags,
79-
SourceManager &SourceMgr, unsigned BufferID)
80-
: SF(SF), Diags(Diags), SourceMgr(SourceMgr), BufferID(BufferID) {}
85+
SourceManager &SourceMgr, unsigned BufferID,
86+
SyntaxArena &Arena, SyntaxParsingCache *SyntaxCache)
87+
: SF(SF), Diags(Diags), SourceMgr(SourceMgr), BufferID(BufferID),
88+
Arena(Arena), SyntaxCache(SyntaxCache) {}
8189
};
8290

8391
private:
@@ -116,12 +124,7 @@ class alignas(1 << SyntaxAlignInBits) SyntaxParsingContext {
116124
// Reference to the
117125
SyntaxParsingContext *&CtxtHolder;
118126

119-
/// A cache of nodes that can be reused when creating the current syntax tree
120-
SyntaxParsingCache *SyntaxParsingCache = nullptr;
121-
122-
SyntaxArena &Arena;
123-
124-
std::vector<RC<RawSyntax>> &Storage;
127+
RootContextData *RootData;
125128

126129
// Offet for 'Storage' this context owns from.
127130
const size_t Offset;
@@ -145,7 +148,7 @@ class alignas(1 << SyntaxAlignInBits) SyntaxParsingContext {
145148
void createNodeInPlace(SyntaxKind Kind, size_t N);
146149

147150
ArrayRef<RC<RawSyntax>> getParts() const {
148-
return makeArrayRef(Storage).drop_front(Offset);
151+
return makeArrayRef(getStorage()).drop_front(Offset);
149152
}
150153

151154
RC<RawSyntax> makeUnknownSyntax(SyntaxKind Kind,
@@ -161,9 +164,8 @@ class alignas(1 << SyntaxAlignInBits) SyntaxParsingContext {
161164
/// Designated constructor for child context.
162165
SyntaxParsingContext(SyntaxParsingContext *&CtxtHolder)
163166
: RootDataOrParent(CtxtHolder), CtxtHolder(CtxtHolder),
164-
SyntaxParsingCache(CtxtHolder->SyntaxParsingCache),
165-
Arena(CtxtHolder->Arena), Storage(CtxtHolder->Storage),
166-
Offset(Storage.size()), Enabled(CtxtHolder->isEnabled()) {
167+
RootData(CtxtHolder->RootData), Offset(RootData->Storage.size()),
168+
Enabled(CtxtHolder->isEnabled()) {
167169
assert(CtxtHolder->isTopOfContextStack() &&
168170
"SyntaxParsingContext cannot have multiple children");
169171
assert(CtxtHolder->Mode != AccumulationMode::LoadedFromCache &&
@@ -197,15 +199,27 @@ class alignas(1 << SyntaxAlignInBits) SyntaxParsingContext {
197199
bool isRoot() const { return RootDataOrParent.is<RootContextData*>(); }
198200
bool isTopOfContextStack() const { return this == CtxtHolder; }
199201

200-
SyntaxParsingContext *getParent() {
202+
SyntaxParsingContext *getParent() const {
201203
return RootDataOrParent.get<SyntaxParsingContext*>();
202204
}
203205

204-
RootContextData &getRootData() {
205-
return *getRoot()->RootDataOrParent.get<RootContextData*>();
206+
RootContextData *getRootData() { return RootData; }
207+
208+
const RootContextData *getRootData() const { return RootData; }
209+
210+
std::vector<RC<RawSyntax>> &getStorage() { return getRootData()->Storage; }
211+
212+
const std::vector<RC<RawSyntax>> &getStorage() const {
213+
return getRootData()->Storage;
214+
}
215+
216+
SyntaxParsingCache *getSyntaxParsingCache() const {
217+
return getRootData()->SyntaxCache;
206218
}
207219

208-
SyntaxParsingContext *getRoot();
220+
SyntaxArena &getArena() const { return getRootData()->Arena; }
221+
222+
const SyntaxParsingContext *getRoot() const;
209223

210224
/// Add RawSyntax to the parts.
211225
void addRawSyntax(RC<RawSyntax> Raw);
@@ -219,6 +233,7 @@ class alignas(1 << SyntaxAlignInBits) SyntaxParsingContext {
219233

220234
template<typename SyntaxNode>
221235
llvm::Optional<SyntaxNode> popIf() {
236+
auto &Storage = getStorage();
222237
assert(Storage.size() > Offset);
223238
if (auto Node = make<Syntax>(Storage.back()).getAs<SyntaxNode>()) {
224239
Storage.pop_back();
@@ -228,6 +243,7 @@ class alignas(1 << SyntaxAlignInBits) SyntaxParsingContext {
228243
}
229244

230245
TokenSyntax popToken() {
246+
auto &Storage = getStorage();
231247
assert(Storage.size() > Offset);
232248
assert(Storage.back()->getKind() == SyntaxKind::Token);
233249
auto Node = make<TokenSyntax>(std::move(Storage.back()));

‎lib/Parse/SyntaxParsingContext.cpp‎

Lines changed: 28 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -34,47 +34,49 @@ using RootContextData = SyntaxParsingContext::RootContextData;
3434

3535
SyntaxParsingContext::SyntaxParsingContext(SyntaxParsingContext *&CtxtHolder,
3636
SourceFile &SF, unsigned BufferID)
37-
: RootDataOrParent(new RootContextData(SF, SF.getASTContext().Diags,
38-
SF.getASTContext().SourceMgr,
39-
BufferID)),
40-
CtxtHolder(CtxtHolder), SyntaxParsingCache(SF.SyntaxParsingCache),
41-
Arena(SF.getASTContext().getSyntaxArena()),
42-
Storage(getRootData().Storage), Offset(0), Mode(AccumulationMode::Root),
43-
Enabled(SF.shouldBuildSyntaxTree()) {
37+
: RootDataOrParent(new RootContextData(
38+
SF, SF.getASTContext().Diags, SF.getASTContext().SourceMgr, BufferID,
39+
SF.getASTContext().getSyntaxArena(), SF.SyntaxParsingCache)),
40+
CtxtHolder(CtxtHolder),
41+
RootData(RootDataOrParent.get<RootContextData *>()), Offset(0),
42+
Mode(AccumulationMode::Root), Enabled(SF.shouldBuildSyntaxTree()) {
4443
CtxtHolder = this;
45-
Storage.reserve(128);
44+
getStorage().reserve(128);
4645
}
4746

4847
size_t SyntaxParsingContext::loadFromCache(size_t LexerOffset) {
49-
assert(Storage.size() == Offset && "Cannot load from cache if nodes have "
50-
"already been gathered");
48+
assert(getStorage().size() == Offset &&
49+
"Cannot load from cache if nodes have "
50+
"already been gathered");
5151
assert(Mode == AccumulationMode::CreateSyntax &&
5252
"Loading from cache is only supported for mode CreateSyntax");
53-
if (!SyntaxParsingCache) {
53+
if (!getSyntaxParsingCache()) {
5454
// We don't have a cache, so there's nothing to look up
5555
return 0;
5656
}
57-
auto CacheLookup = SyntaxParsingCache->lookUp(LexerOffset, SynKind);
57+
auto CacheLookup = getSyntaxParsingCache()->lookUp(LexerOffset, SynKind);
5858
if (!CacheLookup) {
5959
return 0;
6060
}
6161
Mode = AccumulationMode::LoadedFromCache;
6262
RC<RawSyntax> RawLookup = CacheLookup->getRaw().get();
63-
Storage.push_back(RawLookup);
63+
getStorage().push_back(RawLookup);
6464
return RawLookup->getTextLength();
6565
}
6666

6767
RC<RawSyntax>
6868
SyntaxParsingContext::makeUnknownSyntax(SyntaxKind Kind,
6969
ArrayRef<RC<RawSyntax>> Parts) {
7070
assert(isUnknownKind(Kind));
71+
SyntaxArena &Arena = getArena();
7172
return RawSyntax::make(Kind, Parts, SourcePresence::Present, &Arena);
7273
}
7374

7475
RC<RawSyntax>
7576
SyntaxParsingContext::createSyntaxAs(SyntaxKind Kind,
7677
ArrayRef<RC<RawSyntax>> Parts) {
7778
// Try to create the node of the given syntax.
79+
SyntaxArena &Arena = getArena();
7880
if (auto Node = SyntaxFactory::createRaw(Kind, Parts, &Arena))
7981
return Node;
8082

@@ -144,10 +146,10 @@ RC<RawSyntax> SyntaxParsingContext::bridgeAs(SyntaxContextKind Kind,
144146

145147
/// Add RawSyntax to the parts.
146148
void SyntaxParsingContext::addRawSyntax(RC<RawSyntax> Raw) {
147-
Storage.emplace_back(Raw);
149+
getStorage().emplace_back(Raw);
148150
}
149151

150-
SyntaxParsingContext *SyntaxParsingContext::getRoot() {
152+
const SyntaxParsingContext *SyntaxParsingContext::getRoot() const {
151153
auto Curr = this;
152154
while (!Curr->isRoot())
153155
Curr = Curr->getParent();
@@ -160,6 +162,7 @@ void SyntaxParsingContext::addToken(Token &Tok, Trivia &LeadingTrivia,
160162
if (!Enabled)
161163
return;
162164

165+
auto &Arena = getArena();
163166
addRawSyntax(RawSyntax::getToken(Arena, Tok.getKind(), Tok.getText(),
164167
LeadingTrivia.Pieces,
165168
TrailingTrivia.Pieces));
@@ -175,16 +178,16 @@ void SyntaxParsingContext::addSyntax(Syntax Node) {
175178
void SyntaxParsingContext::createNodeInPlace(SyntaxKind Kind, size_t N) {
176179
if (N == 0) {
177180
if (!parserShallOmitWhenNoChildren(Kind))
178-
Storage.push_back(createSyntaxAs(Kind, {}));
181+
getStorage().push_back(createSyntaxAs(Kind, {}));
179182
return;
180183
}
181184

182-
auto I = Storage.end() - N;
185+
auto I = getStorage().end() - N;
183186
*I = createSyntaxAs(Kind, getParts().take_back(N));
184187

185188
// Remove consumed parts.
186189
if (N != 1)
187-
Storage.erase(I + 1, Storage.end());
190+
getStorage().erase(I + 1, getStorage().end());
188191
}
189192

190193
void SyntaxParsingContext::createNodeInPlace(SyntaxKind Kind) {
@@ -337,30 +340,30 @@ void SyntaxParsingContext::finalizeRoot() {
337340
assert(isTopOfContextStack() && "some sub-contexts are not destructed");
338341
assert(isRoot() && "only root context can finalize the tree");
339342
assert(Mode == AccumulationMode::Root);
340-
finalizeSourceFile(getRootData(), getParts());
343+
finalizeSourceFile(*getRootData(), getParts());
341344

342345
// Clear the parts because we will call this function again when destroying
343346
// the root context.
344-
getRootData().Storage.clear();
347+
getStorage().clear();
345348
}
346349

347350
void SyntaxParsingContext::synthesize(tok Kind, StringRef Text) {
348351
if (!Enabled)
349352
return;
350353
if (Text.empty())
351354
Text = getTokenText(Kind);
352-
Storage.push_back(RawSyntax::missing(Kind, Text));
355+
getStorage().push_back(RawSyntax::missing(Kind, Text));
353356
}
354357

355358
void SyntaxParsingContext::synthesize(SyntaxKind Kind) {
356359
if (!Enabled)
357360
return;
358-
Storage.push_back(RawSyntax::missing(Kind));
361+
getStorage().push_back(RawSyntax::missing(Kind));
359362
}
360363

361364
void SyntaxParsingContext::dumpStorage() const {
362365
llvm::errs() << "======================\n";
363-
for (auto Node : Storage) {
366+
for (auto Node : getStorage()) {
364367
Node->dump();
365368
llvm::errs() << "\n--------------\n";
366369
}
@@ -380,6 +383,8 @@ SyntaxParsingContext::~SyntaxParsingContext() {
380383
if (!Enabled)
381384
return;
382385

386+
auto &Storage = getStorage();
387+
383388
switch (Mode) {
384389
// Create specified Syntax node from the parts and add it to the parent.
385390
case AccumulationMode::CreateSyntax:

0 commit comments

Comments
 (0)