mirror of
https://github.com/carbon-language/carbon-lang.git
synced 2026-11-16 05:38:10 +00:00
When identifying a facet type, defer evaluation of LookupImplWitnesses by redirecting them to evaluate into IdentifiedWitness. Then the caller of identify will need to substitute the IdentifiedWitnesses, either with witnesses of their own, or with LookupImplWitness to cause a lookup operation. This allows: - An `impl as` on a named constraint can subst the witnesses in designators from the named constraint with a witness to the impl itself. This prevents them from looking for and finding some other overlapping impl. (This PR) - Impl lookup to collect rewrite/equality requirements from all named constraints and then use the impls it has already found to evaluate any designators in those requirements instead of performing impl lookup again (creating a cycle). (Done in https://github.com/carbon-language/carbon-lang/pull/7944) - Similarly, an `impl as` can collect impls and equality requirements from all named constraints and verify them correctly by replacing witnesses that should refer to the impl with the correct witness instead of performing a lookup and finding an overlapping impl. (Done in https://github.com/carbon-language/carbon-lang/pull/7937) - ImplWitnessAccess to be able to find rewrites from a named constraint, not just from the initial DeclaredFacetType. (TBD) To do this we need to introduce the concept of "identified" specifics. In order to identify a facet type, we must construct a specific for each require decl in a named constraint. These specifics will have IdentifiedWitnesses inside them, but their args would otherwise match a specific for the require decl constructed in another context. To avoid polluting the canonical specific namespace, we introduce a second namespace of specifics that are "identified" since they are created by identifying. As we have introduced a new global state that modifies eval behaviour, we must disable that state when resolving a specific (as per https://github.com/carbon-language/carbon-lang/pull/7923). But inside an "identified" specific, we preserve the behaviour so that the witnesses modified by identify (through SubstPeriodSelf or through evaluating a require specific) have their evaluation deferred.
681 lines
26 KiB
C++
681 lines
26 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_CONTEXT_H_
|
|
#define CARBON_TOOLCHAIN_CHECK_CONTEXT_H_
|
|
|
|
#include <string>
|
|
|
|
#include "common/map.h"
|
|
#include "common/ostream.h"
|
|
#include "llvm/ADT/SmallVector.h"
|
|
#include "toolchain/base/canonical_value_store.h"
|
|
#include "toolchain/base/value_store.h"
|
|
#include "toolchain/check/core_identifier.h"
|
|
#include "toolchain/check/cpp/context.h"
|
|
#include "toolchain/check/decl_introducer_state.h"
|
|
#include "toolchain/check/decl_name_stack.h"
|
|
#include "toolchain/check/deferred_definition_worklist.h"
|
|
#include "toolchain/check/diagnostic_helpers.h"
|
|
#include "toolchain/check/full_pattern_stack.h"
|
|
#include "toolchain/check/generic_region_stack.h"
|
|
#include "toolchain/check/global_init.h"
|
|
#include "toolchain/check/inst_block_stack.h"
|
|
#include "toolchain/check/node_stack.h"
|
|
#include "toolchain/check/param_and_arg_refs_stack.h"
|
|
#include "toolchain/check/region_stack.h"
|
|
#include "toolchain/check/require_impls_stack.h"
|
|
#include "toolchain/check/scope_stack.h"
|
|
#include "toolchain/diagnostics/emitter.h"
|
|
#include "toolchain/parse/node_ids.h"
|
|
#include "toolchain/parse/tree.h"
|
|
#include "toolchain/parse/tree_and_subtrees.h"
|
|
#include "toolchain/sem_ir/declared_facet_type.h"
|
|
#include "toolchain/sem_ir/file.h"
|
|
#include "toolchain/sem_ir/identified_facet_type.h"
|
|
#include "toolchain/sem_ir/ids.h"
|
|
#include "toolchain/sem_ir/import_ir.h"
|
|
#include "toolchain/sem_ir/inst.h"
|
|
#include "toolchain/sem_ir/name_scope.h"
|
|
#include "toolchain/sem_ir/observe.h"
|
|
#include "toolchain/sem_ir/specific_interface.h"
|
|
#include "toolchain/sem_ir/typed_insts.h"
|
|
|
|
namespace Carbon::Check {
|
|
|
|
// Context stored during check.
|
|
//
|
|
// This file stores state, and members objects may provide an API. Other files
|
|
// may also have helpers that operate on Context. To keep this file manageable,
|
|
// please put logic into other files.
|
|
//
|
|
// For example, consider the API for functions:
|
|
// - `context.functions()`: Exposes storage of `SemIR::Function` objects.
|
|
// - `toolchain/check/function.h`: Contains helper functions which use
|
|
// `Check::Context`.
|
|
// - `toolchain/sem_ir/function.h`: Contains helper functions which only need
|
|
// `SemIR` objects, for which it's helpful not to depend on `Check::Context`
|
|
// (for example, shared with lowering).
|
|
class Context {
|
|
public:
|
|
// Stores references for work.
|
|
explicit Context(DiagnosticEmitterBase* emitter,
|
|
Parse::GetTreeAndSubtreesFn tree_and_subtrees_getter,
|
|
SemIR::File* sem_ir, int imported_ir_count,
|
|
int total_ir_count, llvm::raw_ostream* vlog_stream,
|
|
bool mangle_string_fingerprint = false);
|
|
|
|
// Marks an implementation TODO. Always returns false.
|
|
auto TODO(SemIR::LocId loc_id, std::string label) -> bool;
|
|
auto TODO(SemIR::InstId loc_inst_id, std::string label) -> bool;
|
|
|
|
// Runs verification that the processing cleanly finished.
|
|
auto VerifyOnFinish() const -> void;
|
|
|
|
// Prints information for a stack dump.
|
|
auto PrintForStackDump(llvm::raw_ostream& output) const -> void;
|
|
|
|
// Get the Lex::TokenKind of a node for diagnostics.
|
|
auto token_kind(Parse::NodeId node_id) -> Lex::TokenKind {
|
|
return tokens().GetKind(parse_tree().node_token(node_id));
|
|
}
|
|
|
|
auto emitter() -> DiagnosticEmitterBase& { return *emitter_; }
|
|
|
|
auto parse_tree_and_subtrees() -> const Parse::TreeAndSubtrees& {
|
|
return tree_and_subtrees_getter_();
|
|
}
|
|
|
|
auto sem_ir() -> SemIR::File& { return *sem_ir_; }
|
|
auto sem_ir() const -> const SemIR::File& { return *sem_ir_; }
|
|
|
|
auto cpp_context() -> CppContext* { return cpp_context_.get(); }
|
|
|
|
// TODO: Remove this and pass the C++ context to the constructor.
|
|
auto set_cpp_context(std::unique_ptr<CppContext> cpp_context) {
|
|
CARBON_CHECK(!cpp_context_ || !cpp_context, "Already have a C++ context");
|
|
cpp_context_ = std::move(cpp_context);
|
|
}
|
|
|
|
// Convenience functions for major phase data.
|
|
auto parse_tree() const -> const Parse::Tree& {
|
|
return sem_ir_->parse_tree();
|
|
}
|
|
auto tokens() const -> const Lex::TokenizedBuffer& {
|
|
return parse_tree().tokens();
|
|
}
|
|
|
|
auto vlog_stream() -> llvm::raw_ostream* { return vlog_stream_; }
|
|
|
|
auto node_stack() -> NodeStack& { return node_stack_; }
|
|
|
|
auto inst_block_stack() -> InstBlockStack& { return inst_block_stack_; }
|
|
auto pattern_block_stack() -> InstBlockStack& { return pattern_block_stack_; }
|
|
|
|
auto param_and_arg_refs_stack() -> ParamAndArgRefsStack& {
|
|
return param_and_arg_refs_stack_;
|
|
}
|
|
|
|
auto args_type_info_stack() -> InstBlockStack& {
|
|
return args_type_info_stack_;
|
|
}
|
|
|
|
auto struct_type_fields_stack() -> ArrayStack<SemIR::StructTypeField>& {
|
|
return struct_type_fields_stack_;
|
|
}
|
|
|
|
auto field_decls_stack() -> ArrayStack<SemIR::InstId>& {
|
|
return field_decls_stack_;
|
|
}
|
|
|
|
auto friend_scopes_stack() -> ArrayStack<SemIR::ConstantId>& {
|
|
return friend_scopes_stack_;
|
|
}
|
|
|
|
auto require_impls_stack() -> RequireImplsStack& {
|
|
return require_impls_stack_;
|
|
}
|
|
|
|
auto observe_stack() -> ArrayStack<SemIR::ObserveId>& {
|
|
return observe_stack_;
|
|
}
|
|
|
|
auto decl_name_stack() -> DeclNameStack& { return decl_name_stack_; }
|
|
|
|
auto decl_introducer_state_stack() -> DeclIntroducerStateStack& {
|
|
return decl_introducer_state_stack_;
|
|
}
|
|
|
|
auto scope_stack() -> ScopeStack& { return scope_stack_; }
|
|
|
|
// Convenience functions for frequently-used `scope_stack` members.
|
|
auto break_continue_stack()
|
|
-> llvm::SmallVector<ScopeStack::BreakContinueScope>& {
|
|
return scope_stack().break_continue_stack();
|
|
}
|
|
auto full_pattern_stack() -> FullPatternStack& {
|
|
return scope_stack_.full_pattern_stack();
|
|
}
|
|
|
|
auto deferred_definition_worklist() -> DeferredDefinitionWorklist& {
|
|
return deferred_definition_worklist_;
|
|
}
|
|
|
|
auto generic_region_stack() -> GenericRegionStack& {
|
|
return generic_region_stack_;
|
|
}
|
|
|
|
auto vtable_stack() -> InstBlockStack& { return vtable_stack_; }
|
|
|
|
auto exports() -> llvm::SmallVector<SemIR::InstId>& { return exports_; }
|
|
|
|
using CheckIRToImportIRStore =
|
|
FixedSizeValueStore<SemIR::CheckIRId, SemIR::ImportIRId>;
|
|
auto check_ir_map() -> CheckIRToImportIRStore& { return check_ir_map_; }
|
|
|
|
auto import_ir_constant_values()
|
|
-> llvm::SmallVector<SemIR::ConstantValueStore, 0>& {
|
|
return import_ir_constant_values_;
|
|
}
|
|
|
|
auto definitions_required_by_decl() -> llvm::SmallVector<SemIR::InstId>& {
|
|
return definitions_required_by_decl_;
|
|
}
|
|
|
|
auto definitions_required_by_use()
|
|
-> llvm::SmallVector<std::pair<SemIR::LocId, SemIR::SpecificId>>& {
|
|
return definitions_required_by_use_;
|
|
}
|
|
|
|
auto global_init() -> GlobalInit& { return global_init_; }
|
|
|
|
auto imports() -> llvm::SmallVector<SemIR::InstId>& { return imports_; }
|
|
|
|
auto generated() -> llvm::SmallVector<SemIR::InstId>& { return generated_; }
|
|
|
|
// Map from the IDs of binding patterns to the IDs of the corresponding
|
|
// bindings, and related information. The binding insts must be created early,
|
|
// well before we have a block to put them in, because they have to be added
|
|
// to name lookup in case they are referenced later in the pattern. See
|
|
// docs/check/pattern_matching.md for details.
|
|
//
|
|
// This is only populated for "ordinary" binding pattern insts, not insts
|
|
// produced by constant evaluation, because the latter do not have a unique
|
|
// identity, and cannot be referenced by name in any event.
|
|
//
|
|
// TODO: Consider putting this behind a narrower API to guard against emitting
|
|
// multiple times.
|
|
struct BindingPatternInfo {
|
|
// The corresponding AnyBinding inst.
|
|
SemIR::InstId bind_name_id;
|
|
// The region of insts that computes the type of the binding.
|
|
SemIR::ExprRegionId type_expr_region_id;
|
|
};
|
|
auto bind_name_map() -> Map<SemIR::InstId, BindingPatternInfo>& {
|
|
return bind_name_map_;
|
|
}
|
|
|
|
// During Choice typechecking, each alternative turns into a name binding on
|
|
// the Choice type, but this can't be done until the full Choice type is
|
|
// known. This represents each binding to be done at the end of checking the
|
|
// Choice type.
|
|
struct ChoiceDeferredBinding {
|
|
Parse::NodeIdOneOf<Parse::ChoiceAlternativeListCommaId,
|
|
Parse::ChoiceDefinitionId>
|
|
node_id;
|
|
NameComponent name_component;
|
|
};
|
|
auto choice_deferred_bindings() -> llvm::SmallVector<ChoiceDeferredBinding>& {
|
|
return choice_deferred_bindings_;
|
|
}
|
|
|
|
auto region_stack() -> RegionStack& { return region_stack_; }
|
|
|
|
// The `MatchFirstDecl` and state of the `match_first` block that we are
|
|
// currently checking.
|
|
struct MatchFirstContext {
|
|
SemIR::InstId decl_id;
|
|
bool is_final;
|
|
int block_size = 0;
|
|
};
|
|
auto match_first_context() -> std::optional<MatchFirstContext>& {
|
|
return match_first_context_;
|
|
}
|
|
|
|
// An ongoing impl lookup, used to ensure termination.
|
|
struct ImplLookupStackEntry {
|
|
SemIR::ConstantId query_self_const_id;
|
|
SemIR::ConstantId query_facet_type_const_id;
|
|
// The location of the impl being looked at for the stack entry.
|
|
SemIR::InstId impl_loc = SemIR::InstId::None;
|
|
// TODO: If we make a proper stack class, we only need one `diagnosed_cycle`
|
|
// field, which resets to false when the stack becomes empty.
|
|
bool diagnosed_cycle = false;
|
|
};
|
|
auto impl_lookup_stack() -> llvm::SmallVector<ImplLookupStackEntry>& {
|
|
return impl_lookup_stack_;
|
|
}
|
|
|
|
// A map from a (self, interface) pair to a final witness.
|
|
using ImplLookupCacheKey =
|
|
std::pair<SemIR::ConstantId, SemIR::SpecificInterfaceId>;
|
|
using ImplLookupCacheMap = Map<ImplLookupCacheKey, SemIR::ConstantId>;
|
|
auto impl_lookup_cache() -> ImplLookupCacheMap& { return impl_lookup_cache_; }
|
|
|
|
auto impl_lookup_no_symbolic_final_lookups() -> int32_t& {
|
|
return impl_lookup_no_symbolic_final_lookups_;
|
|
}
|
|
|
|
// An impl lookup query that resulted in a concrete witness from finding an
|
|
// `impl` declaration (not though a facet value), and its result. Used to look
|
|
// for conflicting `impl` declarations.
|
|
struct PoisonedConcreteImplLookupQuery {
|
|
// The location the LookupImplWitness originated from.
|
|
SemIR::LocId loc_id;
|
|
// The query for a witness of an impl for an interface.
|
|
SemIR::LookupImplWitness query;
|
|
// The resulting final witness.
|
|
SemIR::ConstantId witness_id;
|
|
};
|
|
auto poisoned_concrete_impl_lookup_queries()
|
|
-> llvm::SmallVector<PoisonedConcreteImplLookupQuery>& {
|
|
return poisoned_concrete_impl_lookup_queries_;
|
|
}
|
|
|
|
// A stack that tracks constraints from a `where` expression being checked.
|
|
// The back of the stack is the currently checked `where` expression.
|
|
struct WhereStackEntry {
|
|
// A map from an ImplWitnessAccess on the LHS of a rewrite constraint to its
|
|
// value on the RHS. Used during checking of a `where` expression to allow
|
|
// constraints to access values from earlier constraints.
|
|
Map<SemIR::ConstantId, SemIR::InstId> rewrites;
|
|
|
|
// A collection of `A impls B` facts known about the current `where`
|
|
// expression being checked. Used to allow constraints to know about `impls`
|
|
// relationships from earlier constraints.
|
|
struct SelfImplsFacetType {
|
|
SemIR::ConstantId self_const_id;
|
|
SemIR::ConstantId facet_type_const_id;
|
|
};
|
|
llvm::SmallVector<SelfImplsFacetType> impls;
|
|
|
|
SemIR::LocId loc_id;
|
|
};
|
|
|
|
auto where_stack() -> llvm::SmallVector<WhereStackEntry>& {
|
|
return where_stack_;
|
|
}
|
|
|
|
auto binding_type_where_count() -> int32_t& {
|
|
return binding_type_where_count_;
|
|
}
|
|
|
|
struct DeclaringImplDecl {
|
|
SemIR::ConstantId self_id;
|
|
SemIR::SpecificInterface specific_interface;
|
|
auto operator==(const DeclaringImplDecl& rhs) const -> bool = default;
|
|
};
|
|
auto declaring_impl_decls() -> llvm::SmallVector<DeclaringImplDecl>& {
|
|
return declaring_impl_decls_;
|
|
}
|
|
|
|
auto eval_impl_lookup_to_identified_witness() -> int32_t& {
|
|
return eval_impl_lookup_to_identified_witness_;
|
|
}
|
|
|
|
// Data about a form expression.
|
|
//
|
|
// TODO: consider moving this out of Context.
|
|
struct FormExpr {
|
|
static const FormExpr Error;
|
|
static const FormExpr None;
|
|
|
|
// The inst ID of the form expression itself. This is always an inst in the
|
|
// AnyPrimitiveForm category.
|
|
SemIR::InstId form_inst_id;
|
|
// The inst ID of the form expression's type component.
|
|
SemIR::TypeInstId type_component_inst_id;
|
|
// The type ID corresponding to type_component_id.
|
|
SemIR::TypeId type_component_id;
|
|
};
|
|
|
|
// Pushes form_expr onto the stack of return form declarations for in-progress
|
|
// function declarations.
|
|
//
|
|
// Note: the "stack" currently can only have one element, but that restriction
|
|
// can be relaxed if it becomes possible to have multiple pending return type
|
|
// declarations.
|
|
auto PushReturnForm(FormExpr form_expr) -> void {
|
|
CARBON_CHECK(return_form_expr_ == std::nullopt,
|
|
"TODO: make form_expr_ a stack if necessary");
|
|
return_form_expr_ = form_expr;
|
|
}
|
|
|
|
// Pops a FormExpr off the stack of return form declarations for in-progress
|
|
// function declarations.
|
|
auto PopReturnForm() -> FormExpr {
|
|
CARBON_CHECK(return_form_expr_ != std::nullopt);
|
|
return *std::exchange(return_form_expr_, std::nullopt);
|
|
}
|
|
|
|
auto core_identifiers() -> CoreIdentifierCache& { return core_identifiers_; }
|
|
|
|
auto access_context() -> SemIR::NameScopeId& { return access_context_; }
|
|
|
|
// --------------------------------------------------------------------------
|
|
// Directly expose SemIR::File data accessors for brevity in calls.
|
|
// --------------------------------------------------------------------------
|
|
|
|
auto identifiers() -> SharedValueStores::IdentifierStore& {
|
|
return sem_ir().identifiers();
|
|
}
|
|
auto ints() -> SharedValueStores::IntStore& { return sem_ir().ints(); }
|
|
auto reals() -> SharedValueStores::RealStore& { return sem_ir().reals(); }
|
|
auto floats() -> SharedValueStores::FloatStore& { return sem_ir().floats(); }
|
|
auto string_literal_values() -> SharedValueStores::StringLiteralStore& {
|
|
return sem_ir().string_literal_values();
|
|
}
|
|
auto entity_names() -> SemIR::EntityNameStore& {
|
|
return sem_ir().entity_names();
|
|
}
|
|
auto cpp_overload_sets() -> SemIR::CppOverloadSetStore& {
|
|
return sem_ir().cpp_overload_sets();
|
|
}
|
|
auto functions() -> SemIR::FunctionStore& { return sem_ir().functions(); }
|
|
auto generated_functions() -> SemIR::GeneratedFunctionStore& {
|
|
return sem_ir().generated_functions();
|
|
}
|
|
auto thunks() -> SemIR::ThunkStore& { return sem_ir().thunks(); }
|
|
auto classes() -> SemIR::ClassStore& { return sem_ir().classes(); }
|
|
auto fields() -> SemIR::FieldStore& { return sem_ir().fields(); }
|
|
auto vtables() -> SemIR::VtableStore& { return sem_ir().vtables(); }
|
|
auto interfaces() -> SemIR::InterfaceStore& { return sem_ir().interfaces(); }
|
|
auto named_constraints() -> SemIR::NamedConstraintStore& {
|
|
return sem_ir().named_constraints();
|
|
}
|
|
auto require_impls() -> SemIR::RequireImplsStore& {
|
|
return sem_ir().require_impls();
|
|
}
|
|
auto require_impls_blocks() -> SemIR::RequireImplsBlockStore& {
|
|
return sem_ir().require_impls_blocks();
|
|
}
|
|
auto observes() -> SemIR::ObserveStore& { return sem_ir().observes(); }
|
|
auto observe_blocks() -> SemIR::ObserveBlockStore& {
|
|
return sem_ir().observe_blocks();
|
|
}
|
|
auto associated_constants() -> SemIR::AssociatedConstantStore& {
|
|
return sem_ir().associated_constants();
|
|
}
|
|
auto declared_facet_types() -> SemIR::DeclaredFacetTypeStore& {
|
|
return sem_ir().declared_facet_types();
|
|
}
|
|
auto identified_facet_types() -> SemIR::IdentifiedFacetTypeStore& {
|
|
return sem_ir().identified_facet_types();
|
|
}
|
|
auto impls() -> SemIR::ImplStore& { return sem_ir().impls(); }
|
|
auto specific_interfaces() -> SemIR::SpecificInterfaceStore& {
|
|
return sem_ir().specific_interfaces();
|
|
}
|
|
auto generics() -> SemIR::GenericStore& { return sem_ir().generics(); }
|
|
auto specifics() -> SemIR::SpecificStore& { return sem_ir().specifics(); }
|
|
auto import_irs() -> SemIR::ImportIRStore& { return sem_ir().import_irs(); }
|
|
auto import_ir_insts() -> SemIR::ImportIRInstStore& {
|
|
return sem_ir().import_ir_insts();
|
|
}
|
|
auto ast_context() -> clang::ASTContext& {
|
|
return cpp_context()->ast_context();
|
|
}
|
|
auto clang_sema() -> clang::Sema& { return cpp_context()->sema(); }
|
|
auto clang_decls() -> SemIR::ClangDeclStore& {
|
|
return sem_ir().clang_decls();
|
|
}
|
|
auto clang_decl_signatures() -> SemIR::ClangDeclSignatureStore& {
|
|
return sem_ir().clang_decl_signatures();
|
|
}
|
|
auto names() -> SemIR::NameStoreWrapper { return sem_ir().names(); }
|
|
auto name_scopes() -> SemIR::NameScopeStore& {
|
|
return sem_ir().name_scopes();
|
|
}
|
|
auto struct_type_fields() -> SemIR::StructTypeFieldsStore& {
|
|
return sem_ir().struct_type_fields();
|
|
}
|
|
auto custom_layouts() -> SemIR::CustomLayoutStore& {
|
|
return sem_ir().custom_layouts();
|
|
}
|
|
auto types() -> SemIR::TypeStore& { return sem_ir().types(); }
|
|
// Instructions should be added with `AddInst` or `AddInstInNoBlock` from
|
|
// `inst.h`. This is `const` to prevent accidental misuse.
|
|
auto insts() const -> const SemIR::InstStore& { return sem_ir().insts(); }
|
|
auto constant_values() -> SemIR::ConstantValueStore& {
|
|
return sem_ir().constant_values();
|
|
}
|
|
auto inst_blocks() -> SemIR::InstBlockStore& {
|
|
return sem_ir().inst_blocks();
|
|
}
|
|
auto constants() -> SemIR::ConstantStore& { return sem_ir().constants(); }
|
|
auto bundles() -> SemIR::BundleStore& { return sem_ir().bundles(); }
|
|
auto total_ir_count() const -> int { return total_ir_count_; }
|
|
auto mangle_string_fingerprint() const -> bool {
|
|
return mangle_string_fingerprint_;
|
|
}
|
|
|
|
auto clang_function_pointer_types() -> SemIR::ClangFunctionPointerTypeStore& {
|
|
return sem_ir().clang_function_pointer_types();
|
|
}
|
|
auto clang_function_pointer_types() const
|
|
-> const SemIR::ClangFunctionPointerTypeStore& {
|
|
return sem_ir().clang_function_pointer_types();
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// End of SemIR::File members.
|
|
// --------------------------------------------------------------------------
|
|
|
|
private:
|
|
// Handles diagnostics.
|
|
DiagnosticEmitterBase* emitter_;
|
|
|
|
// Returns a lazily constructed TreeAndSubtrees.
|
|
Parse::GetTreeAndSubtreesFn tree_and_subtrees_getter_;
|
|
|
|
// The SemIR::File being added to.
|
|
SemIR::File* sem_ir_;
|
|
// The total number of files.
|
|
int total_ir_count_;
|
|
|
|
// The C++ checking context.
|
|
std::unique_ptr<CppContext> cpp_context_;
|
|
|
|
// Whether to print verbose output.
|
|
llvm::raw_ostream* vlog_stream_;
|
|
|
|
// The stack during Build. Will contain file-level parse nodes on return.
|
|
NodeStack node_stack_;
|
|
|
|
// The stack of instruction blocks being used for general IR generation.
|
|
InstBlockStack inst_block_stack_;
|
|
|
|
// The stack of instruction blocks that contain pattern instructions.
|
|
InstBlockStack pattern_block_stack_;
|
|
|
|
// The stack of instruction blocks being used for param and arg ref blocks.
|
|
ParamAndArgRefsStack param_and_arg_refs_stack_;
|
|
|
|
// The stack of instruction blocks being used for type information while
|
|
// processing arguments. This is used in parallel with
|
|
// param_and_arg_refs_stack_. It's used for:
|
|
// - Struct literals, where we need to track names for a type separate from
|
|
// the literal arguments.
|
|
// - The associated entries witness table, while parsing an interface.
|
|
InstBlockStack args_type_info_stack_;
|
|
|
|
// The stack of StructTypeFields for in-progress StructTypeLiterals.
|
|
ArrayStack<SemIR::StructTypeField> struct_type_fields_stack_;
|
|
|
|
// The stack of FieldDecls for in-progress Class definitions.
|
|
ArrayStack<SemIR::InstId> field_decls_stack_;
|
|
|
|
// The stack of `friend` decls for in-progress Class definitions, identified
|
|
// by the constant value of an expression that names them.
|
|
ArrayStack<SemIR::ConstantId> friend_scopes_stack_;
|
|
|
|
// The stack of RequireImpls for in-progress Interface and Constraint
|
|
// definitions.
|
|
RequireImplsStack require_impls_stack_;
|
|
|
|
// The stack of Observe for in-progress Interface and Function
|
|
// definitions.
|
|
ArrayStack<SemIR::ObserveId> observe_stack_;
|
|
|
|
// The stack used for qualified declaration name construction.
|
|
DeclNameStack decl_name_stack_;
|
|
|
|
// The stack of declarations that could have modifiers.
|
|
DeclIntroducerStateStack decl_introducer_state_stack_;
|
|
|
|
// The stack of scopes we are currently within.
|
|
ScopeStack scope_stack_;
|
|
|
|
// The worklist of deferred definition tasks to perform at the end of the
|
|
// enclosing deferred definition scope.
|
|
DeferredDefinitionWorklist deferred_definition_worklist_;
|
|
|
|
// The stack of generic regions we are currently within.
|
|
GenericRegionStack generic_region_stack_;
|
|
|
|
// Contains a vtable block for each `class` scope which is currently being
|
|
// defined, regardless of whether the class can have virtual functions.
|
|
InstBlockStack vtable_stack_;
|
|
|
|
// Instructions which are operands to an `export` directive. This becomes
|
|
// `InstBlockId::Exports`.
|
|
llvm::SmallVector<SemIR::InstId> exports_;
|
|
|
|
// Maps CheckIRId to ImportIRId.
|
|
CheckIRToImportIRStore check_ir_map_;
|
|
|
|
// Per-import constant values. These refer to the main IR and mainly serve as
|
|
// a lookup table for quick access.
|
|
//
|
|
// Inline 0 elements because it's expected to require heap allocation.
|
|
llvm::SmallVector<SemIR::ConstantValueStore, 0> import_ir_constant_values_;
|
|
|
|
// Declaration instructions of entities that should have definitions by the
|
|
// end of the current source file.
|
|
llvm::SmallVector<SemIR::InstId> definitions_required_by_decl_;
|
|
|
|
// Entities that should have definitions by the end of the current source
|
|
// file, because of a generic was used a concrete specific. This is currently
|
|
// only tracking specific functions that should have a definition emitted.
|
|
llvm::SmallVector<std::pair<SemIR::LocId, SemIR::SpecificId>>
|
|
definitions_required_by_use_;
|
|
|
|
// State for global initialization.
|
|
GlobalInit global_init_;
|
|
|
|
// Instructions which are generated as a result of imports; both `ImportRef`s
|
|
// and instructions they generate. For example, when a name reference resolves
|
|
// an imported function, the `ImportRefLoaded` results in a `FunctionDecl`,
|
|
// and both end up here. The `FunctionDecl` shouldn't use the current block on
|
|
// inst_block_stack_ because it's not tied to the referencing scope.
|
|
//
|
|
// This becomes `InstBlockId::Imports`.
|
|
llvm::SmallVector<SemIR::InstId> imports_;
|
|
|
|
// Entities which are generated internally to the toolchain, to represent
|
|
// builtin concepts which should be dumped as part of `SemIR`. For example,
|
|
// when doing destruction, the `Destroy.Op` function is generated, and will be
|
|
// found here.
|
|
//
|
|
// This becomes `InstBlockId::Generated`.
|
|
llvm::SmallVector<SemIR::InstId> generated_;
|
|
|
|
// Map from an AnyBindingPattern inst to precomputed parts of the
|
|
// pattern-match SemIR for it.
|
|
Map<SemIR::InstId, BindingPatternInfo> bind_name_map_;
|
|
|
|
// Each alternative in a Choice gets an entry here, they are stored in
|
|
// declaration order. The vector is consumed and emptied at the end of the
|
|
// Choice definition.
|
|
//
|
|
// TODO: This may need to be a stack of vectors if it becomes possible to
|
|
// define a Choice type inside an alternative's parameter set.
|
|
llvm::SmallVector<ChoiceDeferredBinding> choice_deferred_bindings_;
|
|
|
|
// Stack of single-entry regions being built.
|
|
RegionStack region_stack_;
|
|
|
|
// The statte of the `match_first` block that we are currently checking.
|
|
std::optional<MatchFirstContext> match_first_context_;
|
|
|
|
// Tracks all ongoing impl lookups in order to ensure that lookup terminates
|
|
// via the acyclic rule and the termination rule.
|
|
llvm::SmallVector<ImplLookupStackEntry> impl_lookup_stack_;
|
|
|
|
// Tracks a mapping from (self, interface) to witness, for queries that had
|
|
// final results.
|
|
ImplLookupCacheMap impl_lookup_cache_;
|
|
|
|
// While non-zero, symbolic lookups for final impls are prevented in order to
|
|
// prevent cycles. This is incremented while replacing `.Self` in a facet type
|
|
// from an impl lookup query that we are searching for a witness for the
|
|
// query.
|
|
int32_t impl_lookup_no_symbolic_final_lookups_ = 0;
|
|
|
|
// Tracks impl lookup queries that lead to concrete witness results, along
|
|
// with those results. Used to verify that the same queries produce the same
|
|
// results at the end of the file. Any difference is diagnosed.
|
|
llvm::SmallVector<PoisonedConcreteImplLookupQuery>
|
|
poisoned_concrete_impl_lookup_queries_;
|
|
|
|
// Tracks information about constraints in the current `where` expression
|
|
// being checked so that they can be used by later constraints.
|
|
llvm::SmallVector<WhereStackEntry> where_stack_;
|
|
|
|
// Counts the number of `where` expressions in the type of the binding
|
|
// currently being checked.
|
|
int32_t binding_type_where_count_ = 0;
|
|
|
|
// Track impl declarations that are underway. If we're declaring an impl for
|
|
// `C as I`, an impl lookup query for `C as I` or `.Self as I` should find
|
|
// that impl being declared (even though it does not yet exist).
|
|
llvm::SmallVector<DeclaringImplDecl> declaring_impl_decls_;
|
|
|
|
// Tracks if we are currently identifying a facet type, which causes
|
|
// LookupImplWitness instructions to not resolve to final witnesses by
|
|
// redirecting them to form IdentifiedWitness instructions. The caller to
|
|
// identify must replace any IdentifiedWitness instructions in the
|
|
// IdentifiedFacetType before using the values there.
|
|
int32_t eval_impl_lookup_to_identified_witness_ = 0;
|
|
|
|
// Declared return form for the in-progress function declaration, if any.
|
|
std::optional<FormExpr> return_form_expr_;
|
|
|
|
// See `CoreIdentifierCache` for details.
|
|
CoreIdentifierCache core_identifiers_;
|
|
|
|
bool mangle_string_fingerprint_;
|
|
|
|
// Scope for querying member access. For example, when checking a class
|
|
// method, this would be set to the scope of that method's class.
|
|
//
|
|
// This is updated by `DeclNameStack`. During monomorphization, it is updated
|
|
// by `TryEvalBlockForSpecific`.
|
|
SemIR::NameScopeId access_context_ = SemIR::NameScopeId::None;
|
|
};
|
|
|
|
inline constexpr Context::FormExpr Context::FormExpr::Error = {
|
|
.form_inst_id = SemIR::ErrorInst::InstId,
|
|
.type_component_inst_id = SemIR::ErrorInst::TypeInstId,
|
|
.type_component_id = SemIR::ErrorInst::TypeId};
|
|
|
|
inline constexpr Context::FormExpr Context::FormExpr::None = {
|
|
.form_inst_id = SemIR::InstId::None,
|
|
.type_component_inst_id = SemIR::TypeInstId::None,
|
|
.type_component_id = SemIR::TypeId::None};
|
|
|
|
} // namespace Carbon::Check
|
|
|
|
#endif // CARBON_TOOLCHAIN_CHECK_CONTEXT_H_
|