Files
carbon-lang/toolchain/sem_ir/name_scope.cpp
T
Dana Jansens c64117d0e0 Make IdTag typesafe (#6574)
The IdTag knows the type of the Id its tagging and the type of the Id
being used as the tag. This prevents mixing up tagged and untagged ids,
and avoids having to work with untyped integers.

Adds an Untagged marker struct that's used as the tag type in IdTag when
no tag is desired.

The complexity of ConstantIds and TypeIds became a bit visible: TypeIds
are concrete ConstantIds. And ConstantIds have two different tagging
schemes, one for concrete and one for symbolic ids. And ConstantIds are
actually re-cast InstIds with the same index. The LoweredTypeStore needs
to work with tagged TypeIds, but the tags actually come from an InstId
store in ConstantValueStore. Now this is expressed in the type system by
getting the tags for TypeIds from the ConstantValueStore.

ValueStores without an TagId type parameter are now visibly untagged.

IdTag is now only default constructible when it does not have a tag,
which means ValueStore is only default constructible when the TagId is
untagged. This forces tagged value stores to be constructed correctly
with a tag at compile time, and untagged ones to be constructed without.

FixedSizeValueStore has overloads for dealing with tagged and untagged
Ids, since it can't default-construct ValueStore for tagged ids, and no
longer requires passing in default-constructed tags when there is no tag
in the ids.
2026-01-13 22:44:38 +00:00

103 lines
3.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/sem_ir/name_scope.h"
#include <optional>
#include <utility>
#include "toolchain/sem_ir/file.h"
namespace Carbon::SemIR {
NameScopeStore::NameScopeStore(const File* file)
// 1 reserved untagged id because the Package NameScope is used across
// Files.
: file_(file), values_(file->check_ir_id(), 1) {}
auto NameScope::Print(llvm::raw_ostream& out) const -> void {
out << "{inst: " << inst_id_ << ", parent_scope: " << parent_scope_id_
<< ", has_error: " << (has_error_ ? "true" : "false");
out << ", extended_scopes: [";
llvm::ListSeparator scope_sep;
for (auto id : extended_scopes_) {
out << scope_sep << id;
}
out << "]";
out << ", names: {";
llvm::ListSeparator sep;
for (auto entry : names_) {
if (entry.result.is_poisoned()) {
continue;
}
out << sep << entry.name_id << ": " << entry.result.target_inst_id();
}
out << "}";
out << "}";
}
auto NameScope::AddRequired(Entry name_entry) -> void {
CARBON_CHECK(!name_entry.result.is_poisoned(),
"Cannot add a poisoned name: {0}.", name_entry.name_id);
auto add_name = [&] {
EntryId index(names_.size());
names_.push_back(name_entry);
return index;
};
auto result = name_map_.Insert(name_entry.name_id, add_name);
if (!result.is_inserted()) {
// A required name can overwrite poison.
auto& name = names_[result.value().index];
CARBON_CHECK(name.result.is_poisoned(), "Failed to add required name: {0}",
name_entry.name_id);
name = name_entry;
}
}
auto NameScope::LookupOrAdd(NameId name_id, InstId inst_id,
AccessKind access_kind)
-> std::pair<bool, EntryId> {
auto insert_result = name_map_.Insert(name_id, EntryId(names_.size()));
if (!insert_result.is_inserted()) {
return {false, EntryId(insert_result.value())};
}
names_.push_back({.name_id = name_id,
.result = ScopeLookupResult::MakeWrappedLookupResult(
inst_id, access_kind)});
return {true, EntryId(names_.size() - 1)};
}
auto NameScope::LookupOrPoison(LocId loc_id, NameId name_id)
-> std::optional<EntryId> {
if (!name_id.AsIdentifierId().has_value()) {
return Lookup(name_id);
}
auto insert_result = name_map_.Insert(name_id, EntryId(names_.size()));
if (insert_result.is_inserted()) {
names_.push_back({.name_id = name_id,
.result = ScopeLookupResult::MakePoisoned(loc_id)});
return std::nullopt;
}
return insert_result.value();
}
auto NameScopeStore::GetInstIfValid(NameScopeId scope_id) const
-> std::pair<InstId, std::optional<Inst>> {
if (!scope_id.has_value()) {
return {InstId::None, std::nullopt};
}
auto inst_id = Get(scope_id).inst_id();
if (!inst_id.has_value()) {
return {InstId::None, std::nullopt};
}
return {inst_id, file_->insts().Get(inst_id)};
}
} // namespace Carbon::SemIR