carbon-language/carbon-lang
1
0
Fork 0
mirror of https://github.com/carbon-language/carbon-lang.git synced 2026-09-24 22:02:23 +01:00
Code Issues Packages Projects Releases 10 Wiki Activity

Refactor the node stack into its own class. (#2505)

Browse Source 
Currently, there's a mix of accessing node_stack_ both directly and indirectly, and there are already several Push/Pop methods to help wrap the behavior. However, there's also direct access because of shifting over time, as well as variations in _how_ the stack is used.

This migrates to a separate class in order to make a more specific contract for the API. It cleans up existing uses and adds APIs where needed.
This commit is contained in:
Jon Ross-Perkins
2023-01-05 15:16:05 -08:00
committed by GitHub
parent 78ac6cb7d1
commit 2a163ca6cd
8 changed files with 419 additions and 228 deletions
Download Patch File Download Diff File Expand all files Collapse all files
toolchain/semantics/semantics_parse_tree_handler.cpp
+67 -174
View File
@@ -22,20 +22,7 @@ class SemanticsParseTreeHandler::PrettyStackTraceNodeStack
~PrettyStackTraceNodeStack() override = default;
auto print(llvm::raw_ostream& output) const -> void override {
output << "node_stack_:\n";
for (int i = 0; i < static_cast<int>(handler_->node_stack_.size()); ++i) {
const auto& entry = handler_->node_stack_[i];
auto parse_node_kind = handler_->parse_tree_->node_kind(entry.parse_node);
output << "\t" << i << ".\t" << parse_node_kind;
if (parse_node_kind == ParseNodeKind::PatternBinding) {
output << " -> " << entry.name_id;
} else {
if (entry.result_id.is_valid()) {
output << " -> " << entry.result_id;
}
}
output << "\n";
}
handler_->node_stack_.PrintForStackDump(output);
}
private:
@@ -95,6 +82,12 @@ auto SemanticsParseTreeHandler::AddNode(SemanticsNode node) -> SemanticsNodeId {
return semantics_->AddNode(current_block_id(), node);
}
auto SemanticsParseTreeHandler::AddNodeAndPush(ParseTree::Node parse_node,
SemanticsNode node) -> void {
auto node_id = AddNode(node);
node_stack_.Push(parse_node, node_id);
}
auto SemanticsParseTreeHandler::BindName(ParseTree::Node name_node,
SemanticsNodeId type_id,
SemanticsNodeId target_id)
@@ -122,101 +115,6 @@ auto SemanticsParseTreeHandler::BindName(ParseTree::Node name_node,
return name_id;
}
auto SemanticsParseTreeHandler::Push(ParseTree::Node parse_node) -> void {
CARBON_VLOG() << "Push " << node_stack_.size() << ": "
<< parse_tree_->node_kind(parse_node) << "\n";
CARBON_CHECK(node_stack_.size() < (1 << 20))
<< "Excessive stack size: likely infinite loop";
node_stack_.push_back(
{.parse_node = parse_node, .result_id = SemanticsNodeId::MakeInvalid()});
}
auto SemanticsParseTreeHandler::Push(ParseTree::Node parse_node,
SemanticsNode node) -> void {
CARBON_VLOG() << "Push " << node_stack_.size() << ": "
<< parse_tree_->node_kind(parse_node) << " -> " << node.kind()
<< "\n";
CARBON_CHECK(node_stack_.size() < (1 << 20))
<< "Excessive stack size: likely infinite loop";
auto node_id = AddNode(node);
node_stack_.push_back({.parse_node = parse_node, .result_id = node_id});
}
auto SemanticsParseTreeHandler::Push(ParseTree::Node parse_node,
SemanticsNodeId node_id) -> void {
CARBON_VLOG() << "Push " << node_stack_.size() << ": "
<< parse_tree_->node_kind(parse_node) << " -> " << node_id
<< "\n";
CARBON_CHECK(node_stack_.size() < (1 << 20))
<< "Excessive stack size: likely infinite loop";
node_stack_.push_back({.parse_node = parse_node, .result_id = node_id});
}
auto SemanticsParseTreeHandler::Push(ParseTree::Node parse_node,
SemanticsStringId name_id) -> void {
CARBON_CHECK(parse_tree_->node_kind(parse_node) ==
ParseNodeKind::PatternBinding);
CARBON_VLOG() << "Push " << node_stack_.size() << ": "
<< parse_tree_->node_kind(parse_node) << " -> " << name_id
<< "\n";
CARBON_CHECK(node_stack_.size() < (1 << 20))
<< "Excessive stack size: likely infinite loop";
node_stack_.push_back({.parse_node = parse_node, .name_id = name_id});
}
auto SemanticsParseTreeHandler::Pop(ParseNodeKind pop_parse_kind) -> void {
auto back = node_stack_.pop_back_val();
auto parse_kind = parse_tree_->node_kind(back.parse_node);
CARBON_VLOG() << "Pop " << node_stack_.size() << ": " << pop_parse_kind
<< "\n";
CARBON_CHECK(parse_kind == pop_parse_kind)
<< "Expected " << pop_parse_kind << ", found " << parse_kind;
CARBON_CHECK(!back.result_id.is_valid())
<< "Expected no result ID on " << parse_kind << ", was "
<< back.result_id;
}
auto SemanticsParseTreeHandler::PopWithResult() -> SemanticsNodeId {
auto back = node_stack_.pop_back_val();
auto node_id = back.result_id;
CARBON_VLOG() << "Pop " << node_stack_.size() << ": any ("
<< parse_tree_->node_kind(back.parse_node) << ") -> " << node_id
<< "\n";
CARBON_CHECK(node_id.is_valid())
<< "Invalid PopWithResult on " << parse_tree_->node_kind(back.parse_node);
return node_id;
}
auto SemanticsParseTreeHandler::PopWithResult(ParseNodeKind pop_parse_kind)
-> SemanticsNodeId {
auto back = node_stack_.pop_back_val();
auto parse_kind = parse_tree_->node_kind(back.parse_node);
auto node_id = back.result_id;
CARBON_VLOG() << "Pop " << node_stack_.size() << ": " << pop_parse_kind
<< ") -> " << node_id << "\n";
CARBON_CHECK(parse_kind == pop_parse_kind)
<< "Expected " << pop_parse_kind << ", found " << parse_kind;
CARBON_CHECK(node_id.is_valid())
<< "Invalid PopWithResult with " << parse_kind;
return node_id;
}
auto SemanticsParseTreeHandler::PopWithResultIf(ParseNodeKind pop_parse_kind)
-> std::optional<SemanticsNodeId> {
auto parse_kind = parse_tree_->node_kind(node_stack_.back().parse_node);
if (parse_kind != pop_parse_kind) {
return std::nullopt;
}
auto back = node_stack_.pop_back_val();
auto node_id = back.result_id;
CARBON_VLOG() << "Pop " << node_stack_.size() << ": " << pop_parse_kind
<< ") -> " << node_id << "\n";
CARBON_CHECK(node_id.is_valid())
<< "Invalid PopWithResult with " << parse_kind;
return node_id;
}
auto SemanticsParseTreeHandler::PushScope() -> void {
scope_stack_.push_back({});
}
@@ -311,7 +209,7 @@ auto SemanticsParseTreeHandler::HandleContinueStatementStart(
auto SemanticsParseTreeHandler::HandleDeclaredName(ParseTree::Node parse_node)
-> void {
// The parent is responsible for binding the name.
Push(parse_node);
node_stack_.Push(parse_node);
}
auto SemanticsParseTreeHandler::HandleDeducedParameterList(
@@ -338,7 +236,7 @@ auto SemanticsParseTreeHandler::HandleEmptyDeclaration(
ParseTree::Node parse_node) -> void {
// Empty declarations have no actions associated, but we still balance the
// tree.
Push(parse_node);
node_stack_.Push(parse_node);
}
auto SemanticsParseTreeHandler::HandleExpressionStatement(
@@ -346,8 +244,8 @@ auto SemanticsParseTreeHandler::HandleExpressionStatement(
// Pop the expression without investigating its contents.
// TODO: This will probably eventually need to do some "do not discard"
// analysis.
PopWithResult();
Push(parse_node);
node_stack_.PopAndIgnore();
node_stack_.Push(parse_node);
}
auto SemanticsParseTreeHandler::HandleFileEnd(ParseTree::Node /*parse_node*/)
@@ -383,23 +281,23 @@ auto SemanticsParseTreeHandler::HandleFunctionDeclaration(
auto SemanticsParseTreeHandler::HandleFunctionDefinition(
ParseTree::Node parse_node) -> void {
// Merges code block children up under the FunctionDefinitionStart.
while (parse_tree_->node_kind(node_stack_.back().parse_node) !=
while (parse_tree_->node_kind(node_stack_.PeekParseNode()) !=
ParseNodeKind::FunctionDefinitionStart) {
node_stack_.pop_back();
node_stack_.PopAndIgnore();
}
Pop(ParseNodeKind::FunctionDefinitionStart);
node_stack_.PopAndIgnore();
PopScope();
node_block_stack_.pop_back();
Push(parse_node);
node_stack_.Push(parse_node);
}
auto SemanticsParseTreeHandler::HandleFunctionDefinitionStart(
ParseTree::Node parse_node) -> void {
Pop(ParseNodeKind::ParameterList);
auto name_node = node_stack_.back().parse_node;
node_stack_.pop_back();
auto fn_node = node_stack_.back().parse_node;
Pop(ParseNodeKind::FunctionIntroducer);
node_stack_.PopAndDiscardSoloParseNode(ParseNodeKind::ParameterList);
auto name_node = node_stack_.PopForSoloParseNode(ParseNodeKind::DeclaredName);
auto fn_node =
node_stack_.PopForSoloParseNode(ParseNodeKind::FunctionIntroducer);
auto decl_id = AddNode(SemanticsNode::MakeFunctionDeclaration(fn_node));
// TODO: Propagate the type of the function.
@@ -408,13 +306,13 @@ auto SemanticsParseTreeHandler::HandleFunctionDefinitionStart(
AddNode(SemanticsNode::MakeFunctionDefinition(parse_node, decl_id, block_id));
node_block_stack_.push_back(block_id);
PushScope();
Push(parse_node);
node_stack_.Push(parse_node);
}
auto SemanticsParseTreeHandler::HandleFunctionIntroducer(
ParseTree::Node parse_node) -> void {
// No action, just a bracketing node.
Push(parse_node);
node_stack_.Push(parse_node);
}
auto SemanticsParseTreeHandler::HandleIfCondition(
@@ -439,8 +337,8 @@ auto SemanticsParseTreeHandler::HandleIfStatementElse(
auto SemanticsParseTreeHandler::HandleInfixOperator(ParseTree::Node parse_node)
-> void {
auto rhs_id = PopWithResult();
auto lhs_id = PopWithResult();
auto rhs_id = node_stack_.PopForNodeId();
auto lhs_id = node_stack_.PopForNodeId();
SemanticsNodeId result_type =
TryTypeConversion(parse_node, lhs_id, rhs_id, /*can_convert_lhs=*/true);
@@ -448,8 +346,8 @@ auto SemanticsParseTreeHandler::HandleInfixOperator(ParseTree::Node parse_node)
auto token = parse_tree_->node_token(parse_node);
switch (auto token_kind = tokens_->GetKind(token)) {
case TokenKind::Plus:
Push(parse_node, SemanticsNode::MakeBinaryOperatorAdd(
parse_node, result_type, lhs_id, rhs_id));
AddNodeAndPush(parse_node, SemanticsNode::MakeBinaryOperatorAdd(
parse_node, result_type, lhs_id, rhs_id));
break;
default:
CARBON_FATAL() << "Unrecognized token kind: " << token_kind.name();
@@ -478,19 +376,20 @@ auto SemanticsParseTreeHandler::HandleLiteral(ParseTree::Node parse_node)
case TokenKind::IntegerLiteral: {
auto id =
semantics_->AddIntegerLiteral(tokens_->GetIntegerLiteral(token));
Push(parse_node, SemanticsNode::MakeIntegerLiteral(parse_node, id));
AddNodeAndPush(parse_node,
SemanticsNode::MakeIntegerLiteral(parse_node, id));
break;
}
case TokenKind::RealLiteral: {
// TODO: Add storage of the Real literal.
Push(parse_node, SemanticsNode::MakeRealLiteral(parse_node));
AddNodeAndPush(parse_node, SemanticsNode::MakeRealLiteral(parse_node));
break;
}
case TokenKind::IntegerTypeLiteral: {
auto text = tokens_->GetTokenText(token);
CARBON_CHECK(text == "i32") << "Currently only i32 is allowed";
Push(parse_node, SemanticsNodeId::MakeBuiltinReference(
SemanticsBuiltinKind::IntegerType));
node_stack_.Push(parse_node, SemanticsNodeId::MakeBuiltinReference(
SemanticsBuiltinKind::IntegerType));
break;
}
default:
@@ -506,8 +405,8 @@ auto SemanticsParseTreeHandler::HandleNameReference(ParseTree::Node parse_node)
CARBON_DIAGNOSTIC(NameNotFound, Error, "Name {0} not found",
llvm::StringRef);
emitter_->Emit(parse_node, NameNotFound, name_str);
Push(parse_node, SemanticsNodeId::MakeBuiltinReference(
SemanticsBuiltinKind::InvalidType));
node_stack_.Push(parse_node, SemanticsNodeId::MakeBuiltinReference(
SemanticsBuiltinKind::InvalidType));
};
auto name_id = semantics_->GetString(name_str);
@@ -524,7 +423,7 @@ auto SemanticsParseTreeHandler::HandleNameReference(ParseTree::Node parse_node)
CARBON_CHECK(!it->second.empty()) << "Should have been erased: " << name_str;
// TODO: Check for ambiguous lookups.
Push(parse_node, it->second.back());
node_stack_.Push(parse_node, it->second.back());
}
auto SemanticsParseTreeHandler::HandlePackageApi(ParseTree::Node /*parse_node*/)
@@ -556,8 +455,8 @@ auto SemanticsParseTreeHandler::HandleParameterList(ParseTree::Node parse_node)
-> void {
// TODO: This should transform into a usable parameter list. For now
// it's unused and only stored so that node counts match.
Pop(ParseNodeKind::ParameterListStart);
Push(parse_node);
node_stack_.PopAndDiscardSoloParseNode(ParseNodeKind::ParameterListStart);
node_stack_.Push(parse_node);
}
auto SemanticsParseTreeHandler::HandleParameterListComma(
@@ -568,7 +467,7 @@ auto SemanticsParseTreeHandler::HandleParameterListComma(
auto SemanticsParseTreeHandler::HandleParameterListStart(
ParseTree::Node parse_node) -> void {
// TODO: See HandleParameterList.
Push(parse_node);
node_stack_.Push(parse_node);
}
auto SemanticsParseTreeHandler::HandleParenExpression(
@@ -583,23 +482,21 @@ auto SemanticsParseTreeHandler::HandleParenExpressionOrTupleLiteralStart(
auto SemanticsParseTreeHandler::HandlePatternBinding(ParseTree::Node parse_node)
-> void {
auto type = node_stack_.pop_back_val();
CARBON_CHECK(type.result_id.is_valid());
auto type = node_stack_.PopForNodeId();
// Get the name.
auto name_node = node_stack_.pop_back_val().parse_node;
auto name_node = node_stack_.PopForSoloParseNode();
// Allocate storage, linked to the name for error locations.
auto storage_id =
AddNode(SemanticsNode::MakeVarStorage(name_node, type.result_id));
auto storage_id = AddNode(SemanticsNode::MakeVarStorage(name_node, type));
// Bind the name to storage.
auto name_id = BindName(name_node, type.result_id, storage_id);
auto name_id = BindName(name_node, type, storage_id);
// If this node's result is used, it'll be for either the name or the storage
// address. The storage address can be found through the name, so we push the
// name.
Push(parse_node, name_id);
node_stack_.Push(parse_node, name_id);
}
auto SemanticsParseTreeHandler::HandlePostfixOperator(
@@ -614,23 +511,23 @@ auto SemanticsParseTreeHandler::HandlePrefixOperator(
auto SemanticsParseTreeHandler::HandleReturnStatement(
ParseTree::Node parse_node) -> void {
if (parse_tree_->node_kind(node_stack_.back().parse_node) ==
if (parse_tree_->node_kind(node_stack_.PeekParseNode()) ==
ParseNodeKind::ReturnStatementStart) {
Pop(ParseNodeKind::ReturnStatementStart);
Push(parse_node, SemanticsNode::MakeReturn(parse_node));
node_stack_.PopAndDiscardSoloParseNode(ParseNodeKind::ReturnStatementStart);
AddNodeAndPush(parse_node, SemanticsNode::MakeReturn(parse_node));
} else {
auto arg = PopWithResult();
auto arg = node_stack_.PopForNodeId();
auto arg_type = semantics_->GetType(arg);
Pop(ParseNodeKind::ReturnStatementStart);
Push(parse_node,
SemanticsNode::MakeReturnExpression(parse_node, arg_type, arg));
node_stack_.PopAndDiscardSoloParseNode(ParseNodeKind::ReturnStatementStart);
AddNodeAndPush(parse_node, SemanticsNode::MakeReturnExpression(
parse_node, arg_type, arg));
}
}
auto SemanticsParseTreeHandler::HandleReturnStatementStart(
ParseTree::Node parse_node) -> void {
// No action, just a bracketing node.
Push(parse_node);
node_stack_.Push(parse_node);
}
auto SemanticsParseTreeHandler::HandleReturnType(ParseTree::Node /*parse_node*/)
@@ -700,49 +597,45 @@ auto SemanticsParseTreeHandler::HandleTupleLiteralComma(
auto SemanticsParseTreeHandler::HandleVariableDeclaration(
ParseTree::Node parse_node) -> void {
auto last_child = node_stack_.pop_back_val();
CARBON_CHECK(last_child.result_id.is_valid());
auto last_child = node_stack_.PopForParseNodeAndNodeId();
if (parse_tree_->node_kind(last_child.parse_node) !=
if (parse_tree_->node_kind(last_child.first) !=
ParseNodeKind::PatternBinding) {
SemanticsNodeId init_id = last_child.result_id;
auto storage_id = PopWithResult(ParseNodeKind::VariableInitializer);
auto storage_id =
node_stack_.PopForNodeId(ParseNodeKind::VariableInitializer);
auto binding = node_stack_.pop_back_val();
CARBON_CHECK(parse_tree_->node_kind(binding.parse_node) ==
auto binding = node_stack_.PopForParseNodeAndNameId();
CARBON_CHECK(parse_tree_->node_kind(binding.first) ==
ParseNodeKind::PatternBinding);
CARBON_CHECK(binding.name_id.is_valid());
CARBON_CHECK(binding.second.is_valid());
// Restore the name now that the initializer is complete.
AddNameToLookup(binding.name_id, storage_id);
AddNameToLookup(binding.second, storage_id);
auto storage_type = TryTypeConversion(parse_node, storage_id, init_id,
/*can_convert_lhs=*/false);
auto storage_type =
TryTypeConversion(parse_node, storage_id, last_child.second,
/*can_convert_lhs=*/false);
AddNode(SemanticsNode::MakeAssign(parse_node, storage_type, storage_id,
init_id));
last_child.second));
}
Pop(ParseNodeKind::VariableIntroducer);
Push(parse_node);
node_stack_.PopAndDiscardSoloParseNode(ParseNodeKind::VariableIntroducer);
node_stack_.Push(parse_node);
}
auto SemanticsParseTreeHandler::HandleVariableIntroducer(
ParseTree::Node parse_node) -> void {
// No action, just a bracketing node.
Push(parse_node);
node_stack_.Push(parse_node);
}
auto SemanticsParseTreeHandler::HandleVariableInitializer(
ParseTree::Node parse_node) -> void {
// Temporarily remove name lookup entries added by the `var`. These will be
// restored by `VariableDeclaration`.
auto back = node_stack_.back();
CARBON_CHECK(parse_tree_->node_kind(back.parse_node) ==
ParseNodeKind::PatternBinding)
<< parse_tree_->node_kind(back.parse_node);
// Save the storage ID.
auto it = name_lookup_.find(back.name_id);
auto it = name_lookup_.find(node_stack_.PeekForNameId());
CARBON_CHECK(it != name_lookup_.end());
CARBON_CHECK(!it->second.empty());
auto storage_id = it->second.back();
@@ -755,7 +648,7 @@ auto SemanticsParseTreeHandler::HandleVariableInitializer(
it->second.pop_back();
}
Push(parse_node, storage_id);
node_stack_.Push(parse_node, storage_id);
}
auto SemanticsParseTreeHandler::HandleWhileCondition(