Files
carbon-lang/toolchain/sem_ir/class.h
David BlaikieandChristopher Di Bella d99b767dde Export fields of imported Carbon classes to C++ (#8021)
When a Carbon class from another library was used from C++, its fields
were never exported, so C++ member access failed with 'no member named'.
The class scope of an imported class holds import references rather than
`FieldDecl`s, so `LookupClassFieldByStructField` didn't find them.
Resolve scope entries to their constant `FieldDecl`, load the import
references before exporting fields, and consistently key exported fields
by the `FieldDecl`.

Unfortunately `SemIR::LookupClassFieldByStructField` can't call
`LoadImportRef` because `SemIR::LookupClassFieldByStructField` is in
`SemIR` and `LoadImportRef` needs a `Check::Context` (and `check`
depends on `sem_ir`, not the other way around, so `sem_ir` can't use
check). So instead, make a `Check::LookupClassFieldByStructField` that
wraps the `SemIR` version, and does the `LoadImportRef`

Assisted-By: Claude

---------

Co-authored-by: Christopher Di Bella <cjdb.ns@gmail.com>
2026-11-02 20:37:01 +00:00

181 lines
6.6 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_CLASS_H_
#define CARBON_TOOLCHAIN_SEM_IR_CLASS_H_
#include <optional>
#include "common/map.h"
#include "toolchain/base/value_store.h"
#include "toolchain/sem_ir/entity_with_params_base.h"
#include "toolchain/sem_ir/ids.h"
#include "toolchain/sem_ir/inst.h"
#include "toolchain/sem_ir/struct_type_field.h"
namespace clang {
class TagDecl;
}
namespace Carbon::SemIR {
class File;
class NameScope;
// Class-specific fields.
struct ClassFields {
enum InheritanceKind : int8_t {
// `abstract class`
Abstract,
// `base class`
Base,
// `class`
Final,
};
// The following members always have values, and do not change throughout the
// lifetime of the class.
// The class type, which is the type of `Self` in the class definition.
TypeId self_type_id;
// The kind of inheritance that this class supports.
// TODO: The rules here are not yet decided. See #3384.
InheritanceKind inheritance_kind;
// Whether this class or any base class has at least one virtual function.
bool is_dynamic = false;
// The following members are set at the `{` of the class definition.
// The class scope.
NameScopeId scope_id = NameScopeId::None;
// The first block of the class body.
// TODO: Handle control flow in the class body, such as if-expressions.
InstBlockId body_block_id = InstBlockId::None;
// The following members are accumulated throughout the class definition.
// The adapted type declaration, if any. `None` if the class is not an
// adapter. This is an AdaptDecl instruction.
// TODO: Consider sharing the storage for `adapt_id` and `base_id`. A class
// can't have both.
InstId adapt_id = InstId::None;
// The base class declaration. `None` if the class has no base class. This is
// a BaseDecl instruction.
InstId base_id = InstId::None;
// The following members are set at the `}` of the class definition.
// A `CompleteTypeWitness` instruction witnessing that this class type is
// complete, and tracking its object representation. This has a value once the
// class is defined. For an adapter, the object representation is the
// non-adapter type that this class directly or transitively adapts.
InstId complete_type_witness_id = InstId::None;
// The virtual function table. `None` if the class has no (direct or
// inherited) virtual functions.
InstId vtable_decl_id = InstId::None;
// The scopes that are declared as friends of this class. Each scope is
// identified by the constant value of the expression that names it.
Set<SemIR::ConstantId> friend_scopes;
auto PrintClassFields(llvm::raw_ostream& out) const -> void {
out << "self_type_id: " << self_type_id << ", inheritance_kind: ";
switch (inheritance_kind) {
case Abstract:
out << "Abstract";
break;
case Base:
out << "Base";
break;
case Final:
out << "Final";
break;
}
out << ", is_dynamic: " << is_dynamic << ", scope_id: " << scope_id
<< ", body_block_id: " << body_block_id << ", adapt_id: " << adapt_id
<< ", base_id: " << base_id
<< ", complete_type_witness_id: " << complete_type_witness_id
<< ", vtable_decl_id: " << vtable_decl_id;
}
};
// A class. See EntityWithParamsBase regarding the inheritance here.
struct Class : public EntityWithParamsBase,
public ClassFields,
public Printable<Class> {
auto Print(llvm::raw_ostream& out) const -> void {
out << "{";
PrintBaseFields(out);
out << ", ";
PrintClassFields(out);
out << "}";
}
// This is false until we reach the `}` of the class definition.
auto is_complete() const -> bool {
return complete_type_witness_id.has_value();
}
// When merging a declaration and definition, prefer things which would point
// at the definition for diagnostics.
auto MergeDefinition(const Class& definition) -> void {
EntityWithParamsBase::MergeBaseDefinition(definition);
scope_id = definition.scope_id;
body_block_id = definition.body_block_id;
adapt_id = definition.adapt_id;
base_id = definition.base_id;
complete_type_witness_id = definition.complete_type_witness_id;
}
// Gets the type that this class type adapts. Returns `None` if there is no
// such type, or if the class is not yet defined.
auto GetAdaptedType(const File& file, SpecificId specific_id) const -> TypeId;
// Gets the base class for this class type. Returns `None` if there is no
// such type, or if the class is not yet defined.
auto GetBaseType(const File& file, SpecificId specific_id) const -> TypeId;
// Gets the object representation for this class. Returns `None` if the class
// is not yet defined.
auto GetObjectRepr(const File& file, SpecificId specific_id) const -> TypeId;
// Get the `StructTypeField`s from a class's object repr.
auto GetStructTypeFields(const File& sem_ir, SpecificId specific_id) const
-> llvm::ArrayRef<SemIR::StructTypeField>;
};
using ClassStore = ValueStore<ClassId, Class, Tag<CheckIRId>>;
// If this declaration declares a class type that is "owned" by Carbon, and not
// imported from C++, returns the corresponding type ID and `ClassType`.
// Otherwise returns `nullopt`.
auto GetAsCarbonOwnedClass(const File& sem_ir, const clang::TagDecl* tag_decl)
-> std::optional<std::pair<SemIR::TypeId, SemIR::ClassType>>;
// Given the target instruction of an entry in a class's scope, returns the
// corresponding `FieldDecl`, or `nullopt` if the entry is not a field. If the
// class was imported, the entry must already have been loaded.
auto GetClassFieldFromScopeEntry(const File& sem_ir, InstId entry_inst_id)
-> std::optional<InstStore::GetAsWithIdResult<SemIR::FieldDecl>>;
// Returns the `FieldDecl` in the class scope corresponding to the given field
// of the class's object representation, or `nullopt` if there is none, such as
// for a base class. If the class was imported, the field must already have
// been loaded.
auto LookupClassFieldByStructField(const File& sem_ir,
const NameScope& class_scope,
const StructTypeField& struct_field)
-> std::optional<InstStore::GetAsWithIdResult<SemIR::FieldDecl>>;
} // namespace Carbon::SemIR
namespace Carbon {
extern template class ValueStore<SemIR::ClassId, SemIR::Class,
Tag<SemIR::CheckIRId>>;
} // namespace Carbon
#endif // CARBON_TOOLCHAIN_SEM_IR_CLASS_H_