mirror of
https://github.com/carbon-language/carbon-lang.git
synced 2026-09-24 20:40:11 +01:00
Dana Jansens
917a6ea971
Currently each interface has a `Self` facet internally that becomes a binding to every entity inside the interface: associated constants, functions, and require decls. Each of these has to be independently generic as a result. This makes is challenging in extended name lookup to move into an extended scope of an interface, as we have a specific for the interface, but the names within require a different specific that includes a `Self` facet value. We generalize this relationship by adding a second generic to Interface, called `generic_with_self`. When we want to work with entities inside the interface, we move from the interface-without-specific to the interface-with-self specific by adding a Self to the specific. This is done independently of any particular entity inside the Interface, as those entities are now all members of the interface-with-self generic. Associated constants no longer need a generic of their own, as they do not have separate generic bindings. Functions retain a generic, but if the function has no generic arguments, it will have no bindings of its own now. Require decls retain a generic so that their specific can be instantiated separately from the interface. Requiring the interface to be complete does not require the types in a require decl to be complete unless it is modified by `extend`. So we allow them to be completed later by keeping them in a separate generic. Named constraints look like interfaces and gain the additional inner generic-with-self, with the same relationship to require decls. This removes the need for name lookup to perform Substitution of a Self facet into the extended scope instruction. Instead, the `SpecificConstant` instruction inserted by a `require` decl is part of the interface-with-self generic. When looking through a FacetType for extended scopes, for each interface, we push the scope with the specific for the interface-with-self. Then the constant value of the `SpecificConstant` is correctly modified by the provided self automatically through applying that specific.
65 lines
2.8 KiB
C++
65 lines
2.8 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_CHECK_EVAL_H_
|
|
#define CARBON_TOOLCHAIN_CHECK_EVAL_H_
|
|
|
|
#include "toolchain/check/context.h"
|
|
#include "toolchain/sem_ir/ids.h"
|
|
#include "toolchain/sem_ir/inst.h"
|
|
#include "toolchain/sem_ir/inst_kind.h"
|
|
|
|
namespace Carbon::Check {
|
|
|
|
// Adds a `ConstantId` for a constant that has been imported from another IR.
|
|
// Does not evaluate the instruction, instead trusting that it is already in a
|
|
// suitable form, but does canonicalize the operands if necessary.
|
|
// TODO: Rely on import to canonicalize the operands to avoid this work.
|
|
auto AddImportedConstant(Context& context, SemIR::Inst inst)
|
|
-> SemIR::ConstantId;
|
|
|
|
// Evaluates the instruction `inst`. If `inst_id` is specified, it is the ID of
|
|
// the instruction; otherwise, evaluation of the instruction must not require an
|
|
// `InstId` to be provided.
|
|
auto TryEvalInstUnsafe(Context& context, SemIR::InstId inst_id,
|
|
SemIR::Inst inst) -> SemIR::ConstantId;
|
|
|
|
// Determines the phase of the instruction `inst_id`, and returns its constant
|
|
// value if it has constant phase. If it has runtime phase, returns
|
|
// `SemIR::ConstantId::NotConstant`.
|
|
inline auto TryEvalInst(Context& context, SemIR::InstId inst_id)
|
|
-> SemIR::ConstantId {
|
|
return TryEvalInstUnsafe(context, inst_id, context.insts().Get(inst_id));
|
|
}
|
|
|
|
// Same, but for a typed instruction that doesn't have an InstId assigned yet,
|
|
// in the case where evaluation doesn't need an InstId. This can be used to
|
|
// avoid allocating an instruction in the case where you just want a constant
|
|
// value and the instruction is known to not matter. However, even then care
|
|
// should be taken: if the produced constant is symbolic, you may still need an
|
|
// instruction to associate the constant with the enclosing generic.
|
|
//
|
|
// To evaluate an instruction and add it to SemIR only if necessary, use
|
|
// EvalOrAddInst instead.
|
|
template <typename InstT>
|
|
requires(InstT::Kind.constant_needs_inst_id() ==
|
|
SemIR::InstConstantNeedsInstIdKind::No)
|
|
auto TryEvalInst(Context& context, InstT inst) -> SemIR::ConstantId {
|
|
return TryEvalInstUnsafe(context, SemIR::InstId::None, inst);
|
|
}
|
|
|
|
// Evaluates the eval block for a region of a specific. Produces a block
|
|
// containing the evaluated constant values of the instructions in the eval
|
|
// block.
|
|
//
|
|
// TODO: Return whether any of the instructions produced contain an ErrorInst.
|
|
auto TryEvalBlockForSpecific(Context& context, SemIR::LocId loc_id,
|
|
SemIR::SpecificId specific_id,
|
|
SemIR::GenericInstIndex::Region region)
|
|
-> SemIR::InstBlockId;
|
|
|
|
} // namespace Carbon::Check
|
|
|
|
#endif // CARBON_TOOLCHAIN_CHECK_EVAL_H_
|