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
Files
11deb14dc65625ac72296a69ee262051e53c43e0
carbon-lang/toolchain/semantics/semantics_parse_tree_handler.cpp
T
Jon Ross-Perkins 11deb14dc6 Handle var init-with-self situations. (#2488) 
The problem I'm trying to solve is: `var x: i32 = x;`. This change makes it so that name lookup fails, by removing `x` from name lookup between the `=` and `;`.

`var x: i32` still adds to name lookup to handle future situations like `var (x: i32, x: i32);` which is still a redefinition of `x`; if we don't add `x` to name lookup, it gets harder to catch that example.

The VariableDeclaration/VariableInitializer refactor in ParseTree supports this by given a bracketing-like structure for semantics to cue that it's entering an initialization expression. With this, VariableInitializer can remove the name lookup and queue it to be restored. VariableDeclaration doesn't need to change too much since it's still bracketed by VariableIntroducer, and so we just traverse slightly differently.

Note this also incidentally changes a little about NameReference, that it's returning the storage consistently instead of the name. You can see this e.g. in global_lookup.carbon, `Assign(node8, node4): node2;` using node4 (VarStorage) instead of Node5 (BindName). Really either _could_ work, since from a BindName we can get to the VarStorage, and that may be reason to switch later if we find it preferable to have the BindName for whatever reason.

But the *actual* value in NameLookup is a BindName so that errors can associate with the _name_ instead of the "storage" parse node, which is currently the `:`. This is mainly for fail_duplicate_decl.carbon, which has a "Previous definition" note that points at the storage's parse node.
2022-12-28 12:55:40 -08:00

778 lines
25 KiB
C++
Raw Blame History

// Part of the Carbon Language project, under the Apache License v2.0 with LLVM
// Exceptions. See /LICENSE for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
#include "toolchain/semantics/semantics_parse_tree_handler.h"
#include "common/vlog.h"
#include "llvm/Support/PrettyStackTrace.h"
#include "toolchain/lexer/token_kind.h"
#include "toolchain/lexer/tokenized_buffer.h"
#include "toolchain/parser/parse_node_kind.h"
#include "toolchain/semantics/semantics_builtin_kind.h"
#include "toolchain/semantics/semantics_node.h"
namespace Carbon {
class SemanticsParseTreeHandler::PrettyStackTraceNodeStack
: public llvm::PrettyStackTraceEntry {
public:
explicit PrettyStackTraceNodeStack(const SemanticsParseTreeHandler* handler)
: handler_(handler) {}
~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";
}
}
private:
const SemanticsParseTreeHandler* handler_;
};
class SemanticsParseTreeHandler::PrettyStackTraceNodeBlockStack
: public llvm::PrettyStackTraceEntry {
public:
explicit PrettyStackTraceNodeBlockStack(
const SemanticsParseTreeHandler* handler)
: handler_(handler) {}
~PrettyStackTraceNodeBlockStack() override = default;
auto print(llvm::raw_ostream& output) const -> void override {
output << "node_block_stack_:\n";
for (int i = 0; i < static_cast<int>(handler_->node_block_stack_.size());
++i) {
const auto& entry = handler_->node_block_stack_[i];
output << "\t" << i << ".\t" << entry << "\n";
}
}
private:
const SemanticsParseTreeHandler* handler_;
};
auto SemanticsParseTreeHandler::Build() -> void {
PrettyStackTraceNodeStack pretty_node_stack(this);
PrettyStackTraceNodeBlockStack pretty_node_block_stack(this);
// Add a block for the ParseTree.
node_block_stack_.push_back(semantics_->AddNodeBlock());
PushScope();
for (auto parse_node : parse_tree_->postorder()) {
switch (auto parse_kind = parse_tree_->node_kind(parse_node)) {
#define CARBON_PARSE_NODE_KIND(Name) \
case ParseNodeKind::Name(): { \
Handle##Name(parse_node); \
break; \
}
#include "toolchain/parser/parse_node_kind.def"
}
}
node_block_stack_.pop_back();
CARBON_CHECK(node_block_stack_.empty()) << node_block_stack_.size();
PopScope();
CARBON_CHECK(name_lookup_.empty()) << name_lookup_.size();
CARBON_CHECK(scope_stack_.empty()) << scope_stack_.size();
}
auto SemanticsParseTreeHandler::AddNode(SemanticsNode node) -> SemanticsNodeId {
CARBON_VLOG() << "AddNode " << current_block_id() << ": " << node << "\n";
return semantics_->AddNode(current_block_id(), node);
}
auto SemanticsParseTreeHandler::BindName(ParseTree::Node name_node,
SemanticsNodeId type_id,
SemanticsNodeId target_id)
-> SemanticsStringId {
CARBON_CHECK(parse_tree_->node_kind(name_node) ==
ParseNodeKind::DeclaredName())
<< parse_tree_->node_kind(name_node);
auto name_str = parse_tree_->GetNodeText(name_node);
auto name_id = semantics_->AddString(name_str);
AddNode(SemanticsNode::MakeBindName(name_node, type_id, name_id, target_id));
auto [it, inserted] = current_scope().names.insert(name_id);
if (inserted) {
name_lookup_[name_id].push_back(target_id);
} else {
CARBON_DIAGNOSTIC(NameRedefined, Error, "Redefining {0} in the same scope.",
llvm::StringRef);
CARBON_DIAGNOSTIC(PreviousDefinition, Note, "Previous definition is here.");
auto prev_def_id = name_lookup_[name_id].back();
auto prev_def = semantics_->GetNode(prev_def_id);
emitter_->Build(name_node, NameRedefined, name_str)
.Note(prev_def.parse_node(), PreviousDefinition)
.Emit();
}
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({});
}
auto SemanticsParseTreeHandler::PopScope() -> void {
auto scope = scope_stack_.pop_back_val();
for (const auto& str_id : scope.names) {
auto it = name_lookup_.find(str_id);
if (it->second.size() == 1) {
// Erase names that no longer resolve.
name_lookup_.erase(it);
} else {
it->second.pop_back();
}
}
}
auto SemanticsParseTreeHandler::TryTypeConversion(ParseTree::Node parse_node,
SemanticsNodeId lhs_id,
SemanticsNodeId rhs_id,
bool /*can_convert_lhs*/)
-> SemanticsNodeId {
auto lhs_type = semantics_->GetType(lhs_id);
auto rhs_type = semantics_->GetType(rhs_id);
// TODO: This should attempt a type conversion, but there's not enough
// implemented to do that right now.
if (lhs_type != rhs_type) {
auto invalid_type = SemanticsNodeId::MakeBuiltinReference(
SemanticsBuiltinKind::InvalidType());
if (lhs_type != invalid_type && rhs_type != invalid_type) {
// TODO: This is a poor diagnostic, and should be expanded.
CARBON_DIAGNOSTIC(TypeMismatch, Error,
"Type mismatch: lhs is {0}, rhs is {1}",
SemanticsNodeId, SemanticsNodeId);
emitter_->Emit(parse_node, TypeMismatch, lhs_type, rhs_type);
}
return invalid_type;
}
return lhs_type;
}
auto SemanticsParseTreeHandler::HandleAddress(ParseTree::Node /*parse_node*/)
-> void {
CARBON_FATAL() << "TODO";
}
auto SemanticsParseTreeHandler::HandleBreakStatement(
ParseTree::Node /*parse_node*/) -> void {
CARBON_FATAL() << "TODO";
}
auto SemanticsParseTreeHandler::HandleBreakStatementStart(
ParseTree::Node /*parse_node*/) -> void {
CARBON_FATAL() << "TODO";
}
auto SemanticsParseTreeHandler::HandleCallExpression(
ParseTree::Node /*parse_node*/) -> void {
CARBON_FATAL() << "TODO";
}
auto SemanticsParseTreeHandler::HandleCallExpressionComma(
ParseTree::Node /*parse_node*/) -> void {
CARBON_FATAL() << "TODO";
}
auto SemanticsParseTreeHandler::HandleCallExpressionStart(
ParseTree::Node /*parse_node*/) -> void {
CARBON_FATAL() << "TODO";
}
auto SemanticsParseTreeHandler::HandleCodeBlock(ParseTree::Node /*parse_node*/)
-> void {
CARBON_FATAL() << "TODO";
}
auto SemanticsParseTreeHandler::HandleCodeBlockStart(
ParseTree::Node /*parse_node*/) -> void {
CARBON_FATAL() << "TODO";
}
auto SemanticsParseTreeHandler::HandleContinueStatement(
ParseTree::Node /*parse_node*/) -> void {
CARBON_FATAL() << "TODO";
}
auto SemanticsParseTreeHandler::HandleContinueStatementStart(
ParseTree::Node /*parse_node*/) -> void {
CARBON_FATAL() << "TODO";
}
auto SemanticsParseTreeHandler::HandleDeclaredName(ParseTree::Node parse_node)
-> void {
// The parent is responsible for binding the name.
Push(parse_node);
}
auto SemanticsParseTreeHandler::HandleDeducedParameterList(
ParseTree::Node /*parse_node*/) -> void {
CARBON_FATAL() << "TODO";
}
auto SemanticsParseTreeHandler::HandleDeducedParameterListStart(
ParseTree::Node /*parse_node*/) -> void {
CARBON_FATAL() << "TODO";
}
auto SemanticsParseTreeHandler::HandleDesignatedName(
ParseTree::Node /*parse_node*/) -> void {
CARBON_FATAL() << "TODO";
}
auto SemanticsParseTreeHandler::HandleDesignatorExpression(
ParseTree::Node /*parse_node*/) -> void {
CARBON_FATAL() << "TODO";
}
auto SemanticsParseTreeHandler::HandleEmptyDeclaration(
ParseTree::Node parse_node) -> void {
// Empty declarations have no actions associated, but we still balance the
// tree.
Push(parse_node);
}
auto SemanticsParseTreeHandler::HandleExpressionStatement(
ParseTree::Node parse_node) -> void {
// Pop the expression without investigating its contents.
// TODO: This will probably eventually need to do some "do not discard"
// analysis.
PopWithResult();
Push(parse_node);
}
auto SemanticsParseTreeHandler::HandleFileEnd(ParseTree::Node /*parse_node*/)
-> void {
// Do nothing, no need to balance this node.
}
auto SemanticsParseTreeHandler::HandleForHeader(ParseTree::Node /*parse_node*/)
-> void {
CARBON_FATAL() << "TODO";
}
auto SemanticsParseTreeHandler::HandleForHeaderStart(
ParseTree::Node /*parse_node*/) -> void {
CARBON_FATAL() << "TODO";
}
auto SemanticsParseTreeHandler::HandleForIn(ParseTree::Node /*parse_node*/)
-> void {
CARBON_FATAL() << "TODO";
}
auto SemanticsParseTreeHandler::HandleForStatement(
ParseTree::Node /*parse_node*/) -> void {
CARBON_FATAL() << "TODO";
}
auto SemanticsParseTreeHandler::HandleFunctionDeclaration(
ParseTree::Node /*parse_node*/) -> void {
CARBON_FATAL() << "TODO";
}
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) !=
ParseNodeKind::FunctionDefinitionStart()) {
node_stack_.pop_back();
}
Pop(ParseNodeKind::FunctionDefinitionStart());
PopScope();
node_block_stack_.pop_back();
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());
auto decl_id = AddNode(SemanticsNode::MakeFunctionDeclaration(fn_node));
// TODO: Propagate the type of the function.
BindName(name_node, SemanticsNodeId::MakeInvalid(), decl_id);
auto block_id = semantics_->AddNodeBlock();
AddNode(SemanticsNode::MakeFunctionDefinition(parse_node, decl_id, block_id));
node_block_stack_.push_back(block_id);
PushScope();
Push(parse_node);
}
auto SemanticsParseTreeHandler::HandleFunctionIntroducer(
ParseTree::Node parse_node) -> void {
// No action, just a bracketing node.
Push(parse_node);
}
auto SemanticsParseTreeHandler::HandleIfCondition(
ParseTree::Node /*parse_node*/) -> void {
CARBON_FATAL() << "TODO";
}
auto SemanticsParseTreeHandler::HandleIfConditionStart(
ParseTree::Node /*parse_node*/) -> void {
CARBON_FATAL() << "TODO";
}
auto SemanticsParseTreeHandler::HandleIfStatement(
ParseTree::Node /*parse_node*/) -> void {
CARBON_FATAL() << "TODO";
}
auto SemanticsParseTreeHandler::HandleIfStatementElse(
ParseTree::Node /*parse_node*/) -> void {
CARBON_FATAL() << "TODO";
}
auto SemanticsParseTreeHandler::HandleInfixOperator(ParseTree::Node parse_node)
-> void {
auto rhs_id = PopWithResult();
auto lhs_id = PopWithResult();
SemanticsNodeId result_type =
TryTypeConversion(parse_node, lhs_id, rhs_id, /*can_convert_lhs=*/true);
// Figure out the operator for the token.
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));
break;
default:
CARBON_FATAL() << "Unrecognized token kind: " << token_kind.name();
}
}
auto SemanticsParseTreeHandler::HandleInterfaceBody(
ParseTree::Node /*parse_node*/) -> void {
CARBON_FATAL() << "TODO";
}
auto SemanticsParseTreeHandler::HandleInterfaceBodyStart(
ParseTree::Node /*parse_node*/) -> void {
CARBON_FATAL() << "TODO";
}
auto SemanticsParseTreeHandler::HandleInterfaceDefinition(
ParseTree::Node /*parse_node*/) -> void {
CARBON_FATAL() << "TODO";
}
auto SemanticsParseTreeHandler::HandleLiteral(ParseTree::Node parse_node)
-> void {
auto token = parse_tree_->node_token(parse_node);
switch (auto token_kind = tokens_->GetKind(token)) {
case TokenKind::IntegerLiteral(): {
auto id =
semantics_->AddIntegerLiteral(tokens_->GetIntegerLiteral(token));
Push(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));
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()));
break;
}
default:
CARBON_FATAL() << "Unhandled kind: " << token_kind.name();
}
}
auto SemanticsParseTreeHandler::HandleNameReference(ParseTree::Node parse_node)
-> void {
auto name_str = parse_tree_->GetNodeText(parse_node);
auto name_not_found = [&] {
CARBON_DIAGNOSTIC(NameNotFound, Error, "Name {0} not found",
llvm::StringRef);
emitter_->Emit(parse_node, NameNotFound, name_str);
Push(parse_node, SemanticsNodeId::MakeBuiltinReference(
SemanticsBuiltinKind::InvalidType()));
};
auto name_id = semantics_->GetString(name_str);
if (!name_id) {
name_not_found();
return;
}
auto it = name_lookup_.find(*name_id);
if (it == name_lookup_.end()) {
name_not_found();
return;
}
CARBON_CHECK(!it->second.empty()) << "Should have been erased: " << name_str;
// TODO: Check for ambiguous lookups.
Push(parse_node, it->second.back());
}
auto SemanticsParseTreeHandler::HandlePackageApi(ParseTree::Node /*parse_node*/)
-> void {
CARBON_FATAL() << "TODO";
}
auto SemanticsParseTreeHandler::HandlePackageDirective(
ParseTree::Node /*parse_node*/) -> void {
CARBON_FATAL() << "TODO";
}
auto SemanticsParseTreeHandler::HandlePackageImpl(
ParseTree::Node /*parse_node*/) -> void {
CARBON_FATAL() << "TODO";
}
auto SemanticsParseTreeHandler::HandlePackageIntroducer(
ParseTree::Node /*parse_node*/) -> void {
CARBON_FATAL() << "TODO";
}
auto SemanticsParseTreeHandler::HandlePackageLibrary(
ParseTree::Node /*parse_node*/) -> void {
CARBON_FATAL() << "TODO";
}
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);
}
auto SemanticsParseTreeHandler::HandleParameterListComma(
ParseTree::Node /*parse_node*/) -> void {
CARBON_FATAL() << "TODO";
}
auto SemanticsParseTreeHandler::HandleParameterListStart(
ParseTree::Node parse_node) -> void {
// TODO: See HandleParameterList.
Push(parse_node);
}
auto SemanticsParseTreeHandler::HandleParenExpression(
ParseTree::Node /*parse_node*/) -> void {
CARBON_FATAL() << "TODO";
}
auto SemanticsParseTreeHandler::HandleParenExpressionOrTupleLiteralStart(
ParseTree::Node /*parse_node*/) -> void {
CARBON_FATAL() << "TODO";
}
auto SemanticsParseTreeHandler::HandlePatternBinding(ParseTree::Node parse_node)
-> void {
auto type = node_stack_.pop_back_val();
CARBON_CHECK(type.result_id.is_valid());
// Get the name.
auto name_node = node_stack_.pop_back_val().parse_node;
// Allocate storage, linked to the name for error locations.
auto storage_id =
AddNode(SemanticsNode::MakeVarStorage(name_node, type.result_id));
// Bind the name to storage.
auto name_id = BindName(name_node, type.result_id, 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);
}
auto SemanticsParseTreeHandler::HandlePostfixOperator(
ParseTree::Node /*parse_node*/) -> void {
CARBON_FATAL() << "TODO";
}
auto SemanticsParseTreeHandler::HandlePrefixOperator(
ParseTree::Node /*parse_node*/) -> void {
CARBON_FATAL() << "TODO";
}
auto SemanticsParseTreeHandler::HandleReturnStatement(
ParseTree::Node parse_node) -> void {
if (parse_tree_->node_kind(node_stack_.back().parse_node) ==
ParseNodeKind::ReturnStatementStart()) {
Pop(ParseNodeKind::ReturnStatementStart());
Push(parse_node, SemanticsNode::MakeReturn(parse_node));
} else {
auto arg = PopWithResult();
auto arg_type = semantics_->GetType(arg);
Pop(ParseNodeKind::ReturnStatementStart());
Push(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);
}
auto SemanticsParseTreeHandler::HandleReturnType(ParseTree::Node /*parse_node*/)
-> void {
CARBON_FATAL() << "TODO";
}
auto SemanticsParseTreeHandler::HandleSelfDeducedParameter(
ParseTree::Node /*parse_node*/) -> void {
CARBON_FATAL() << "TODO";
}
auto SemanticsParseTreeHandler::HandleSelfType(ParseTree::Node /*parse_node*/)
-> void {
CARBON_FATAL() << "TODO";
}
auto SemanticsParseTreeHandler::HandleStructComma(
ParseTree::Node /*parse_node*/) -> void {
CARBON_FATAL() << "TODO";
}
auto SemanticsParseTreeHandler::HandleStructFieldDesignator(
ParseTree::Node /*parse_node*/) -> void {
CARBON_FATAL() << "TODO";
}
auto SemanticsParseTreeHandler::HandleStructFieldType(
ParseTree::Node /*parse_node*/) -> void {
CARBON_FATAL() << "TODO";
}
auto SemanticsParseTreeHandler::HandleStructFieldUnknown(
ParseTree::Node /*parse_node*/) -> void {
CARBON_FATAL() << "TODO";
}
auto SemanticsParseTreeHandler::HandleStructFieldValue(
ParseTree::Node /*parse_node*/) -> void {
CARBON_FATAL() << "TODO";
}
auto SemanticsParseTreeHandler::HandleStructLiteral(
ParseTree::Node /*parse_node*/) -> void {
CARBON_FATAL() << "TODO";
}
auto SemanticsParseTreeHandler::HandleStructLiteralOrStructTypeLiteralStart(
ParseTree::Node /*parse_node*/) -> void {
CARBON_FATAL() << "TODO";
}
auto SemanticsParseTreeHandler::HandleStructTypeLiteral(
ParseTree::Node /*parse_node*/) -> void {
CARBON_FATAL() << "TODO";
}
auto SemanticsParseTreeHandler::HandleTupleLiteral(
ParseTree::Node /*parse_node*/) -> void {
CARBON_FATAL() << "TODO";
}
auto SemanticsParseTreeHandler::HandleTupleLiteralComma(
ParseTree::Node /*parse_node*/) -> void {
CARBON_FATAL() << "TODO";
}
auto SemanticsParseTreeHandler::HandleVariableDeclaration(
ParseTree::Node parse_node) -> void {
auto last_child = node_stack_.pop_back_val();
CARBON_CHECK(last_child.result_id.is_valid());
if (parse_tree_->node_kind(last_child.parse_node) !=
ParseNodeKind::PatternBinding()) {
SemanticsNodeId init_id = last_child.result_id;
auto storage_id = PopWithResult(ParseNodeKind::VariableInitializer());
auto binding = node_stack_.pop_back_val();
CARBON_CHECK(parse_tree_->node_kind(binding.parse_node) ==
ParseNodeKind::PatternBinding());
CARBON_CHECK(binding.name_id.is_valid());
// Restore the name now that the initializer is complete.
AddNameToLookup(binding.name_id, storage_id);
auto storage_type = TryTypeConversion(parse_node, storage_id, init_id,
/*can_convert_lhs=*/false);
AddNode(SemanticsNode::MakeAssign(parse_node, storage_type, storage_id,
init_id));
}
Pop(ParseNodeKind::VariableIntroducer());
Push(parse_node);
}
auto SemanticsParseTreeHandler::HandleVariableIntroducer(
ParseTree::Node parse_node) -> void {
// No action, just a bracketing node.
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);
CARBON_CHECK(it != name_lookup_.end());
CARBON_CHECK(!it->second.empty());
auto storage_id = it->second.back();
// Pop the name from lookup.
if (it->second.size() == 1) {
// Erase names that no longer resolve.
name_lookup_.erase(it);
} else {
it->second.pop_back();
}
Push(parse_node, storage_id);
}
auto SemanticsParseTreeHandler::HandleWhileCondition(
ParseTree::Node /*parse_node*/) -> void {
CARBON_FATAL() << "TODO";
}
auto SemanticsParseTreeHandler::HandleWhileConditionStart(
ParseTree::Node /*parse_node*/) -> void {
CARBON_FATAL() << "TODO";
}
auto SemanticsParseTreeHandler::HandleWhileStatement(
ParseTree::Node /*parse_node*/) -> void {
CARBON_FATAL() << "TODO";
}
} // namespace Carbon
Reference in New Issue View Git Blame Copy Permalink