Files
carbon-lang/toolchain/sem_ir/name_scope.h
T
Jon Ross-Perkins 807a3f1370 Add namespace-scoped private keyword support. (#4026)
Adds access to the name lookup table in name scopes. This is so that we
can quickly check access during name lookup without resolving the entity
itself. Does this for names in general, but does not implement handling
for entity-scoped names, only namespace-scoped names (where they're
essentially just not exported).

Excludes `private` names from exports. Although names should be
accessible to `impl` files, that's not implemented here because we'll
probably want to do it by directly copying name lookup tables.
2024-06-06 00:19:56 +00:00

157 lines
5.0 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
#ifndef CARBON_TOOLCHAIN_SEM_IR_NAME_SCOPE_H_
#define CARBON_TOOLCHAIN_SEM_IR_NAME_SCOPE_H_
#include "toolchain/sem_ir/ids.h"
#include "toolchain/sem_ir/inst.h"
namespace Carbon::SemIR {
// Access control for an entity.
enum class AccessKind : int8_t {
Public,
Protected,
Private,
};
struct NameScope : Printable<NameScope> {
struct Entry {
InstId inst_id;
AccessKind access_kind;
};
auto 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: {";
// Sort name keys to get stable output.
llvm::SmallVector<NameId> keys;
for (auto [key, _] : names) {
keys.push_back(key);
}
llvm::sort(keys,
[](NameId lhs, NameId rhs) { return lhs.index < rhs.index; });
llvm::ListSeparator key_sep;
for (auto key : keys) {
out << key_sep << key << ": " << names.find(key)->second.inst_id;
}
out << "}";
out << "}";
}
// Names in the scope.
llvm::DenseMap<NameId, Entry> names = llvm::DenseMap<NameId, Entry>();
// Scopes extended by this scope.
//
// TODO: A `NameScopeId` is currently insufficient to describe an extended
// scope in general. For example:
//
// class A(T:! type) {
// extend base: B(T*);
// }
//
// needs to describe the `T*` argument.
//
// Small vector size is set to 1: we expect that there will rarely be more
// than a single extended scope. Currently the only kind of extended scope is
// a base class, and there can be only one of those per scope.
// TODO: Revisit this once we have more kinds of extended scope and data.
// TODO: Consider using something like `TinyPtrVector` for this.
llvm::SmallVector<NameScopeId, 1> extended_scopes;
// The instruction which owns the scope.
InstId inst_id;
// When the scope is a namespace, the name. Otherwise, invalid.
NameId name_id;
// The parent scope.
NameScopeId parent_scope_id;
// Whether we have diagnosed an error in a construct that would have added
// names to this scope. For example, this can happen if an `import` failed or
// an `extend` declaration was ill-formed. If true, the `names` map is assumed
// to be missing names as a result of the error, and no further errors are
// produced for lookup failures in this scope.
bool has_error = false;
// True if this is a closed namespace created by importing a package.
bool is_closed_import = false;
// Imported IR scopes that compose this namespace. This will be empty for
// scopes that correspond to the current package.
llvm::SmallVector<std::pair<SemIR::ImportIRId, SemIR::NameScopeId>, 0>
import_ir_scopes;
};
// Provides a ValueStore wrapper for an API specific to name scopes.
class NameScopeStore {
public:
explicit NameScopeStore(InstStore* insts) : insts_(insts) {}
// Adds a name scope, returning an ID to reference it.
auto Add(InstId inst_id, NameId name_id, NameScopeId parent_scope_id)
-> NameScopeId {
return values_.Add({.inst_id = inst_id,
.name_id = name_id,
.parent_scope_id = parent_scope_id});
}
// Adds a name that is required to exist in a name scope, such as `Self`.
// These must never conflict.
auto AddRequiredName(NameScopeId scope_id, NameId name_id, InstId inst_id)
-> void {
NameScope::Entry entry = {.inst_id = inst_id,
.access_kind = AccessKind::Public};
auto success = Get(scope_id).names.insert({name_id, entry}).second;
CARBON_CHECK(success) << "Failed to add required name: " << name_id;
}
// Returns the requested name scope.
auto Get(NameScopeId scope_id) -> NameScope& { return values_.Get(scope_id); }
// Returns the requested name scope.
auto Get(NameScopeId scope_id) const -> const NameScope& {
return values_.Get(scope_id);
}
// Returns the instruction owning the requested name scope, or Invalid with
// nullopt if the scope is either invalid or has no associated instruction.
auto GetInstIfValid(NameScopeId scope_id) const
-> std::pair<InstId, std::optional<Inst>> {
if (!scope_id.is_valid()) {
return {InstId::Invalid, std::nullopt};
}
auto inst_id = Get(scope_id).inst_id;
if (!inst_id.is_valid()) {
return {InstId::Invalid, std::nullopt};
}
return {inst_id, insts_->Get(inst_id)};
}
auto OutputYaml() const -> Yaml::OutputMapping {
return values_.OutputYaml();
}
private:
InstStore* insts_;
ValueStore<NameScopeId> values_;
};
} // namespace Carbon::SemIR
#endif // CARBON_TOOLCHAIN_SEM_IR_NAME_SCOPE_H_