mirror of
https://github.com/apple/swift.git
synced 2025-12-21 12:14:44 +01:00
efb91f70a1
By now ParsedRawSyntaxNode does not have any knowledge about deferred node data anymore, which frees up SyntaxParseActions (and, in particular its sublass SyntaxTreeCreator) to perform optimisations to more efficiently create and record deferred nodes.
243 lines
9.5 KiB
C++
243 lines
9.5 KiB
C++
//===--- ParsedRawSyntaxRecorder.cpp - Raw Syntax Parsing Recorder --------===//
|
|
//
|
|
// This source file is part of the Swift.org open source project
|
|
//
|
|
// Copyright (c) 2014 - 2019 Apple Inc. and the Swift project authors
|
|
// Licensed under Apache License v2.0 with Runtime Library Exception
|
|
//
|
|
// See https://swift.org/LICENSE.txt for license information
|
|
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file defines the ParsedRawSyntaxRecorder, which is the interface the
|
|
// parser is using to pass parsed syntactic elements to a SyntaxParseActions
|
|
// receiver and get a ParsedRawSyntaxNode object back.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "swift/Parse/ParsedRawSyntaxRecorder.h"
|
|
#include "swift/Parse/ParsedRawSyntaxNode.h"
|
|
#include "swift/Parse/ParsedTrivia.h"
|
|
#include "swift/Parse/SyntaxParseActions.h"
|
|
#include "swift/Parse/SyntaxParsingContext.h"
|
|
#include "swift/Parse/Token.h"
|
|
#include "swift/Syntax/SyntaxKind.h"
|
|
|
|
using namespace swift;
|
|
using namespace swift::syntax;
|
|
|
|
ParsedRawSyntaxNode
|
|
ParsedRawSyntaxRecorder::recordDeferredNode(const ParsedRawSyntaxNode &node) {
|
|
switch (node.getDataKind()) {
|
|
case RecordedOrDeferredNode::Kind::Null:
|
|
case RecordedOrDeferredNode::Kind::Recorded:
|
|
llvm_unreachable("Not deferred");
|
|
case RecordedOrDeferredNode::Kind::DeferredLayout: {
|
|
OpaqueSyntaxNode Data = SPActions->recordDeferredLayout(node.getData());
|
|
return ParsedRawSyntaxNode(
|
|
Data, node.getRange(), node.getKind(), node.getTokenKind(),
|
|
ParsedRawSyntaxNode::DataKind::Recorded, node.isMissing());
|
|
}
|
|
case RecordedOrDeferredNode::Kind::DeferredToken: {
|
|
OpaqueSyntaxNode Data = SPActions->recordDeferredToken(node.getData());
|
|
return ParsedRawSyntaxNode(
|
|
Data, node.getRange(), node.getKind(), node.getTokenKind(),
|
|
ParsedRawSyntaxNode::DataKind::Recorded, node.isMissing());
|
|
}
|
|
}
|
|
}
|
|
|
|
ParsedRawSyntaxNode
|
|
ParsedRawSyntaxRecorder::recordToken(const Token &tok, StringRef leadingTrivia,
|
|
StringRef trailingTrivia) {
|
|
return recordToken(tok.getKind(), tok.getRange(), leadingTrivia,
|
|
trailingTrivia);
|
|
}
|
|
|
|
ParsedRawSyntaxNode
|
|
ParsedRawSyntaxRecorder::recordToken(tok tokKind, CharSourceRange tokRange,
|
|
StringRef leadingTrivia,
|
|
StringRef trailingTrivia) {
|
|
SourceLoc offset = tokRange.getStart().getAdvancedLoc(-leadingTrivia.size());
|
|
unsigned length =
|
|
leadingTrivia.size() + tokRange.getByteLength() + trailingTrivia.size();
|
|
CharSourceRange range(offset, length);
|
|
OpaqueSyntaxNode n =
|
|
SPActions->recordToken(tokKind, leadingTrivia, trailingTrivia, range);
|
|
return ParsedRawSyntaxNode(n, range, SyntaxKind::Token, tokKind,
|
|
ParsedRawSyntaxNode::DataKind::Recorded,
|
|
/*IsMissing=*/false);
|
|
}
|
|
|
|
ParsedRawSyntaxNode
|
|
ParsedRawSyntaxRecorder::recordMissingToken(tok tokenKind, SourceLoc loc) {
|
|
CharSourceRange range{loc, 0};
|
|
OpaqueSyntaxNode n = SPActions->recordMissingToken(tokenKind, loc);
|
|
return ParsedRawSyntaxNode(n, range, SyntaxKind::Token, tokenKind,
|
|
ParsedRawSyntaxNode::DataKind::Recorded,
|
|
/*isMissing=*/true);
|
|
}
|
|
|
|
ParsedRawSyntaxNode
|
|
ParsedRawSyntaxRecorder::recordRawSyntax(SyntaxKind kind,
|
|
MutableArrayRef<ParsedRawSyntaxNode> elements) {
|
|
assert(kind != SyntaxKind::Token && "Use recordToken to record a token");
|
|
#ifndef NDEBUG
|
|
ParsedRawSyntaxRecorder::verifyElementRanges(elements);
|
|
#endif
|
|
|
|
SmallVector<OpaqueSyntaxNode, 16> subnodes;
|
|
SourceLoc startLoc;
|
|
unsigned length = 0;
|
|
if (!elements.empty()) {
|
|
for (auto &subnode : elements) {
|
|
if (!subnode.isNull() && subnode.getRange().isValid()) {
|
|
if (startLoc.isInvalid()) {
|
|
startLoc = subnode.getRange().getStart();
|
|
}
|
|
length += subnode.getRange().getByteLength();
|
|
}
|
|
switch (subnode.getDataKind()) {
|
|
case RecordedOrDeferredNode::Kind::Null:
|
|
subnodes.push_back(nullptr);
|
|
break;
|
|
case RecordedOrDeferredNode::Kind::Recorded:
|
|
subnodes.push_back(subnode.takeData());
|
|
break;
|
|
case RecordedOrDeferredNode::Kind::DeferredLayout:
|
|
case RecordedOrDeferredNode::Kind::DeferredToken: {
|
|
auto recorded = recordDeferredNode(subnode);
|
|
subnodes.push_back(recorded.takeData());
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
OpaqueSyntaxNode n = SPActions->recordRawSyntax(kind, subnodes);
|
|
return ParsedRawSyntaxNode(
|
|
n, CharSourceRange(startLoc, length), kind, tok::NUM_TOKENS,
|
|
ParsedRawSyntaxNode::DataKind::Recorded, /*IsMissing=*/false);
|
|
}
|
|
|
|
ParsedRawSyntaxNode
|
|
ParsedRawSyntaxRecorder::recordEmptyRawSyntaxCollection(SyntaxKind kind,
|
|
SourceLoc loc) {
|
|
CharSourceRange range{loc, 0};
|
|
OpaqueSyntaxNode n = SPActions->recordRawSyntax(kind, {});
|
|
return ParsedRawSyntaxNode(n, range, kind, tok::unknown,
|
|
ParsedRawSyntaxNode::DataKind::Recorded,
|
|
/*IsMissing=*/false);
|
|
}
|
|
|
|
/// Create a deferred layout node.
|
|
ParsedRawSyntaxNode ParsedRawSyntaxRecorder::makeDeferred(
|
|
syntax::SyntaxKind k, MutableArrayRef<ParsedRawSyntaxNode> deferredNodes,
|
|
SyntaxParsingContext &ctx) {
|
|
#ifndef NDEBUG
|
|
ParsedRawSyntaxRecorder::verifyElementRanges(deferredNodes);
|
|
#endif
|
|
|
|
CharSourceRange range;
|
|
RecordedOrDeferredNode *newPtr =
|
|
ctx.getScratchAlloc().Allocate<RecordedOrDeferredNode>(
|
|
deferredNodes.size());
|
|
auto ptr = newPtr;
|
|
for (auto &node : deferredNodes) {
|
|
assert(!node.isRecorded() &&
|
|
"Cannot create a deferred layout node that has recorded children");
|
|
// Cached range.
|
|
if (!node.isNull() && !node.isMissing()) {
|
|
auto nodeRange = node.getRange();
|
|
if (nodeRange.isValid()) {
|
|
if (range.isInvalid())
|
|
range = nodeRange;
|
|
else
|
|
range.widen(nodeRange);
|
|
}
|
|
}
|
|
|
|
auto kind = node.getDataKind();
|
|
new (ptr) RecordedOrDeferredNode(node.takeData(), kind);
|
|
ptr++;
|
|
}
|
|
auto children = llvm::makeMutableArrayRef(newPtr, deferredNodes.size());
|
|
auto data = SPActions->makeDeferredLayout(k, /*IsMissing=*/false, children);
|
|
return ParsedRawSyntaxNode(data, range, k, tok::NUM_TOKENS,
|
|
ParsedRawSyntaxNode::DataKind::DeferredLayout,
|
|
/*IsMissing=*/false);
|
|
}
|
|
|
|
/// Create a deferred token node.
|
|
ParsedRawSyntaxNode
|
|
ParsedRawSyntaxRecorder::makeDeferred(Token tok, StringRef leadingTrivia,
|
|
StringRef trailingTrivia) {
|
|
CharSourceRange tokRange = tok.getRange();
|
|
CharSourceRange RangeWithTrivia = CharSourceRange(
|
|
tokRange.getStart().getAdvancedLoc(-leadingTrivia.size()),
|
|
(unsigned)leadingTrivia.size() + tokRange.getByteLength() +
|
|
(unsigned)trailingTrivia.size());
|
|
auto Data =
|
|
SPActions->makeDeferredToken(tok.getKind(), leadingTrivia, trailingTrivia,
|
|
RangeWithTrivia, /*IsMissing=*/false);
|
|
return ParsedRawSyntaxNode(
|
|
Data, RangeWithTrivia, SyntaxKind::Token, tok.getKind(),
|
|
ParsedRawSyntaxNode::DataKind::DeferredToken, /*IsMissing=*/false);
|
|
}
|
|
|
|
ParsedRawSyntaxNode
|
|
ParsedRawSyntaxRecorder::makeDeferredMissing(tok tokKind, SourceLoc loc) {
|
|
auto Data = SPActions->makeDeferredToken(
|
|
tokKind, /*leadingTrivia=*/StringRef(),
|
|
/*trailingTrivia=*/StringRef(), CharSourceRange(loc, /*Length=*/0),
|
|
/*IsMissing=*/true);
|
|
return ParsedRawSyntaxNode(
|
|
Data, CharSourceRange(loc, /*Length=*/0), SyntaxKind::Token, tokKind,
|
|
ParsedRawSyntaxNode::DataKind::DeferredToken, /*IsMissing=*/true);
|
|
}
|
|
|
|
ParsedRawSyntaxNode
|
|
ParsedRawSyntaxRecorder::lookupNode(size_t lexerOffset, SourceLoc loc,
|
|
SyntaxKind kind) {
|
|
size_t length;
|
|
OpaqueSyntaxNode n;
|
|
std::tie(length, n) = SPActions->lookupNode(lexerOffset, kind);
|
|
if (length == 0) {
|
|
return ParsedRawSyntaxNode::null();
|
|
}
|
|
CharSourceRange range{loc, unsigned(length)};
|
|
return ParsedRawSyntaxNode(n, range, kind, tok::unknown,
|
|
ParsedRawSyntaxNode::DataKind::Recorded,
|
|
/*IsMissing=*/false);
|
|
}
|
|
|
|
ParsedRawSyntaxNode
|
|
ParsedRawSyntaxRecorder::getDeferredChild(const ParsedRawSyntaxNode &parent,
|
|
size_t childIndex) const {
|
|
assert(parent.isDeferredLayout());
|
|
auto childInfo = SPActions->getDeferredChild(parent.getData(), childIndex,
|
|
parent.getRange().getStart());
|
|
return ParsedRawSyntaxNode(childInfo.Data, childInfo.Range,
|
|
childInfo.SyntaxKind, childInfo.TokenKind,
|
|
childInfo.SyntaxKind == syntax::SyntaxKind::Token
|
|
? RecordedOrDeferredNode::Kind::DeferredToken
|
|
: RecordedOrDeferredNode::Kind::DeferredLayout,
|
|
childInfo.IsMissing);
|
|
}
|
|
|
|
#ifndef NDEBUG
|
|
void ParsedRawSyntaxRecorder::verifyElementRanges(ArrayRef<ParsedRawSyntaxNode> elements) {
|
|
SourceLoc prevEndLoc;
|
|
for (const auto &elem: elements) {
|
|
if (elem.isMissing() || elem.isNull())
|
|
continue;
|
|
CharSourceRange range = elem.getRange();
|
|
if (range.isValid()) {
|
|
assert((prevEndLoc.isInvalid() || range.getStart() == prevEndLoc)
|
|
&& "Non-contiguous child ranges?");
|
|
prevEndLoc = range.getEnd();
|
|
}
|
|
}
|
|
}
|
|
#endif
|