Skip to content

[Parse] Assert that the children of syntax tree nodes have contiguous source ranges #27406

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
Sep 28, 2019
Merged

[Parse] Assert that the children of syntax tree nodes have contiguous source ranges #27406

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
35 changes: 20 additions & 15 deletions include/swift/Parse/ParsedRawSyntaxNode.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -109,10 +109,12 @@ class ParsedRawSyntaxNode {
}

ParsedRawSyntaxNode(syntax::SyntaxKind k, tok tokKind,
CharSourceRange r, OpaqueSyntaxNode n)
CharSourceRange r, OpaqueSyntaxNode n,
bool IsMissing = false)
: RecordedData{n, r},
SynKind(uint16_t(k)), TokKind(uint16_t(tokKind)),
DK(DataKind::Recorded) {
DK(DataKind::Recorded),
IsMissing(IsMissing) {
assert(getKind() == k && "Syntax kind with too large value!");
assert(getTokenKind() == tokKind && "Token kind with too large value!");
}
Expand Down Expand Up @@ -197,12 +199,14 @@ class ParsedRawSyntaxNode {
return copy;
}

CharSourceRange getDeferredRange() const {
CharSourceRange getDeferredRange(bool includeTrivia) const {
switch (DK) {
case DataKind::DeferredLayout:
return getDeferredLayoutRange();
return getDeferredLayoutRange(includeTrivia);
case DataKind::DeferredToken:
return getDeferredTokenRange();
return includeTrivia
? getDeferredTokenRangeWithTrivia()
: getDeferredTokenRange();
default:
llvm_unreachable("node not deferred");
}
Expand All @@ -227,18 +231,19 @@ class ParsedRawSyntaxNode {

// Deferred Layout Data ====================================================//

CharSourceRange getDeferredLayoutRange() const {
CharSourceRange getDeferredLayoutRange(bool includeTrivia) const {
assert(DK == DataKind::DeferredLayout);
assert(!DeferredLayout.Children.empty());
auto getLastNonNullChild = [this]() -> const ParsedRawSyntaxNode & {
for (auto &Child : llvm::reverse(getDeferredChildren()))
if (!Child.isNull())
return Child;
llvm_unreachable("layout node without non-null children");
auto HasValidRange = [includeTrivia](const ParsedRawSyntaxNode &Child) {
return !Child.isNull() && !Child.isMissing() &&
Child.getDeferredRange(includeTrivia).isValid();
};
auto firstRange = DeferredLayout.Children.front().getDeferredRange();
auto lastRange = getLastNonNullChild().getDeferredRange();
firstRange.widen(lastRange);
auto first = llvm::find_if(getDeferredChildren(), HasValidRange);
if (first == getDeferredChildren().end())
return CharSourceRange();
auto last = llvm::find_if(llvm::reverse(getDeferredChildren()),
HasValidRange);
auto firstRange = first->getDeferredRange(includeTrivia);
firstRange.widen(last->getDeferredRange(includeTrivia));
return firstRange;
}
ArrayRef<ParsedRawSyntaxNode> getDeferredChildren() const {
Expand Down
4 changes: 4 additions & 0 deletions include/swift/Parse/ParsedRawSyntaxRecorder.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -73,6 +73,10 @@ class ParsedRawSyntaxRecorder {
/// Used for incremental re-parsing.
ParsedRawSyntaxNode lookupNode(size_t lexerOffset, SourceLoc loc,
syntax::SyntaxKind kind);

#ifndef NDEBUG
static void verifyElementRanges(ArrayRef<ParsedRawSyntaxNode> elements);
#endif
};

} // end namespace swift
Expand Down
2 changes: 1 addition & 1 deletion include/swift/Parse/ParsedSyntaxBuilders.h.gyb
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -62,9 +62,9 @@ public:
% end

Parsed${node.name} build();
Parsed${node.name} makeDeferred();

private:
Parsed${node.name} makeDeferred();
Parsed${node.name} record();
void finishLayout(bool deferred);
};
Expand Down
21 changes: 9 additions & 12 deletions include/swift/Parse/ParsedSyntaxRecorder.h.gyb
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -43,23 +43,22 @@ struct ParsedSyntaxRecorder {
% end
% child_params = ', '.join(child_params)
private:
static Parsed${node.name} record${node.syntax_kind}(${child_params},
static Parsed${node.name} record${node.syntax_kind}(MutableArrayRef<ParsedRawSyntaxNode> layout,
ParsedRawSyntaxRecorder &rec);
public:
static Parsed${node.name} defer${node.syntax_kind}(${child_params},
static Parsed${node.name} defer${node.syntax_kind}(MutableArrayRef<ParsedRawSyntaxNode> layout,
SyntaxParsingContext &SPCtx);
public:
static Parsed${node.name} make${node.syntax_kind}(${child_params},
SyntaxParsingContext &SPCtx);
% elif node.is_syntax_collection():
private:
static Parsed${node.name} record${node.syntax_kind}(
MutableArrayRef<Parsed${node.collection_element_type}> elts,
MutableArrayRef<ParsedRawSyntaxNode> layout,
ParsedRawSyntaxRecorder &rec);

public:
static Parsed${node.name} defer${node.syntax_kind}(
MutableArrayRef<Parsed${node.collection_element_type}> elts,
MutableArrayRef<ParsedRawSyntaxNode> layout,
SyntaxParsingContext &SPCtx);
public:
static Parsed${node.name} make${node.syntax_kind}(
MutableArrayRef<Parsed${node.collection_element_type}> elts,
SyntaxParsingContext &SPCtx);
Expand All @@ -69,14 +68,12 @@ public:
% elif node.is_unknown():
private:
static Parsed${node.name} record${node.syntax_kind}(
MutableArrayRef<ParsedSyntax> elts,
MutableArrayRef<ParsedRawSyntaxNode> layout,
ParsedRawSyntaxRecorder &rec);

public:
static Parsed${node.name} defer${node.syntax_kind}(
MutableArrayRef<ParsedSyntax> elts,
MutableArrayRef<ParsedRawSyntaxNode> layout,
SyntaxParsingContext &SPCtx);

public:
static Parsed${node.name} make${node.syntax_kind}(
MutableArrayRef<ParsedSyntax> elts,
SyntaxParsingContext &SPCtx);
Expand Down
4 changes: 2 additions & 2 deletions lib/Parse/ParseExpr.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1498,8 +1498,8 @@ ParserResult<Expr> Parser::parseExprPrimary(Diag<> ID, bool isExprBasic) {
ParsedSyntaxRecorder::makeIdentifierPattern(
SyntaxContext->popToken(), *SyntaxContext);
ParsedExprSyntax ExprNode =
ParsedSyntaxRecorder::deferUnresolvedPatternExpr(std::move(PatternNode),
*SyntaxContext);
ParsedSyntaxRecorder::makeUnresolvedPatternExpr(std::move(PatternNode),
*SyntaxContext);
SyntaxContext->addSyntax(std::move(ExprNode));
return makeParserResult(new (Context) UnresolvedPatternExpr(pattern));
}
Expand Down
20 changes: 15 additions & 5 deletions lib/Parse/ParseType.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -399,7 +399,7 @@ Parser::TypeASTResult Parser::parseType(Diag<> MessageID,
diagnose(Tok.getLoc(), DiagID)
.fixItInsert(ArrowLoc, "throws ")
.fixItRemove(Tok.getLoc());
Throws = consumeTokenSyntax();
ignoreToken();
}
ParserResult<TypeRepr> SecondHalf =
parseType(diag::expected_type_function_result);
Expand Down Expand Up @@ -944,7 +944,8 @@ Parser::TypeResult Parser::parseOldStyleProtocolComposition() {
replacement = "Any";
} else {
auto extractText = [&](ParsedTypeSyntax &Type) -> StringRef {
auto SourceRange = Type.getRaw().getDeferredRange();
auto SourceRange = Type.getRaw()
.getDeferredRange(/*includeTrivia=*/false);
return SourceMgr.extractText(SourceRange);
};
auto Begin = Protocols.begin();
Expand Down Expand Up @@ -1061,18 +1062,15 @@ Parser::TypeResult Parser::parseTypeTupleBody() {
// Consume a name.
NameLoc = Tok.getLoc();
Name = consumeArgumentLabelSyntax();
LocalJunk.push_back(Name->copyDeferred());

// If there is a second name, consume it as well.
if (Tok.canBeArgumentLabel()) {
SecondNameLoc = Tok.getLoc();
SecondName = consumeArgumentLabelSyntax();
LocalJunk.push_back(SecondName->copyDeferred());
}

// Consume the ':'.
if ((Colon = consumeTokenSyntaxIf(tok::colon))) {
LocalJunk.push_back(Colon->copyDeferred());
// If we succeed, then we successfully parsed a label.
if (Backtracking)
Backtracking->cancelBacktrack();
Expand All @@ -1089,6 +1087,18 @@ Parser::TypeResult Parser::parseTypeTupleBody() {
IsInOutObsoleted = false;
}

if (!Backtracking || !Backtracking->willBacktrack()) {
if (Name)
LocalJunk.push_back(Name->copyDeferred());
if (SecondName)
LocalJunk.push_back(SecondName->copyDeferred());
if (Colon)
LocalJunk.push_back(Colon->copyDeferred());
} else if (Backtracking && Backtracking->willBacktrack()) {
Name.reset();
SecondName.reset();
assert(!Colon.hasValue());
}
Backtracking.reset();

// Parse the type annotation.
Expand Down
21 changes: 20 additions & 1 deletion lib/Parse/ParsedRawSyntaxRecorder.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -53,7 +53,8 @@ ParsedRawSyntaxNode
ParsedRawSyntaxRecorder::recordMissingToken(tok tokenKind, SourceLoc loc) {
CharSourceRange range{loc, 0};
OpaqueSyntaxNode n = SPActions->recordMissingToken(tokenKind, loc);
return ParsedRawSyntaxNode{SyntaxKind::Token, tokenKind, range, n};
return ParsedRawSyntaxNode{SyntaxKind::Token, tokenKind, range, n,
/*isMissing=*/true};
}

static ParsedRawSyntaxNode
Expand Down Expand Up @@ -128,3 +129,21 @@ ParsedRawSyntaxRecorder::lookupNode(size_t lexerOffset, SourceLoc loc,
CharSourceRange range{loc, unsigned(length)};
return ParsedRawSyntaxNode{kind, tok::unknown, range, n};
}

#ifndef NDEBUG
void ParsedRawSyntaxRecorder::verifyElementRanges(ArrayRef<ParsedRawSyntaxNode> elements) {
SourceLoc prevEndLoc;
for (const auto &elem: elements) {
if (elem.isMissing() || elem.isNull())
continue;
CharSourceRange range = elem.isRecorded()
? elem.getRecordedRange()
: elem.getDeferredRange(/*includeTrivia=*/true);
if (range.isValid()) {
assert((prevEndLoc.isInvalid() || range.getStart() == prevEndLoc)
&& "Non-contiguous child ranges?");
prevEndLoc = range.getEnd();
}
}
}
#endif
4 changes: 4 additions & 0 deletions lib/Parse/ParsedSyntaxBuilders.cpp.gyb
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -120,6 +120,10 @@ void Parsed${node.name}Builder::finishLayout(bool deferred) {
}
% end
% end

#ifndef NDEBUG
ParsedRawSyntaxRecorder::verifyElementRanges(Layout);
#endif
% end
}

Expand Down
86 changes: 38 additions & 48 deletions lib/Parse/ParsedSyntaxRecorder.cpp.gyb
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -90,23 +90,21 @@ bool ParsedSyntaxRecorder::formExactLayoutFor(syntax::SyntaxKind Kind,
% child_params = ', '.join(child_params)
% child_move_args = ', '.join(child_move_args)
Parsed${node.name}
ParsedSyntaxRecorder::record${node.syntax_kind}(${child_params},
ParsedSyntaxRecorder::record${node.syntax_kind}(MutableArrayRef<ParsedRawSyntaxNode> layout,
ParsedRawSyntaxRecorder &rec) {
ParsedRawSyntaxNode layout[] = {
% for child in node.children:
% if child.is_optional:
${child.name}.hasValue() ? ${child.name}->takeRaw() : ParsedRawSyntaxNode::null(),
% else:
${child.name}.takeRaw(),
% end
% end
};
auto raw = rec.recordRawSyntax(SyntaxKind::${node.syntax_kind}, layout);
return Parsed${node.name}(std::move(raw));
}

Parsed${node.name}
ParsedSyntaxRecorder::defer${node.syntax_kind}(${child_params}, SyntaxParsingContext &SPCtx) {
ParsedSyntaxRecorder::defer${node.syntax_kind}(MutableArrayRef<ParsedRawSyntaxNode> layout, SyntaxParsingContext &SPCtx) {
auto raw = ParsedRawSyntaxNode::makeDeferred(SyntaxKind::${node.syntax_kind}, layout, SPCtx);
return Parsed${node.name}(std::move(raw));
}

Parsed${node.name}
ParsedSyntaxRecorder::make${node.syntax_kind}(${child_params},
SyntaxParsingContext &SPCtx) {
ParsedRawSyntaxNode layout[] = {
% for child in node.children:
% if child.is_optional:
Expand All @@ -116,41 +114,27 @@ ParsedSyntaxRecorder::defer${node.syntax_kind}(${child_params}, SyntaxParsingCon
% end
% end
};
auto raw = ParsedRawSyntaxNode::makeDeferred(SyntaxKind::${node.syntax_kind}, llvm::makeMutableArrayRef(layout, ${len(node.children)}), SPCtx);
return Parsed${node.name}(std::move(raw));
}

Parsed${node.name}
ParsedSyntaxRecorder::make${node.syntax_kind}(${child_params},
SyntaxParsingContext &SPCtx) {
#ifndef NDEBUG
ParsedRawSyntaxRecorder::verifyElementRanges(layout);
#endif
if (SPCtx.shouldDefer())
return defer${node.syntax_kind}(${child_move_args}, SPCtx);
return record${node.syntax_kind}(${child_move_args}, SPCtx.getRecorder());
return defer${node.syntax_kind}(layout, SPCtx);
return record${node.syntax_kind}(layout, SPCtx.getRecorder());
}

% elif node.is_syntax_collection():
Parsed${node.name}
ParsedSyntaxRecorder::record${node.syntax_kind}(
MutableArrayRef<Parsed${node.collection_element_type}> elements,
MutableArrayRef<ParsedRawSyntaxNode> layout,
ParsedRawSyntaxRecorder &rec) {
SmallVector<ParsedRawSyntaxNode, 16> layout;
layout.reserve(elements.size());
for (auto &element : elements) {
layout.push_back(element.takeRaw());
}
auto raw = rec.recordRawSyntax(SyntaxKind::${node.syntax_kind}, layout);
return Parsed${node.name}(std::move(raw));
}

Parsed${node.name}
ParsedSyntaxRecorder::defer${node.syntax_kind}(
MutableArrayRef<Parsed${node.collection_element_type}> elements,
MutableArrayRef<ParsedRawSyntaxNode> layout,
SyntaxParsingContext &SPCtx) {
SmallVector<ParsedRawSyntaxNode, 16> layout;
layout.reserve(elements.size());
for (auto &element : elements) {
layout.push_back(element.takeRaw());
}
auto raw = ParsedRawSyntaxNode::makeDeferred(SyntaxKind::${node.syntax_kind},
layout, SPCtx);
return Parsed${node.name}(std::move(raw));
Expand All @@ -160,9 +144,17 @@ Parsed${node.name}
ParsedSyntaxRecorder::make${node.syntax_kind}(
MutableArrayRef<Parsed${node.collection_element_type}> elements,
SyntaxParsingContext &SPCtx) {
SmallVector<ParsedRawSyntaxNode, 16> layout;
layout.reserve(elements.size());
for (auto &element : elements) {
layout.push_back(element.takeRaw());
}
#ifndef NDEBUG
ParsedRawSyntaxRecorder::verifyElementRanges(layout);
#endif
if (SPCtx.shouldDefer())
return defer${node.syntax_kind}(elements, SPCtx);
return record${node.syntax_kind}(elements, SPCtx.getRecorder());
return defer${node.syntax_kind}(layout, SPCtx);
return record${node.syntax_kind}(layout, SPCtx.getRecorder());
}

Parsed${node.name}
Expand All @@ -180,26 +172,16 @@ ParsedSyntaxRecorder::makeBlank${node.syntax_kind}(SourceLoc loc,
% elif node.is_unknown():
Parsed${node.name}
ParsedSyntaxRecorder::record${node.syntax_kind}(
MutableArrayRef<ParsedSyntax> elements,
MutableArrayRef<ParsedRawSyntaxNode> layout,
ParsedRawSyntaxRecorder &rec) {
SmallVector<ParsedRawSyntaxNode, 16> layout;
layout.reserve(elements.size());
for (auto &element : elements) {
layout.push_back(element.takeRaw());
}
auto raw = rec.recordRawSyntax(SyntaxKind::${node.syntax_kind}, layout);
return Parsed${node.name}(std::move(raw));
}

Parsed${node.name}
ParsedSyntaxRecorder::defer${node.syntax_kind}(
MutableArrayRef<ParsedSyntax> elements,
MutableArrayRef<ParsedRawSyntaxNode> layout,
SyntaxParsingContext &SPCtx) {
SmallVector<ParsedRawSyntaxNode, 16> layout;
layout.reserve(elements.size());
for (auto &element : elements) {
layout.push_back(element.takeRaw());
}
auto raw = ParsedRawSyntaxNode::makeDeferred(SyntaxKind::${node.syntax_kind}, layout, SPCtx);
return Parsed${node.name}(std::move(raw));
}
Expand All @@ -208,9 +190,17 @@ Parsed${node.name}
ParsedSyntaxRecorder::make${node.syntax_kind}(
MutableArrayRef<ParsedSyntax> elements,
SyntaxParsingContext &SPCtx) {
SmallVector<ParsedRawSyntaxNode, 16> layout;
layout.reserve(elements.size());
for (auto &element : elements) {
layout.push_back(element.takeRaw());
}
#ifndef NDEBUG
ParsedRawSyntaxRecorder::verifyElementRanges(layout);
#endif
if (SPCtx.shouldDefer())
return defer${node.syntax_kind}(elements, SPCtx);
return record${node.syntax_kind}(elements, SPCtx.getRecorder());
return defer${node.syntax_kind}(layout, SPCtx);
return record${node.syntax_kind}(layout, SPCtx.getRecorder());
}
% end
% end
Expand Down