mirror of
https://github.com/carbon-language/carbon-lang.git
synced 2026-11-16 17:18:10 +00:00
This addresses/avoids the duplicate import of vtables. I went through a few iterations/etc along the way and left them in the commit history for the PR in case any of them are useful to illustrate how I got here, or worth revisiting. Essentially I ended up with a circularity in importing - importing the class imported the vtable_decl which imported the virtual functions - and then pending specifics of the virtual functions needed the self specific of the enclosing class which wasn't ready yet. Adding ImportRef to the vtable_decl to break the cycle caused me trouble when naming the vtable_decl instructions - so I tried making the functions in the vtable unloaded ImportRefs instead. That worked, but meant that importing a class still was doing O(number of vtable entries) even if the vtable wasn't used. So I revisited the lazy vtable_decl - figured out how to make the naming work (when building the vtable_ptr, even though the vtable_decl doesn't have to be loaded for the vtable_ptr, I force it to be loaded anyway, to load the vtable so it's usable by lowering, etc). And then I could go back to the old non-lazy loaded vtable entries (using some loaded ImportRefs in the cases where we needed them/had already adopted them). Then thinking about the VtablePtr instruction, went back/forth on exactly what it needed - went from VtablePtr's member being a VtableDecl InstId, to a ClassId, then back to a VtableId as it was before this patch. Naming the instructions has one oddity, that the VtableDecl and VtablePtr instructions seem to need to add the pending name for the VtableId - despite not using the VtableId in their own name - should the inst namer be doing this work for parameters of instructions rather than requiring the inst to do it deliberately? (or am I holding it wrong in some way?) --------- Co-authored-by: Richard Smith <richard@metafoo.co.uk>
124 lines
4.2 KiB
C++
124 lines
4.2 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 "toolchain/base/value_store.h"
|
|
#include "toolchain/sem_ir/entity_with_params_base.h"
|
|
#include "toolchain/sem_ir/ids.h"
|
|
|
|
namespace Carbon::SemIR {
|
|
|
|
// 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;
|
|
|
|
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();
|
|
}
|
|
|
|
// 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;
|
|
};
|
|
|
|
using ClassStore = ValueStore<ClassId, Class>;
|
|
|
|
} // namespace Carbon::SemIR
|
|
|
|
#endif // CARBON_TOOLCHAIN_SEM_IR_CLASS_H_
|