mirror of
https://github.com/carbon-language/carbon-lang.git
synced 2026-09-28 22:02:37 +01:00
Jon Ross-Perkins
6feed2ae33
For parameters (and in the future, arguments too; generally comma-separated lists) track two node blocks: 1. param_ir: The complete IR. 2. param_refs: Nodes within the IR that are the "root" parameter. param_refs should allow quick counting of the # of parameters, and more efficient comparison of call args with function parameters. param_ir should be necessary to generate the actual signature. In order to construct this, this refactors the node_block_stack into its own class, which is reused in params_stack. These carry references to the underlying SmallVector for lazy modification in order to avoid a dependency cycle with SemanticsIR (also see notes on empty node blocks below). When finalized, the block pair is pushed onto finished_params_stack. That's because node_stack only has space for one thing, and this is two things -- so I'm essentially choosing a trade-off of adding another stack in order to avoid consuming more space in the expectation that most parse nodes have 0 or 1 things to return, and 2 will be very rare. As factored, this currently consolidates most empty node blocks into a single canonical empty node block. This is because I think empty blocks, i.e. `()`, will be very common. In order to achieve this, SemanticsNodeBlockStack does lazy creation. An alternative approach would have been to use 1 node block per parameter. We decided against this in order to reduce the number of vectors being created.
124 lines
4.1 KiB
C++
124 lines
4.1 KiB
C++
// 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_ir.h"
|
|
|
|
#include "common/check.h"
|
|
#include "toolchain/parser/parse_tree_node_location_translator.h"
|
|
#include "toolchain/semantics/semantics_builtin_kind.h"
|
|
#include "toolchain/semantics/semantics_node.h"
|
|
#include "toolchain/semantics/semantics_parse_tree_handler.h"
|
|
|
|
namespace Carbon {
|
|
|
|
auto SemanticsIR::MakeBuiltinIR() -> SemanticsIR {
|
|
SemanticsIR semantics(/*builtin_ir=*/nullptr);
|
|
auto block_id = semantics.AddNodeBlock();
|
|
semantics.nodes_.reserve(SemanticsBuiltinKind::ValidCount);
|
|
|
|
constexpr int32_t TypeOfTypeType = 0;
|
|
auto type_type = semantics.AddNode(
|
|
block_id, SemanticsNode::MakeBuiltin(SemanticsBuiltinKind::TypeType,
|
|
SemanticsNodeId(TypeOfTypeType)));
|
|
CARBON_CHECK(type_type.index == TypeOfTypeType)
|
|
<< "TypeType's type must be self-referential.";
|
|
|
|
constexpr int32_t TypeOfInvalidType = 1;
|
|
auto invalid_type = semantics.AddNode(
|
|
block_id, SemanticsNode::MakeBuiltin(SemanticsBuiltinKind::InvalidType,
|
|
SemanticsNodeId(TypeOfInvalidType)));
|
|
CARBON_CHECK(invalid_type.index == TypeOfInvalidType)
|
|
<< "InvalidType's type must be self-referential.";
|
|
|
|
semantics.AddNode(
|
|
block_id,
|
|
SemanticsNode::MakeBuiltin(SemanticsBuiltinKind::IntegerType, type_type));
|
|
|
|
semantics.AddNode(block_id, SemanticsNode::MakeBuiltin(
|
|
SemanticsBuiltinKind::RealType, type_type));
|
|
|
|
CARBON_CHECK(semantics.node_blocks_.size() == 2)
|
|
<< "BuildBuiltins should produce 2 blocks, actual: "
|
|
<< semantics.node_blocks_.size();
|
|
return semantics;
|
|
}
|
|
|
|
auto SemanticsIR::MakeFromParseTree(const SemanticsIR& builtin_ir,
|
|
const TokenizedBuffer& tokens,
|
|
const ParseTree& parse_tree,
|
|
DiagnosticConsumer& consumer,
|
|
llvm::raw_ostream* vlog_stream)
|
|
-> SemanticsIR {
|
|
SemanticsIR semantics(&builtin_ir);
|
|
|
|
// Copy builtins over.
|
|
semantics.nodes_.resize_for_overwrite(SemanticsBuiltinKind::ValidCount);
|
|
static constexpr auto BuiltinIR = SemanticsCrossReferenceIRId(0);
|
|
for (int i = 0; i < SemanticsBuiltinKind::ValidCount; ++i) {
|
|
// We can reuse the type node ID because the offsets of cross-references
|
|
// will be the same in this IR.
|
|
auto type = builtin_ir.nodes_[i].type();
|
|
semantics.nodes_[i] =
|
|
SemanticsNode::MakeCrossReference(type, BuiltinIR, SemanticsNodeId(i));
|
|
}
|
|
|
|
ParseTreeNodeLocationTranslator translator(&tokens, &parse_tree);
|
|
ErrorTrackingDiagnosticConsumer err_tracker(consumer);
|
|
DiagnosticEmitter<ParseTree::Node> emitter(translator, err_tracker);
|
|
SemanticsParseTreeHandler(tokens, emitter, parse_tree, semantics, vlog_stream)
|
|
.Build();
|
|
semantics.has_errors_ = err_tracker.seen_error();
|
|
return semantics;
|
|
}
|
|
|
|
auto SemanticsIR::Print(llvm::raw_ostream& out) const -> void {
|
|
constexpr int Indent = 2;
|
|
|
|
out << "cross_reference_irs_size: " << cross_reference_irs_.size() << "\n";
|
|
|
|
out << "callables: [\n";
|
|
for (auto callable : callables_) {
|
|
out.indent(Indent);
|
|
out << callable << "\n";
|
|
}
|
|
out << "]\n";
|
|
|
|
out << "integer_literals: [\n";
|
|
for (const auto& integer_literal : integer_literals_) {
|
|
out.indent(Indent);
|
|
out << integer_literal << ",\n";
|
|
}
|
|
out << "]\n";
|
|
|
|
out << "strings: [\n";
|
|
for (const auto& string : strings_) {
|
|
out.indent(Indent);
|
|
out << string << ",\n";
|
|
}
|
|
out << "]\n";
|
|
|
|
out << "nodes: [\n";
|
|
for (const auto& node : nodes_) {
|
|
out.indent(Indent);
|
|
out << node << ",\n";
|
|
}
|
|
out << "]\n";
|
|
|
|
out << "node_blocks: [\n";
|
|
for (const auto& node_block : node_blocks_) {
|
|
out.indent(Indent);
|
|
out << "[\n";
|
|
|
|
for (const auto& node : node_block) {
|
|
out.indent(2 * Indent);
|
|
out << node << ",\n";
|
|
}
|
|
out.indent(Indent);
|
|
out << "],\n";
|
|
}
|
|
out << "]\n";
|
|
}
|
|
|
|
} // namespace Carbon
|