diff --git a/toolchain/check/import_ref.cpp b/toolchain/check/import_ref.cpp index 162797dbf95d..d881f4a00d2f 100644 --- a/toolchain/check/import_ref.cpp +++ b/toolchain/check/import_ref.cpp @@ -75,9 +75,8 @@ auto AddImportRef(Context& context, SemIR::ImportIRInst import_ir_inst, // from an imported IR, with a known constant value. This is useful when the // instruction has a symbolic constant value, in order to produce an instruction // that hold that symbolic constant. -static auto AddLoadedImportRef(Context& context, +static auto AddLoadedImportRef(Context& context, SemIR::TypeId type_id, SemIR::ImportIRInst import_ir_inst, - SemIR::TypeId type_id, SemIR::ConstantId const_id) -> SemIR::InstId { auto import_ir_inst_id = context.import_ir_insts().Add(import_ir_inst); SemIR::ImportRefLoaded inst = { @@ -172,6 +171,182 @@ static auto GetInstWithConstantValue(const SemIR::File& file, return file.inst_blocks().Get(block)[symbolic_const.index.index()]; } +namespace { +class ImportRefResolver; + +// The result of attempting to resolve an imported instruction to a constant. +struct ResolveResult { + // The new constant value, if known. + SemIR::ConstantId const_id; + // Whether resolution has been attempted once and needs to be retried. + bool retry = false; + + // Produces a resolve result that tries resolving this instruction again. If + // `const_id` is specified, then this is the end of the second phase, and the + // constant value will be passed to the next resolution attempt. Otherwise, + // this is the end of the first phase. + static auto Retry(SemIR::ConstantId const_id = SemIR::ConstantId::Invalid) + -> ResolveResult { + return {.const_id = const_id, .retry = true}; + } + + // Produces a resolve result that provides the given constant value. Requires + // that there is no new work. + static auto Done(SemIR::ConstantId const_id) -> ResolveResult { + return {.const_id = const_id}; + } +}; +} // namespace + +static auto TryResolveInst(ImportRefResolver& resolver, SemIR::InstId inst_id, + SemIR::ConstantId const_id) -> ResolveResult; + +namespace { +// A context within which we are performing an import. Tracks information about +// the source and destination. This provides a restricted interface compared to +// ImportResolver: in particular, it does not have access to a work list. +// Therefore code that accepts an ImportContext is unable to enqueue new work. +class ImportContext { + public: + // A generic that we have partially imported. + struct PendingGeneric { + SemIR::GenericId import_id; + SemIR::GenericId local_id; + }; + + // A specific that we have partially imported. + struct PendingSpecific { + SemIR::SpecificId import_id; + SemIR::SpecificId local_id; + }; + + explicit ImportContext(Context& context, SemIR::ImportIRId import_ir_id) + : context_(context), + import_ir_id_(import_ir_id), + import_ir_(*context_.import_irs().Get(import_ir_id).sem_ir) {} + + // Returns the file we are importing from. + auto import_ir() -> const SemIR::File& { return import_ir_; } + + // Accessors into value stores of the file we are importing from. + auto import_classes() -> decltype(auto) { return import_ir().classes(); } + auto import_constant_values() -> decltype(auto) { + return import_ir().constant_values(); + } + auto import_entity_names() -> decltype(auto) { + return import_ir().entity_names(); + } + auto import_facet_types() -> decltype(auto) { + return import_ir().facet_types(); + } + auto import_functions() -> decltype(auto) { return import_ir().functions(); } + auto import_generics() -> decltype(auto) { return import_ir().generics(); } + auto import_identifiers() -> decltype(auto) { + return import_ir().identifiers(); + } + auto import_impls() -> decltype(auto) { return import_ir().impls(); } + auto import_inst_blocks() -> decltype(auto) { + return import_ir().inst_blocks(); + } + auto import_insts() -> decltype(auto) { return import_ir().insts(); } + auto import_interfaces() -> decltype(auto) { + return import_ir().interfaces(); + } + auto import_ints() -> decltype(auto) { return import_ir().ints(); } + auto import_name_scopes() -> decltype(auto) { + return import_ir().name_scopes(); + } + auto import_specifics() -> decltype(auto) { return import_ir().specifics(); } + auto import_string_literal_values() -> decltype(auto) { + return import_ir().string_literal_values(); + } + auto import_struct_type_fields() -> decltype(auto) { + return import_ir().struct_type_fields(); + } + auto import_type_blocks() -> decltype(auto) { + return import_ir().type_blocks(); + } + auto import_types() -> decltype(auto) { return import_ir().types(); } + + // Returns the local file's import ID for the IR we are importing from. + auto import_ir_id() -> SemIR::ImportIRId { return import_ir_id_; } + + // A value store for local constant values of imported instructions. This maps + // from `InstId`s in the import IR to corresponding `ConstantId`s in the local + // IR. + auto local_constant_values_for_import_insts() -> decltype(auto) { + return local_context().import_ir_constant_values()[import_ir_id_.index]; + } + + // Returns the file we are importing into. + auto local_ir() -> SemIR::File& { return context_.sem_ir(); } + + // Returns the type-checking context we are importing into. + auto local_context() -> Context& { return context_; } + + // Accessors into value stores of the file we are importing into. + auto local_classes() -> decltype(auto) { return local_ir().classes(); } + auto local_constant_values() -> decltype(auto) { + return local_ir().constant_values(); + } + auto local_entity_names() -> decltype(auto) { + return local_ir().entity_names(); + } + auto local_facet_types() -> decltype(auto) { + return local_ir().facet_types(); + } + auto local_functions() -> decltype(auto) { return local_ir().functions(); } + auto local_generics() -> decltype(auto) { return local_ir().generics(); } + auto local_identifiers() -> decltype(auto) { + return local_ir().identifiers(); + } + auto local_impls() -> decltype(auto) { return local_ir().impls(); } + auto local_import_ir_insts() -> decltype(auto) { + return local_ir().import_ir_insts(); + } + auto local_inst_blocks() -> decltype(auto) { + return local_ir().inst_blocks(); + } + auto local_insts() -> decltype(auto) { return local_ir().insts(); } + auto local_interfaces() -> decltype(auto) { return local_ir().interfaces(); } + auto local_ints() -> decltype(auto) { return local_ir().ints(); } + auto local_name_scopes() -> decltype(auto) { + return local_ir().name_scopes(); + } + auto local_specifics() -> decltype(auto) { return local_ir().specifics(); } + auto local_string_literal_values() -> decltype(auto) { + return local_ir().string_literal_values(); + } + auto local_struct_type_fields() -> decltype(auto) { + return local_ir().struct_type_fields(); + } + auto local_types() -> decltype(auto) { return local_ir().types(); } + + // Add a generic that has been partially imported but needs to be finished. + auto AddPendingGeneric(PendingGeneric pending) -> void { + pending_generics_.push_back(pending); + } + + // Add a specific that has been partially imported but needs to be finished. + auto AddPendingSpecific(PendingSpecific pending) -> void { + pending_specifics_.push_back(pending); + } + + protected: + Context& context_; + SemIR::ImportIRId import_ir_id_; + const SemIR::File& import_ir_; + + // TODO: The following members don't belong here. This pending work mechanism + // can probably be removed entirely if we stop importing generic eval blocks + // and instead evaluate them directly in the imported IR. + + // Generics that we have partially imported but not yet finished importing. + llvm::SmallVector pending_generics_; + // Specifics that we have partially imported but not yet finished importing. + llvm::SmallVector pending_specifics_; +}; + // Resolves an instruction from an imported IR into a constant referring to the // current IR. // @@ -240,12 +415,10 @@ static auto GetInstWithConstantValue(const SemIR::File& file, // TODO: Fix function `extern` handling and merging, rewrite tests. // - check/testdata/function/declaration/import.carbon // - check/testdata/packages/cross_package_import.carbon -class ImportRefResolver { +class ImportRefResolver : public ImportContext { public: explicit ImportRefResolver(Context& context, SemIR::ImportIRId import_ir_id) - : context_(context), - import_ir_id_(import_ir_id), - import_ir_(*context_.import_irs().Get(import_ir_id).sem_ir) {} + : ImportContext(context, import_ir_id) {} // Iteratively resolves an imported instruction's inner references until a // constant ID referencing the current IR is produced. See the class comment @@ -266,7 +439,8 @@ class ImportRefResolver { // Step 2: resolve the instruction. initial_work_ = work_stack_.size(); auto [new_const_id, retry] = - TryResolveInst(work.inst_id, existing.const_id); + TryResolveInst(*this, work.inst_id, existing.const_id); + CARBON_CHECK(!HasNewWork() || retry); CARBON_CHECK( !existing.const_id.is_valid() || existing.const_id == new_const_id, @@ -283,7 +457,7 @@ class ImportRefResolver { work_stack_.pop_back(); } } - auto constant_id = import_ir_constant_values().Get(inst_id); + auto constant_id = local_constant_values_for_import_insts().Get(inst_id); CARBON_CHECK(constant_id.is_valid()); return constant_id; } @@ -298,7 +472,7 @@ class ImportRefResolver { // Wraps constant evaluation with logic to handle constants. auto ResolveConstant(SemIR::ConstantId import_const_id) -> SemIR::ConstantId { - return Resolve(GetInstWithConstantValue(import_ir_, import_const_id)); + return Resolve(GetInstWithConstantValue(import_ir(), import_const_id)); } // Wraps constant evaluation with logic to handle types. @@ -308,29 +482,40 @@ class ImportRefResolver { } auto import_type_const_id = - import_ir_.types().GetConstantId(import_type_id); + import_ir().types().GetConstantId(import_type_id); CARBON_CHECK(import_type_const_id.is_valid()); if (auto import_type_inst_id = - import_ir_.constant_values().GetInstId(import_type_const_id); + import_ir().constant_values().GetInstId(import_type_const_id); import_type_inst_id.is_builtin()) { // Builtins don't require constant resolution; we can use them directly. - return context_.GetBuiltinType(import_type_inst_id.builtin_inst_kind()); + return local_context().GetBuiltinType( + import_type_inst_id.builtin_inst_kind()); } else { - return context_.GetTypeIdForTypeConstant( + return local_context().GetTypeIdForTypeConstant( ResolveConstant(import_type_id.AsConstantId())); } } - private: - // The result of attempting to resolve an imported instruction to a constant. - struct ResolveResult { - // The new constant value, if known. - SemIR::ConstantId const_id; - // Whether resolution has been attempted once and needs to be retried. - bool retry = false; - }; + // Returns true if new unresolved constants were found as part of this + // `Resolve` step. + auto HasNewWork() -> bool { + CARBON_CHECK(initial_work_ <= work_stack_.size(), + "Work shouldn't decrease"); + return initial_work_ < work_stack_.size(); + } + + // Returns the ConstantId for an InstId. Adds unresolved constants to + // work_stack_. + auto GetLocalConstantValueOrPush(SemIR::InstId inst_id) -> SemIR::ConstantId { + auto const_id = local_constant_values_for_import_insts().Get(inst_id); + if (!const_id.is_valid()) { + work_stack_.push_back({.inst_id = inst_id}); + } + return const_id; + } + private: // A step in work_stack_. struct Work { // The instruction to work on. @@ -351,29 +536,6 @@ class ImportRefResolver { llvm::SmallVector indirect_insts = {}; }; - // Local information associated with an imported generic. - struct GenericData { - llvm::SmallVector bindings; - }; - - // Local information associated with an imported specific. - struct SpecificData { - SemIR::ConstantId generic_const_id; - llvm::SmallVector args; - }; - - // A generic that we have partially imported. - struct PendingGeneric { - SemIR::GenericId import_id; - SemIR::GenericId local_id; - }; - - // A specific that we have partially imported. - struct PendingSpecific { - SemIR::SpecificId import_id; - SemIR::SpecificId local_id; - }; - // Looks to see if an instruction has been resolved. If a constant is only // found indirectly, sets the constant for any indirect steps that don't // already have the constant. If a constant isn't found, returns the indirect @@ -381,13 +543,14 @@ class ImportRefResolver { auto FindResolvedConstId(SemIR::InstId inst_id) -> ResolvedConstId { ResolvedConstId result; - if (auto existing_const_id = import_ir_constant_values().Get(inst_id); + if (auto existing_const_id = + local_constant_values_for_import_insts().Get(inst_id); existing_const_id.is_valid()) { result.const_id = existing_const_id; return result; } - const auto* cursor_ir = &import_ir_; + const auto* cursor_ir = &import_ir(); auto cursor_ir_id = SemIR::ImportIRId::Invalid; auto cursor_inst_id = inst_id; @@ -403,21 +566,22 @@ class ImportRefResolver { auto prev_inst_id = cursor_inst_id; cursor_ir = cursor_ir->import_irs().Get(ir_inst.ir_id).sem_ir; - cursor_ir_id = context_.GetImportIRId(*cursor_ir); + cursor_ir_id = local_context().GetImportIRId(*cursor_ir); if (!cursor_ir_id.is_valid()) { // TODO: Should we figure out a location to assign here? - cursor_ir_id = AddImportIR(context_, {.decl_id = SemIR::InstId::Invalid, - .is_export = false, - .sem_ir = cursor_ir}); + cursor_ir_id = + AddImportIR(local_context(), {.decl_id = SemIR::InstId::Invalid, + .is_export = false, + .sem_ir = cursor_ir}); } cursor_inst_id = ir_inst.inst_id; CARBON_CHECK(cursor_ir != prev_ir || cursor_inst_id != prev_inst_id, "{0}", cursor_ir->insts().Get(cursor_inst_id)); - if (auto const_id = - context_.import_ir_constant_values()[cursor_ir_id.index].Get( - cursor_inst_id); + if (auto const_id = local_context() + .import_ir_constant_values()[cursor_ir_id.index] + .Get(cursor_inst_id); const_id.is_valid()) { SetResolvedConstId(inst_id, result.indirect_insts, const_id); result.const_id = const_id; @@ -434,1892 +598,2041 @@ class ImportRefResolver { auto SetResolvedConstId(SemIR::InstId inst_id, llvm::ArrayRef indirect_insts, SemIR::ConstantId const_id) -> void { - import_ir_constant_values().Set(inst_id, const_id); + local_constant_values_for_import_insts().Set(inst_id, const_id); for (auto indirect_inst : indirect_insts) { - context_.import_ir_constant_values()[indirect_inst.ir_id.index].Set( - indirect_inst.inst_id, const_id); + local_context() + .import_ir_constant_values()[indirect_inst.ir_id.index] + .Set(indirect_inst.inst_id, const_id); } } - // Returns true if new unresolved constants were found as part of this - // `Resolve` step. - auto HasNewWork() -> bool { - CARBON_CHECK(initial_work_ <= work_stack_.size(), - "Work shouldn't decrease"); - return initial_work_ < work_stack_.size(); - } + auto PerformPendingWork() -> void; - auto AddImportIRInst(SemIR::InstId inst_id) -> SemIR::ImportIRInstId { - return context_.import_ir_insts().Add( - {.ir_id = import_ir_id_, .inst_id = inst_id}); - } + llvm::SmallVector work_stack_; + // The size of work_stack_ at the start of resolving the current instruction. + size_t initial_work_ = 0; +}; +} // namespace - // Returns the ConstantId for an InstId. Adds unresolved constants to - // work_stack_. - auto GetLocalConstantId(SemIR::InstId inst_id) -> SemIR::ConstantId { - auto const_id = import_ir_constant_values().Get(inst_id); - if (!const_id.is_valid()) { - work_stack_.push_back({.inst_id = inst_id}); - } - return const_id; - } +static auto AddImportRef(ImportContext& context, SemIR::InstId inst_id) + -> SemIR::InstId { + return AddImportRef(context.local_context(), + {.ir_id = context.import_ir_id(), .inst_id = inst_id}); +} - // Returns the ConstantId for an imported ConstantId. Adds unresolved - // constants to work_stack_. - auto GetLocalConstantId(SemIR::ConstantId const_id) -> SemIR::ConstantId { - return GetLocalConstantId(GetInstWithConstantValue(import_ir_, const_id)); - } +static auto AddLoadedImportRef(ImportContext& context, SemIR::TypeId type_id, + SemIR::InstId inst_id, + SemIR::ConstantId const_id) -> SemIR::InstId { + return AddLoadedImportRef( + context.local_context(), type_id, + {.ir_id = context.import_ir_id(), .inst_id = inst_id}, const_id); +} - // Returns the local constant InstId for an imported InstId. - auto GetLocalConstantInstId(SemIR::InstId inst_id) -> SemIR::InstId { - auto const_id = import_ir_constant_values().Get(inst_id); - if (!const_id.is_valid()) { - work_stack_.push_back({.inst_id = inst_id}); - return SemIR::InstId::Invalid; - } - return context_.constant_values().GetInstId(const_id); - } +static auto AddImportIRInst(ImportContext& context, SemIR::InstId inst_id) + -> SemIR::ImportIRInstId { + return context.local_import_ir_insts().Add( + {.ir_id = context.import_ir_id(), .inst_id = inst_id}); +} - // Returns the ConstantId for a TypeId. Adds unresolved constants to - // work_stack_. - auto GetLocalConstantId(SemIR::TypeId type_id) -> SemIR::ConstantId { - return GetLocalConstantId(import_ir_.types().GetConstantId(type_id)); - } +// Returns the ConstantId for an InstId. Adds unresolved constants to +// the resolver's work stack. +static auto GetLocalConstantId(ImportRefResolver& resolver, + SemIR::InstId inst_id) -> SemIR::ConstantId { + return resolver.GetLocalConstantValueOrPush(inst_id); +} - template - auto GetLocalConstantIdChecked(Id id) { - auto result = GetLocalConstantId(id); - CARBON_CHECK(result.is_valid()); - return result; - } +// Returns the ConstantId for an imported ConstantId. Adds unresolved +// constants to the resolver's work stack. +static auto GetLocalConstantId(ImportRefResolver& resolver, + SemIR::ConstantId const_id) + -> SemIR::ConstantId { + return GetLocalConstantId( + resolver, GetInstWithConstantValue(resolver.import_ir(), const_id)); +} - // Gets the local constant values corresponding to an imported inst block. - auto GetLocalInstBlockContents(SemIR::InstBlockId import_block_id) - -> llvm::SmallVector { - llvm::SmallVector inst_ids; - if (!import_block_id.is_valid() || - import_block_id == SemIR::InstBlockId::Empty) { - return inst_ids; - } +// Returns the local constant InstId for an imported InstId. +static auto GetLocalConstantInstId(ImportRefResolver& resolver, + SemIR::InstId inst_id) -> SemIR::InstId { + auto const_id = GetLocalConstantId(resolver, inst_id); + return resolver.local_constant_values().GetInstIdIfValid(const_id); +} - // Import all the values in the block. - auto import_block = import_ir_.inst_blocks().Get(import_block_id); - inst_ids.reserve(import_block.size()); - for (auto import_inst_id : import_block) { - auto const_id = GetLocalConstantId(import_inst_id); - inst_ids.push_back(context_.constant_values().GetInstIdIfValid(const_id)); - } +// Returns the ConstantId for a TypeId. Adds unresolved constants to +// work_stack_. +static auto GetLocalConstantId(ImportRefResolver& resolver, + SemIR::TypeId type_id) -> SemIR::ConstantId { + return GetLocalConstantId(resolver, + resolver.import_types().GetConstantId(type_id)); +} - return inst_ids; +// Returns the ConstantId for an InstId that is required to have already been +// imported. +static auto GetLocalConstantIdChecked(ImportContext& context, + SemIR::InstId inst_id) + -> SemIR::ConstantId { + auto result_id = + context.local_constant_values_for_import_insts().Get(inst_id); + CARBON_CHECK(result_id.is_valid()); + return result_id; +} + +// Returns the ConstantId for a ConstantId that is required to have already been +// imported. +static auto GetLocalConstantIdChecked(ImportContext& context, + SemIR::ConstantId const_id) + -> SemIR::ConstantId { + return GetLocalConstantIdChecked( + context, GetInstWithConstantValue(context.import_ir(), const_id)); +} + +// Returns the ConstantId for a TypeId that is required to have already been +// imported. +static auto GetLocalConstantIdChecked(ImportContext& context, + SemIR::TypeId type_id) + -> SemIR::ConstantId { + return GetLocalConstantIdChecked( + context, context.import_types().GetConstantId(type_id)); +} + +// Translates a NameId from the import IR to a local NameId. +static auto GetLocalNameId(ImportContext& context, SemIR::NameId import_name_id) + -> SemIR::NameId { + if (auto ident_id = import_name_id.AsIdentifierId(); ident_id.is_valid()) { + return SemIR::NameId::ForIdentifier(context.local_identifiers().Add( + context.import_identifiers().Get(ident_id))); } + return import_name_id; +} - // Gets a local instruction block ID corresponding to an imported inst block - // whose contents were already imported, for example by - // GetLocalInstBlockContents. - auto GetLocalInstBlockId(SemIR::InstBlockId import_block_id, - llvm::ArrayRef contents) - -> SemIR::InstBlockId { - if (!import_block_id.is_valid()) { - return SemIR::InstBlockId::Invalid; - } - return context_.inst_blocks().Add(contents); +// Gets the local constant values corresponding to an imported inst block. +static auto GetLocalInstBlockContents(ImportRefResolver& resolver, + SemIR::InstBlockId import_block_id) + -> llvm::SmallVector { + llvm::SmallVector inst_ids; + if (!import_block_id.is_valid() || + import_block_id == SemIR::InstBlockId::Empty) { + return inst_ids; } - // Gets a local canonical instruction block ID corresponding to an imported - // inst block whose contents were already imported, for example by - // GetLocalInstBlockContents. - auto GetLocalCanonicalInstBlockId(SemIR::InstBlockId import_block_id, - llvm::ArrayRef contents) - -> SemIR::InstBlockId { - if (!import_block_id.is_valid()) { - return SemIR::InstBlockId::Invalid; - } - return context_.inst_blocks().AddCanonical(contents); + // Import all the values in the block. + auto import_block = resolver.import_inst_blocks().Get(import_block_id); + inst_ids.reserve(import_block.size()); + for (auto import_inst_id : import_block) { + auto const_id = GetLocalConstantId(resolver, import_inst_id); + inst_ids.push_back( + resolver.local_constant_values().GetInstIdIfValid(const_id)); } - // Gets an incomplete local version of an imported generic. Most fields are - // set in the third phase. - auto MakeIncompleteGeneric(SemIR::InstId decl_id, SemIR::GenericId generic_id) - -> SemIR::GenericId { - if (!generic_id.is_valid()) { - return SemIR::GenericId::Invalid; - } + return inst_ids; +} + +// Gets a local canonical instruction block ID corresponding to an imported inst +// block whose contents were already imported, for example by +// GetLocalInstBlockContents. +static auto GetLocalCanonicalInstBlockId(ImportContext& context, + SemIR::InstBlockId import_block_id, + llvm::ArrayRef contents) + -> SemIR::InstBlockId { + if (!import_block_id.is_valid()) { + return SemIR::InstBlockId::Invalid; + } + return context.local_inst_blocks().AddCanonical(contents); +} - return context_.generics().Add( - {.decl_id = decl_id, - .bindings_id = SemIR::InstBlockId::Invalid, - .self_specific_id = SemIR::SpecificId::Invalid}); +// Gets an incomplete local version of an imported generic. Most fields are +// set in the third phase. +static auto MakeIncompleteGeneric(ImportContext& context, SemIR::InstId decl_id, + SemIR::GenericId generic_id) + -> SemIR::GenericId { + if (!generic_id.is_valid()) { + return SemIR::GenericId::Invalid; } - // Gets a local version of the data associated with a generic. - auto GetLocalGenericData(SemIR::GenericId generic_id) -> GenericData { - if (!generic_id.is_valid()) { - return GenericData(); - } + return context.local_generics().Add( + {.decl_id = decl_id, + .bindings_id = SemIR::InstBlockId::Invalid, + .self_specific_id = SemIR::SpecificId::Invalid}); +} + +namespace { +// Local information associated with an imported generic. +struct GenericData { + llvm::SmallVector bindings; +}; +} // namespace - const auto& generic = import_ir_.generics().Get(generic_id); - return {.bindings = GetLocalInstBlockContents(generic.bindings_id)}; +// Gets a local version of the data associated with a generic. +static auto GetLocalGenericData(ImportRefResolver& resolver, + SemIR::GenericId generic_id) -> GenericData { + if (!generic_id.is_valid()) { + return GenericData(); } - // Adds the given local generic data to the given generic. - auto SetGenericData(SemIR::GenericId import_generic_id, - SemIR::GenericId new_generic_id, - const GenericData& generic_data) -> void { - if (!import_generic_id.is_valid()) { - return; - } + const auto& generic = resolver.import_generics().Get(generic_id); + return {.bindings = GetLocalInstBlockContents(resolver, generic.bindings_id)}; +} - const auto& import_generic = import_ir_.generics().Get(import_generic_id); - auto& new_generic = context_.generics().Get(new_generic_id); - new_generic.bindings_id = GetLocalCanonicalInstBlockId( - import_generic.bindings_id, generic_data.bindings); - // Fill in the remaining information in FinishPendingGeneric. - pending_generics_.push_back( - {.import_id = import_generic_id, .local_id = new_generic_id}); +// Adds the given local generic data to the given generic. +static auto SetGenericData(ImportContext& context, + SemIR::GenericId import_generic_id, + SemIR::GenericId new_generic_id, + const GenericData& generic_data) -> void { + if (!import_generic_id.is_valid()) { + return; } - // Gets a local constant value corresponding to an imported generic ID. May - // add work to the work stack and return `Invalid`. - auto GetLocalConstantId(SemIR::GenericId generic_id) -> SemIR::ConstantId { - if (!generic_id.is_valid()) { - return SemIR::ConstantId::Invalid; + const auto& import_generic = context.import_generics().Get(import_generic_id); + auto& new_generic = context.local_generics().Get(new_generic_id); + new_generic.bindings_id = GetLocalCanonicalInstBlockId( + context, import_generic.bindings_id, generic_data.bindings); + + // Track that we need to fill in the remaining information in + // FinishPendingGeneric. + context.AddPendingGeneric( + {.import_id = import_generic_id, .local_id = new_generic_id}); +} + +// Gets a local constant value corresponding to an imported generic ID. May +// add work to the work stack and return `Invalid`. +static auto GetLocalConstantId(ImportRefResolver& resolver, + SemIR::GenericId generic_id) + -> SemIR::ConstantId { + if (!generic_id.is_valid()) { + return SemIR::ConstantId::Invalid; + } + auto import_decl_inst_id = resolver.import_generics().Get(generic_id).decl_id; + auto import_decl_inst = resolver.import_insts().Get(import_decl_inst_id); + if (import_decl_inst.Is()) { + // For an impl declaration, the imported entity can be found via the + // declaration. + return GetLocalConstantId(resolver, import_decl_inst_id); + } + // For all other kinds of declaration, the imported entity can be found via + // the type of the declaration. + return GetLocalConstantId(resolver, import_decl_inst.type_id()); +} + +// Gets a local generic ID given the corresponding local constant ID returned +// by GetLocalConstantId for the imported generic. Does not add any new work. +static auto GetLocalGenericId(ImportContext& context, + SemIR::ConstantId local_const_id) + -> SemIR::GenericId { + if (!local_const_id.is_valid()) { + return SemIR::GenericId::Invalid; + } + auto inst = context.local_insts().Get( + context.local_constant_values().GetInstId(local_const_id)); + CARBON_KIND_SWITCH(inst) { + case CARBON_KIND(SemIR::FunctionType fn_type): { + return context.local_functions().Get(fn_type.function_id).generic_id; } - auto import_decl_inst_id = import_ir_.generics().Get(generic_id).decl_id; - auto import_decl_inst = import_ir_.insts().Get(import_decl_inst_id); - if (import_decl_inst.Is()) { - // For an impl declaration, the imported entity can be found via the - // declaration. - return GetLocalConstantId(import_decl_inst_id); + case CARBON_KIND(SemIR::GenericClassType class_type): { + return context.local_classes().Get(class_type.class_id).generic_id; } - // For all other kinds of declaration, the imported entity can be found via - // the type of the declaration. - return GetLocalConstantId(import_decl_inst.type_id()); - } - - // Gets a local generic ID given the corresponding local constant ID returned - // by GetLocalConstantId for the imported generic. Does not add any new work. - auto GetLocalGenericId(SemIR::ConstantId local_const_id) -> SemIR::GenericId { - if (!local_const_id.is_valid()) { - return SemIR::GenericId::Invalid; + case CARBON_KIND(SemIR::GenericInterfaceType interface_type): { + return context.local_interfaces() + .Get(interface_type.interface_id) + .generic_id; } - auto inst = context_.insts().Get( - context_.constant_values().GetInstId(local_const_id)); - CARBON_KIND_SWITCH(inst) { - case CARBON_KIND(SemIR::FunctionType fn_type): { - return context_.functions().Get(fn_type.function_id).generic_id; - } - case CARBON_KIND(SemIR::GenericClassType class_type): { - return context_.classes().Get(class_type.class_id).generic_id; - } - case CARBON_KIND(SemIR::GenericInterfaceType interface_type): { - return context_.interfaces() - .Get(interface_type.interface_id) - .generic_id; - } - case CARBON_KIND(SemIR::ImplDecl impl_decl): { - return context_.impls().Get(impl_decl.impl_id).generic_id; - } - default: { - CARBON_FATAL("Unexpected inst for generic declaration: {0}", inst); - } + case CARBON_KIND(SemIR::ImplDecl impl_decl): { + return context.local_impls().Get(impl_decl.impl_id).generic_id; + } + default: { + CARBON_FATAL("Unexpected inst for generic declaration: {0}", inst); } } +} - // Gets local information about an imported specific. - auto GetLocalSpecificData(SemIR::SpecificId specific_id) -> SpecificData { - if (!specific_id.is_valid()) { - return {.generic_const_id = SemIR::ConstantId::Invalid, .args = {}}; - } +namespace { +// Local information associated with an imported specific. +struct SpecificData { + SemIR::ConstantId generic_const_id; + llvm::SmallVector args; +}; +} // namespace - const auto& specific = import_ir_.specifics().Get(specific_id); - return { - .generic_const_id = GetLocalConstantId(specific.generic_id), - .args = GetLocalInstBlockContents(specific.args_id), - }; +// Gets local information about an imported specific. +static auto GetLocalSpecificData(ImportRefResolver& resolver, + SemIR::SpecificId specific_id) + -> SpecificData { + if (!specific_id.is_valid()) { + return {.generic_const_id = SemIR::ConstantId::Invalid, .args = {}}; } - // Gets a local specific whose data was already imported by - // GetLocalSpecificData. Does not add any new work. - auto GetOrAddLocalSpecific(SemIR::SpecificId import_specific_id, - const SpecificData& data) -> SemIR::SpecificId { - if (!import_specific_id.is_valid()) { - return SemIR::SpecificId::Invalid; - } - - // Form a corresponding local specific ID. - const auto& import_specific = - import_ir_.specifics().Get(import_specific_id); - auto generic_id = GetLocalGenericId(data.generic_const_id); - auto args_id = - GetLocalCanonicalInstBlockId(import_specific.args_id, data.args); + const auto& specific = resolver.import_specifics().Get(specific_id); + return { + .generic_const_id = GetLocalConstantId(resolver, specific.generic_id), + .args = GetLocalInstBlockContents(resolver, specific.args_id), + }; +} - // Get the specific. - auto specific_id = context_.specifics().GetOrAdd(generic_id, args_id); +// Gets a local specific whose data was already imported by +// GetLocalSpecificData. Does not add any new work. +static auto GetOrAddLocalSpecific(ImportContext& context, + SemIR::SpecificId import_specific_id, + const SpecificData& data) + -> SemIR::SpecificId { + if (!import_specific_id.is_valid()) { + return SemIR::SpecificId::Invalid; + } + + // Form a corresponding local specific ID. + const auto& import_specific = + context.import_specifics().Get(import_specific_id); + auto generic_id = GetLocalGenericId(context, data.generic_const_id); + auto args_id = + GetLocalCanonicalInstBlockId(context, import_specific.args_id, data.args); + + // Get the specific. + auto specific_id = context.local_specifics().GetOrAdd(generic_id, args_id); + + // Fill in the remaining information in FinishPendingSpecific, if necessary. + auto& specific = context.local_specifics().Get(specific_id); + if (!specific.decl_block_id.is_valid() || + (import_specific.definition_block_id.is_valid() && + !specific.definition_block_id.is_valid())) { + context.AddPendingSpecific( + {.import_id = import_specific_id, .local_id = specific_id}); + } + return specific_id; +} - // Fill in the remaining information in FinishPendingSpecific, if necessary. - auto& specific = context_.specifics().Get(specific_id); - if (!specific.decl_block_id.is_valid() || - (import_specific.definition_block_id.is_valid() && - !specific.definition_block_id.is_valid())) { - pending_specifics_.push_back( - {.import_id = import_specific_id, .local_id = specific_id}); - } - return specific_id; +// Adds unresolved constants for each parameter's type to the resolver's work +// stack. +static auto LoadLocalPatternConstantIds(ImportRefResolver& resolver, + SemIR::InstBlockId param_patterns_id) + -> void { + if (!param_patterns_id.is_valid() || + param_patterns_id == SemIR::InstBlockId::Empty) { + return; } - // Adds unresolved constants for each parameter's type to work_stack_. - auto LoadLocalPatternConstantIds(SemIR::InstBlockId param_patterns_id) - -> void { - if (!param_patterns_id.is_valid() || - param_patterns_id == SemIR::InstBlockId::Empty) { - return; + const auto& param_patterns = + resolver.import_inst_blocks().Get(param_patterns_id); + for (auto pattern_id : param_patterns) { + auto pattern_inst = resolver.import_insts().Get(pattern_id); + GetLocalConstantId(resolver, pattern_inst.type_id()); + if (auto addr = pattern_inst.TryAs()) { + pattern_id = addr->inner_id; + pattern_inst = resolver.import_insts().Get(pattern_id); + GetLocalConstantId(resolver, pattern_inst.type_id()); } - - const auto& param_patterns = - import_ir_.inst_blocks().Get(param_patterns_id); - for (auto pattern_id : param_patterns) { - auto pattern_inst = import_ir_.insts().Get(pattern_id); - GetLocalConstantId(pattern_inst.type_id()); - if (auto addr = pattern_inst.TryAs()) { - pattern_id = addr->inner_id; - pattern_inst = import_ir_.insts().Get(pattern_id); - GetLocalConstantId(pattern_inst.type_id()); - } - pattern_id = import_ir_.insts() - .GetAs(pattern_id) - .subpattern_id; - pattern_inst = import_ir_.insts().Get(pattern_id); - // If the parameter is a symbolic binding, build the - // SymbolicBindingPattern constant. - if (pattern_inst.Is()) { - GetLocalConstantId(pattern_id); - } + pattern_id = resolver.import_insts() + .GetAs(pattern_id) + .subpattern_id; + pattern_inst = resolver.import_insts().Get(pattern_id); + // If the parameter is a symbolic binding, build the + // SymbolicBindingPattern constant. + if (pattern_inst.Is()) { + GetLocalConstantId(resolver, pattern_id); } } +} - // Returns a version of param_patterns_id localized to the current IR. - // - // Must only be called after a call to - // LoadLocalPatternConstantIds(param_patterns_id) has completed without adding - // any new work to work_stack_. - // - // TODO: This is inconsistent with the rest of this class, which expects - // the relevant constants to be explicitly passed in. That makes it - // easier to statically detect when an input isn't loaded, but makes it - // harder to support importing more complex inst structures. We should - // take a holistic look at how to balance those concerns. For example, - // could the same function be used to load the constants and use them, with - // a parameter to select between the two? - auto GetLocalParamPatternsId(SemIR::InstBlockId param_patterns_id) - -> SemIR::InstBlockId { - if (!param_patterns_id.is_valid() || - param_patterns_id == SemIR::InstBlockId::Empty) { - return param_patterns_id; - } - const auto& param_patterns = - import_ir_.inst_blocks().Get(param_patterns_id); - llvm::SmallVector new_patterns; - for (auto param_id : param_patterns) { - // Figure out the pattern structure. This echoes - // Function::GetParamPatternInfoFromPatternId. - auto addr_pattern_id = param_id; - auto addr_inst = - import_ir_.insts().TryGetAs(addr_pattern_id); - auto param_pattern_id = addr_pattern_id; - if (addr_inst) { - param_pattern_id = addr_inst->inner_id; - } - - auto param_pattern = - import_ir_.insts().GetAs(param_pattern_id); - - auto binding_id = param_pattern.subpattern_id; - auto binding = - import_ir_.insts().GetAs(binding_id); - - // Rebuild the pattern. - auto entity_name = import_ir_.entity_names().Get(binding.entity_name_id); - auto name_id = GetLocalNameId(entity_name.name_id); - auto type_id = context_.GetTypeIdForTypeConstant( - GetLocalConstantIdChecked(binding.type_id)); - - auto new_param_id = SemIR::InstId::Invalid; - switch (binding.kind) { - case SemIR::BindingPattern::Kind: { - auto entity_name_id = context_.entity_names().Add( - {.name_id = name_id, - .parent_scope_id = SemIR::NameScopeId::Invalid, - .bind_index = SemIR::CompileTimeBindIndex::Invalid}); - new_param_id = context_.AddInstInNoBlock( - AddImportIRInst(binding_id), - {.type_id = type_id, .entity_name_id = entity_name_id}); - break; - } - case SemIR::SymbolicBindingPattern::Kind: { - // We already imported a constant value for this symbolic binding. - // We can reuse most of it, but update the value to point to our - // specific parameter, and preserve the constant value. - auto bind_const_id = GetLocalConstantIdChecked(binding_id); - auto new_binding_inst = - context_.insts().GetAs( - context_.constant_values().GetInstId(bind_const_id)); - new_param_id = context_.AddInstInNoBlock(AddImportIRInst(binding_id), - new_binding_inst); - context_.constant_values().Set(new_param_id, bind_const_id); - break; - } - default: { - CARBON_FATAL("Unexpected kind: ", binding.kind); - } +// Returns a version of param_patterns_id localized to the current IR. +// +// Must only be called after a call to +// LoadLocalPatternConstantIds(param_patterns_id) has completed without adding +// any new work to work_stack_. +// +// TODO: This is inconsistent with the rest of this class, which expects +// the relevant constants to be explicitly passed in. That makes it +// easier to statically detect when an input isn't loaded, but makes it +// harder to support importing more complex inst structures. We should +// take a holistic look at how to balance those concerns. For example, +// could the same function be used to load the constants and use them, with +// a parameter to select between the two? +static auto GetLocalParamPatternsId(ImportContext& context, + SemIR::InstBlockId param_patterns_id) + -> SemIR::InstBlockId { + if (!param_patterns_id.is_valid() || + param_patterns_id == SemIR::InstBlockId::Empty) { + return param_patterns_id; + } + const auto& param_patterns = + context.import_inst_blocks().Get(param_patterns_id); + llvm::SmallVector new_patterns; + for (auto param_id : param_patterns) { + // Figure out the pattern structure. This echoes + // Function::GetParamPatternInfoFromPatternId. + auto addr_pattern_id = param_id; + auto addr_inst = + context.import_insts().TryGetAs(addr_pattern_id); + auto param_pattern_id = addr_pattern_id; + if (addr_inst) { + param_pattern_id = addr_inst->inner_id; + } + + auto param_pattern = context.import_insts().GetAs( + param_pattern_id); + + auto binding_id = param_pattern.subpattern_id; + auto binding = + context.import_insts().GetAs(binding_id); + + // Rebuild the pattern. + auto entity_name = + context.import_entity_names().Get(binding.entity_name_id); + auto name_id = GetLocalNameId(context, entity_name.name_id); + auto type_id = context.local_context().GetTypeIdForTypeConstant( + GetLocalConstantIdChecked(context, binding.type_id)); + + auto new_param_id = SemIR::InstId::Invalid; + switch (binding.kind) { + case SemIR::BindingPattern::Kind: { + auto entity_name_id = context.local_entity_names().Add( + {.name_id = name_id, + .parent_scope_id = SemIR::NameScopeId::Invalid, + .bind_index = SemIR::CompileTimeBindIndex::Invalid}); + new_param_id = + context.local_context().AddInstInNoBlock( + AddImportIRInst(context, binding_id), + {.type_id = type_id, .entity_name_id = entity_name_id}); + break; } - new_param_id = context_.AddInstInNoBlock( - context_.MakeImportedLocAndInst( - AddImportIRInst(param_pattern_id), - {.type_id = type_id, - .subpattern_id = new_param_id, - .runtime_index = param_pattern.runtime_index})); - if (addr_inst) { - type_id = context_.GetTypeIdForTypeConstant( - GetLocalConstantIdChecked(addr_inst->type_id)); - new_param_id = context_.AddInstInNoBlock( - context_.MakeImportedLocAndInst( - AddImportIRInst(addr_pattern_id), - {.type_id = type_id, .inner_id = new_param_id})); + case SemIR::SymbolicBindingPattern::Kind: { + // We already imported a constant value for this symbolic binding. + // We can reuse most of it, but update the value to point to our + // specific parameter, and preserve the constant value. + auto bind_const_id = GetLocalConstantIdChecked(context, binding_id); + auto new_binding_inst = + context.local_insts().GetAs( + context.local_constant_values().GetInstId(bind_const_id)); + new_param_id = context.local_context().AddInstInNoBlock( + AddImportIRInst(context, binding_id), new_binding_inst); + context.local_constant_values().Set(new_param_id, bind_const_id); + break; } - new_patterns.push_back(new_param_id); - } - return context_.inst_blocks().Add(new_patterns); + default: { + CARBON_FATAL("Unexpected kind: ", binding.kind); + } + } + new_param_id = context.local_context().AddInstInNoBlock( + context.local_context() + .MakeImportedLocAndInst( + AddImportIRInst(context, param_pattern_id), + {.type_id = type_id, + .subpattern_id = new_param_id, + .runtime_index = param_pattern.runtime_index})); + if (addr_inst) { + type_id = context.local_context().GetTypeIdForTypeConstant( + GetLocalConstantIdChecked(context, addr_inst->type_id)); + new_param_id = context.local_context().AddInstInNoBlock( + context.local_context().MakeImportedLocAndInst( + AddImportIRInst(context, addr_pattern_id), + {.type_id = type_id, .inner_id = new_param_id})); + } + new_patterns.push_back(new_param_id); + } + return context.local_inst_blocks().Add(new_patterns); +} + +// Returns a version of import_return_slot_pattern_id localized to the current +// IR. +static auto GetLocalReturnSlotPatternId( + ImportContext& context, SemIR::InstId import_return_slot_pattern_id) + -> SemIR::InstId { + if (!import_return_slot_pattern_id.is_valid()) { + return SemIR::InstId::Invalid; } - // Returns a version of import_return_slot_pattern_id localized to the current - // IR. - auto GetLocalReturnSlotPatternId(SemIR::InstId import_return_slot_pattern_id) - -> SemIR::InstId { - if (!import_return_slot_pattern_id.is_valid()) { - return SemIR::InstId::Invalid; - } - - auto param_pattern = import_ir_.insts().GetAs( - import_return_slot_pattern_id); - auto return_slot_pattern = - import_ir_.insts().GetAs( - param_pattern.subpattern_id); - auto type_id = context_.GetTypeIdForTypeConstant( - GetLocalConstantIdChecked(return_slot_pattern.type_id)); - - auto new_return_slot_pattern_id = context_.AddInstInNoBlock( - context_.MakeImportedLocAndInst( - AddImportIRInst(param_pattern.subpattern_id), - {.type_id = type_id, .type_inst_id = SemIR::InstId::Invalid})); - return context_.AddInstInNoBlock( - context_.MakeImportedLocAndInst( - AddImportIRInst(import_return_slot_pattern_id), - {.type_id = type_id, - .subpattern_id = new_return_slot_pattern_id, - .runtime_index = param_pattern.runtime_index})); - } - - // Translates a NameId from the import IR to a local NameId. - auto GetLocalNameId(SemIR::NameId import_name_id) -> SemIR::NameId { - if (auto ident_id = import_name_id.AsIdentifierId(); ident_id.is_valid()) { - return SemIR::NameId::ForIdentifier( - context_.identifiers().Add(import_ir_.identifiers().Get(ident_id))); - } - return import_name_id; - } - - // Translates a NameScopeId from the import IR to a local NameScopeId. Adds - // unresolved constants to the work stack. - auto GetLocalNameScopeId(SemIR::NameScopeId name_scope_id) - -> SemIR::NameScopeId { - // Get the instruction that created the scope. - auto [inst_id, inst] = - import_ir_.name_scopes().GetInstIfValid(name_scope_id); - if (!inst) { - // Map scopes that aren't associated with an instruction to invalid - // scopes. For now, such scopes aren't used, and we don't have a good way - // to remap them. - return SemIR::NameScopeId::Invalid; - } - - // Get the constant value for the scope. - auto const_id = SemIR::ConstantId::Invalid; - CARBON_KIND_SWITCH(*inst) { - case SemIR::Namespace::Kind: - // If the namespace has already been imported, we can use its constant. - // However, if it hasn't, we use Invalid instead of adding it to the - // work stack. That's expected to be okay when resolving references. - const_id = import_ir_constant_values().Get(inst_id); - break; + auto param_pattern = context.import_insts().GetAs( + import_return_slot_pattern_id); + auto return_slot_pattern = + context.import_insts().GetAs( + param_pattern.subpattern_id); + auto type_id = context.local_context().GetTypeIdForTypeConstant( + GetLocalConstantIdChecked(context, return_slot_pattern.type_id)); + + auto new_return_slot_pattern_id = context.local_context().AddInstInNoBlock( + context.local_context().MakeImportedLocAndInst( + AddImportIRInst(context, param_pattern.subpattern_id), + {.type_id = type_id, .type_inst_id = SemIR::InstId::Invalid})); + return context.local_context().AddInstInNoBlock( + context.local_context().MakeImportedLocAndInst( + AddImportIRInst(context, import_return_slot_pattern_id), + {.type_id = type_id, + .subpattern_id = new_return_slot_pattern_id, + .runtime_index = param_pattern.runtime_index})); +} - default: - const_id = GetLocalConstantId(inst_id); - } - if (!const_id.is_valid()) { - return SemIR::NameScopeId::Invalid; - } +// Translates a NameScopeId from the import IR to a local NameScopeId. Adds +// unresolved constants to the resolver's work stack. +static auto GetLocalNameScopeId(ImportRefResolver& resolver, + SemIR::NameScopeId name_scope_id) + -> SemIR::NameScopeId { + // Get the instruction that created the scope. + auto [inst_id, inst] = + resolver.import_name_scopes().GetInstIfValid(name_scope_id); + if (!inst) { + // Map scopes that aren't associated with an instruction to invalid + // scopes. For now, such scopes aren't used, and we don't have a good way + // to remap them. + return SemIR::NameScopeId::Invalid; + } - auto const_inst_id = context_.constant_values().GetInstId(const_id); - auto name_scope_inst = context_.insts().Get(const_inst_id); - CARBON_KIND_SWITCH(name_scope_inst) { - case CARBON_KIND(SemIR::Namespace inst): { - return inst.name_scope_id; - } - case CARBON_KIND(SemIR::ClassType inst): { - return context_.classes().Get(inst.class_id).scope_id; - } - case CARBON_KIND(SemIR::FacetType inst): { - const SemIR::FacetTypeInfo& facet_type_info = - context_.facet_types().Get(inst.facet_type_id); - // This is specifically the facet type produced by an interface - // declaration, and so should consist of a single interface. - // TODO: Will also have to handle named constraints here, once those are - // implemented. - auto interface = facet_type_info.TryAsSingleInterface(); - CARBON_CHECK(interface); - return context_.interfaces().Get(interface->interface_id).scope_id; - } - case CARBON_KIND(SemIR::ImplDecl inst): { - return context_.impls().Get(inst.impl_id).scope_id; - } - case SemIR::StructValue::Kind: { - auto type_inst = context_.types().GetAsInst(name_scope_inst.type_id()); - CARBON_KIND_SWITCH(type_inst) { - case CARBON_KIND(SemIR::GenericClassType inst): { - return context_.classes().Get(inst.class_id).scope_id; - } - case CARBON_KIND(SemIR::GenericInterfaceType inst): { - return context_.interfaces().Get(inst.interface_id).scope_id; - } - default: { - break; - } + // Get the constant value for the scope. + auto const_id = SemIR::ConstantId::Invalid; + CARBON_KIND_SWITCH(*inst) { + case SemIR::Namespace::Kind: + // If the namespace has already been imported, we can use its constant. + // However, if it hasn't, we use Invalid instead of adding it to the + // work stack. That's expected to be okay when resolving references. + const_id = resolver.local_constant_values_for_import_insts().Get(inst_id); + break; + + default: + const_id = GetLocalConstantId(resolver, inst_id); + } + if (!const_id.is_valid()) { + return SemIR::NameScopeId::Invalid; + } + + auto const_inst_id = resolver.local_constant_values().GetInstId(const_id); + auto name_scope_inst = resolver.local_insts().Get(const_inst_id); + CARBON_KIND_SWITCH(name_scope_inst) { + case CARBON_KIND(SemIR::Namespace inst): { + return inst.name_scope_id; + } + case CARBON_KIND(SemIR::ClassType inst): { + return resolver.local_classes().Get(inst.class_id).scope_id; + } + case CARBON_KIND(SemIR::FacetType inst): { + const SemIR::FacetTypeInfo& facet_type_info = + resolver.local_facet_types().Get(inst.facet_type_id); + // This is specifically the facet type produced by an interface + // declaration, and so should consist of a single interface. + // TODO: Will also have to handle named constraints here, once those are + // implemented. + auto interface = facet_type_info.TryAsSingleInterface(); + CARBON_CHECK(interface); + return resolver.local_interfaces().Get(interface->interface_id).scope_id; + } + case CARBON_KIND(SemIR::ImplDecl inst): { + return resolver.local_impls().Get(inst.impl_id).scope_id; + } + case SemIR::StructValue::Kind: { + auto type_inst = + resolver.local_types().GetAsInst(name_scope_inst.type_id()); + CARBON_KIND_SWITCH(type_inst) { + case CARBON_KIND(SemIR::GenericClassType inst): { + return resolver.local_classes().Get(inst.class_id).scope_id; } - break; - } - default: { - if (const_inst_id == SemIR::InstId::BuiltinErrorInst) { - return SemIR::NameScopeId::Invalid; + case CARBON_KIND(SemIR::GenericInterfaceType inst): { + return resolver.local_interfaces().Get(inst.interface_id).scope_id; + } + default: { + break; } - break; } + break; } - CARBON_FATAL("Unexpected instruction kind for name scope: {0}", - name_scope_inst); - } - - // Given an imported entity base, returns an incomplete, local version of it. - // - // Most fields are set in the third phase once they're imported. Import enough - // of the parameter lists that we know whether this interface is a generic - // interface and can build the right constant value for it. - // - // TODO: Support extern. - // TODO: Add a better way to represent a generic prior to importing the - // parameters. - auto GetIncompleteLocalEntityBase( - SemIR::InstId decl_id, const SemIR::EntityWithParamsBase& import_base) - -> SemIR::EntityWithParamsBase { - // Translate the extern_library_id if present. - auto extern_library_id = SemIR::LibraryNameId::Invalid; - if (import_base.extern_library_id.is_valid()) { - if (import_base.extern_library_id.index >= 0) { - auto val = import_ir_.string_literal_values().Get( - import_base.extern_library_id.AsStringLiteralValueId()); - extern_library_id = SemIR::LibraryNameId::ForStringLiteralValueId( - context_.string_literal_values().Add(val)); - } else { - extern_library_id = import_base.extern_library_id; + default: { + if (const_inst_id == SemIR::InstId::BuiltinErrorInst) { + return SemIR::NameScopeId::Invalid; } + break; } + } + CARBON_FATAL("Unexpected instruction kind for name scope: {0}", + name_scope_inst); +} - return { - .name_id = GetLocalNameId(import_base.name_id), - .parent_scope_id = SemIR::NameScopeId::Invalid, - .generic_id = MakeIncompleteGeneric(decl_id, import_base.generic_id), - .first_param_node_id = Parse::NodeId::Invalid, - .last_param_node_id = Parse::NodeId::Invalid, - .pattern_block_id = SemIR::InstBlockId::Invalid, - .implicit_param_patterns_id = - import_base.implicit_param_patterns_id.is_valid() - ? SemIR::InstBlockId::Empty - : SemIR::InstBlockId::Invalid, - .param_patterns_id = import_base.param_patterns_id.is_valid() - ? SemIR::InstBlockId::Empty - : SemIR::InstBlockId::Invalid, - .call_params_id = SemIR::InstBlockId::Invalid, - .is_extern = import_base.is_extern, - .extern_library_id = extern_library_id, - .non_owning_decl_id = import_base.non_owning_decl_id.is_valid() +// Given an imported entity base, returns an incomplete, local version of it. +// +// Most fields are set in the third phase once they're imported. Import enough +// of the parameter lists that we know whether this interface is a generic +// interface and can build the right constant value for it. +// +// TODO: Support extern. +static auto GetIncompleteLocalEntityBase( + ImportContext& context, SemIR::InstId decl_id, + const SemIR::EntityWithParamsBase& import_base) + -> SemIR::EntityWithParamsBase { + // Translate the extern_library_id if present. + auto extern_library_id = SemIR::LibraryNameId::Invalid; + if (import_base.extern_library_id.is_valid()) { + if (import_base.extern_library_id.index >= 0) { + auto val = context.import_string_literal_values().Get( + import_base.extern_library_id.AsStringLiteralValueId()); + extern_library_id = SemIR::LibraryNameId::ForStringLiteralValueId( + context.local_string_literal_values().Add(val)); + } else { + extern_library_id = import_base.extern_library_id; + } + } + + return { + .name_id = GetLocalNameId(context, import_base.name_id), + .parent_scope_id = SemIR::NameScopeId::Invalid, + .generic_id = + MakeIncompleteGeneric(context, decl_id, import_base.generic_id), + .first_param_node_id = Parse::NodeId::Invalid, + .last_param_node_id = Parse::NodeId::Invalid, + .pattern_block_id = SemIR::InstBlockId::Invalid, + .implicit_param_patterns_id = + import_base.implicit_param_patterns_id.is_valid() + ? SemIR::InstBlockId::Empty + : SemIR::InstBlockId::Invalid, + .param_patterns_id = import_base.param_patterns_id.is_valid() + ? SemIR::InstBlockId::Empty + : SemIR::InstBlockId::Invalid, + .call_params_id = SemIR::InstBlockId::Invalid, + .is_extern = import_base.is_extern, + .extern_library_id = extern_library_id, + .non_owning_decl_id = import_base.non_owning_decl_id.is_valid() + ? decl_id + : SemIR::InstId::Invalid, + .first_owning_decl_id = import_base.first_owning_decl_id.is_valid() ? decl_id : SemIR::InstId::Invalid, - .first_owning_decl_id = import_base.first_owning_decl_id.is_valid() - ? decl_id - : SemIR::InstId::Invalid, - }; - } - - // Adds ImportRefUnloaded entries for members of the imported scope, for name - // lookup. - auto AddNameScopeImportRefs(const SemIR::NameScope& import_scope, - SemIR::NameScope& new_scope) -> void { - for (auto entry : import_scope.names) { - auto ref_id = AddImportRef( - context_, {.ir_id = import_ir_id_, .inst_id = entry.inst_id}); - new_scope.AddRequired({.name_id = GetLocalNameId(entry.name_id), - .inst_id = ref_id, - .access_kind = entry.access_kind}); - } - for (auto scope_inst_id : import_scope.extended_scopes) { - new_scope.extended_scopes.push_back(AddImportRef( - context_, {.ir_id = import_ir_id_, .inst_id = scope_inst_id})); - } - } - - // Given a block ID for a list of associated entities of a witness, returns a - // version localized to the current IR. - auto AddAssociatedEntities(SemIR::InstBlockId associated_entities_id) - -> SemIR::InstBlockId { - if (associated_entities_id == SemIR::InstBlockId::Empty) { - return SemIR::InstBlockId::Empty; - } - auto associated_entities = - import_ir_.inst_blocks().Get(associated_entities_id); - llvm::SmallVector new_associated_entities; - new_associated_entities.reserve(associated_entities.size()); - for (auto inst_id : associated_entities) { - new_associated_entities.push_back( - AddImportRef(context_, {.ir_id = import_ir_id_, .inst_id = inst_id})); - } - return context_.inst_blocks().Add(new_associated_entities); - } - - // Tries to resolve the InstId, returning a constant when ready, or Invalid if - // more has been added to the stack. A similar API is followed for all - // following TryResolveTypedInst helper functions. - // - // `const_id` is Invalid unless we've tried to resolve this instruction - // before, in which case it's the previous result. - // - // TODO: Error is returned when support is missing, but that should go away. - auto TryResolveInst(SemIR::InstId inst_id, SemIR::ConstantId const_id) - -> ResolveResult { - auto inst_const_id = import_ir_.constant_values().Get(inst_id); - if (!inst_const_id.is_valid() || !inst_const_id.is_symbolic()) { - return TryResolveInstCanonical(inst_id, const_id); - } - - // Try to import the generic. This might add new work. - const auto& symbolic_const = - import_ir_.constant_values().GetSymbolicConstant(inst_const_id); - auto generic_const_id = GetLocalConstantId(symbolic_const.generic_id); + }; +} - auto inner_const_id = SemIR::ConstantId::Invalid; - if (const_id.is_valid()) { - // For the third phase, extract the constant value that - // TryResolveInstCanonical produced previously. - inner_const_id = context_.constant_values().Get( - context_.constant_values().GetSymbolicConstant(const_id).inst_id); - } - - // Import the constant and rebuild the symbolic constant data. - auto result = TryResolveInstCanonical(inst_id, inner_const_id); - if (!result.const_id.is_valid()) { - // First phase: TryResolveInstCanoncial needs a retry. - return result; - } - - if (!const_id.is_valid()) { - // Second phase: we have created an abstract constant. Create a - // corresponding generic constant. - if (symbolic_const.generic_id.is_valid()) { - result.const_id = context_.constant_values().AddSymbolicConstant( - {.inst_id = context_.constant_values().GetInstId(result.const_id), - .generic_id = GetLocalGenericId(generic_const_id), - .index = symbolic_const.index}); - } - } else { - // Third phase: perform a consistency check and produce the constant we - // created in the second phase. - CARBON_CHECK(result.const_id == inner_const_id, - "Constant value changed in third phase."); - result.const_id = const_id; - } - - return result; +// Adds ImportRefUnloaded entries for members of the imported scope, for name +// lookup. +static auto AddNameScopeImportRefs(ImportContext& context, + const SemIR::NameScope& import_scope, + SemIR::NameScope& new_scope) -> void { + for (auto entry : import_scope.names) { + auto ref_id = AddImportRef(context, entry.inst_id); + new_scope.AddRequired({.name_id = GetLocalNameId(context, entry.name_id), + .inst_id = ref_id, + .access_kind = entry.access_kind}); } - - // Tries to resolve the InstId, returning a canonical constant when ready, or - // Invalid if more has been added to the stack. This is the same as - // TryResolveInst, except that it may resolve symbolic constants as canonical - // constants instead of as constants associated with a particular generic. - auto TryResolveInstCanonical(SemIR::InstId inst_id, - SemIR::ConstantId const_id) -> ResolveResult { - if (inst_id.is_builtin()) { - CARBON_CHECK(!const_id.is_valid()); - // Constants for builtins can be directly copied. - return ResolveAsConstant(context_.constant_values().Get(inst_id)); - } - - auto untyped_inst = import_ir_.insts().Get(inst_id); - CARBON_KIND_SWITCH(untyped_inst) { - case CARBON_KIND(SemIR::AssociatedEntity inst): { - return TryResolveTypedInst(inst); - } - case CARBON_KIND(SemIR::AssociatedEntityType inst): { - return TryResolveTypedInst(inst); - } - case CARBON_KIND(SemIR::BaseDecl inst): { - return TryResolveTypedInst(inst, inst_id); - } - case CARBON_KIND(SemIR::BindAlias inst): { - return TryResolveTypedInst(inst); - } - case SemIR::BindName::Kind: { - // TODO: Should we be resolving BindNames at all? - return ResolveAsConstant(SemIR::ConstantId::NotConstant); - } - case CARBON_KIND(SemIR::BindSymbolicName inst): { - return TryResolveTypedInst(inst); - } - case CARBON_KIND(SemIR::ClassDecl inst): { - return TryResolveTypedInst(inst, const_id); - } - case CARBON_KIND(SemIR::ClassType inst): { - return TryResolveTypedInst(inst); - } - case CARBON_KIND(SemIR::CompleteTypeWitness inst): { - return TryResolveTypedInst(inst); - } - case CARBON_KIND(SemIR::ConstType inst): { - return TryResolveTypedInst(inst); - } - case CARBON_KIND(SemIR::ExportDecl inst): { - return TryResolveTypedInst(inst); - } - case CARBON_KIND(SemIR::FacetAccessType inst): { - return TryResolveTypedInst(inst); - } - case CARBON_KIND(SemIR::FacetType inst): { - return TryResolveTypedInst(inst); - } - case CARBON_KIND(SemIR::FacetValue inst): { - return TryResolveTypedInst(inst); - } - case CARBON_KIND(SemIR::FieldDecl inst): { - return TryResolveTypedInst(inst, inst_id); - } - case CARBON_KIND(SemIR::FunctionDecl inst): { - return TryResolveTypedInst(inst, const_id); - } - case CARBON_KIND(SemIR::FunctionType inst): { - return TryResolveTypedInst(inst); - } - case CARBON_KIND(SemIR::GenericClassType inst): { - return TryResolveTypedInst(inst); - } - case CARBON_KIND(SemIR::GenericInterfaceType inst): { - return TryResolveTypedInst(inst); - } - case CARBON_KIND(SemIR::ImplDecl inst): { - return TryResolveTypedInst(inst, const_id); - } - case CARBON_KIND(SemIR::ImportRefLoaded inst): { - return TryResolveTypedInst(inst, inst_id); - } - case CARBON_KIND(SemIR::InterfaceDecl inst): { - return TryResolveTypedInst(inst, const_id); - } - case CARBON_KIND(SemIR::InterfaceWitness inst): { - return TryResolveTypedInst(inst); - } - case CARBON_KIND(SemIR::IntValue inst): { - return TryResolveTypedInst(inst); - } - case CARBON_KIND(SemIR::IntType inst): { - return TryResolveTypedInst(inst); - } - case CARBON_KIND(SemIR::PointerType inst): { - return TryResolveTypedInst(inst); - } - case CARBON_KIND(SemIR::SpecificFunction inst): { - return TryResolveTypedInst(inst); - } - case CARBON_KIND(SemIR::SymbolicBindingPattern inst): { - return TryResolveTypedInst(inst); - } - case CARBON_KIND(SemIR::StructType inst): { - return TryResolveTypedInst(inst); - } - case CARBON_KIND(SemIR::StructValue inst): { - return TryResolveTypedInst(inst); - } - case CARBON_KIND(SemIR::TupleType inst): { - return TryResolveTypedInst(inst); - } - case CARBON_KIND(SemIR::TupleValue inst): { - return TryResolveTypedInst(inst); - } - case CARBON_KIND(SemIR::UnboundElementType inst): { - return TryResolveTypedInst(inst); - } - default: { - // This instruction might have a constant value of a different kind. - auto constant_inst_id = - import_ir_.constant_values().GetConstantInstId(inst_id); - if (constant_inst_id == inst_id) { - context_.TODO( - SemIR::LocId(AddImportIRInst(inst_id)), - llvm::formatv("TryResolveInst on {0}", untyped_inst.kind()) - .str()); - return {.const_id = SemIR::ConstantId::Error}; - } - // Try to resolve the constant value instead. Note that this can only - // retry once. - CARBON_DCHECK(import_ir_.constant_values().GetConstantInstId( - constant_inst_id) == constant_inst_id, - "Constant value of constant instruction should refer to " - "the same instruction"); - return TryResolveInstCanonical(constant_inst_id, const_id); - } - } + for (auto scope_inst_id : import_scope.extended_scopes) { + new_scope.extended_scopes.push_back(AddImportRef(context, scope_inst_id)); } +} - // Produces a resolve result that tries resolving this instruction again. If - // `const_id` is specified, then this is the end of the second phase, and the - // constant value will be passed to the next resolution attempt. Otherwise, - // this is the end of the first phase. - auto Retry(SemIR::ConstantId const_id = SemIR::ConstantId::Invalid) - -> ResolveResult { - CARBON_CHECK(HasNewWork()); - return {.const_id = const_id, .retry = true}; - } +// Given a block ID for a list of associated entities of a witness, returns a +// version localized to the current IR. +static auto AddAssociatedEntities(ImportContext& context, + SemIR::InstBlockId associated_entities_id) + -> SemIR::InstBlockId { + if (associated_entities_id == SemIR::InstBlockId::Empty) { + return SemIR::InstBlockId::Empty; + } + auto associated_entities = + context.import_inst_blocks().Get(associated_entities_id); + llvm::SmallVector new_associated_entities; + new_associated_entities.reserve(associated_entities.size()); + for (auto inst_id : associated_entities) { + new_associated_entities.push_back(AddImportRef(context, inst_id)); + } + return context.local_inst_blocks().Add(new_associated_entities); +} - // Produces a resolve result that provides the given constant value. Requires - // that there is no new work. - auto ResolveAsConstant(SemIR::ConstantId const_id) -> ResolveResult { - CARBON_CHECK(!HasNewWork()); - return {.const_id = const_id}; +// Produces a resolve result that provides the given constant value. Retries +// instead if work has been added. +static auto RetryOrDone(ImportRefResolver& resolver, SemIR::ConstantId const_id) + -> ResolveResult { + if (resolver.HasNewWork()) { + return ResolveResult::Retry(); } + return ResolveResult::Done(const_id); +} - // Produces a resolve result that provides the given constant value. Retries - // instead if work has been added. - auto RetryOrResolveAsConstant(SemIR::ConstantId const_id) -> ResolveResult { - if (HasNewWork()) { - return Retry(); - } - return ResolveAsConstant(const_id); - } +// Produces a resolve result for the given instruction that describes a constant +// value. This should only be used for instructions that describe constants, and +// not for instructions that represent declarations. For a declaration, we need +// an associated location, so AddInstInNoBlock should be used instead. Requires +// that there is no new work. +static auto ResolveAsUntyped(ImportContext& context, SemIR::Inst inst) + -> ResolveResult { + auto result = + TryEvalInst(context.local_context(), SemIR::InstId::Invalid, inst); + CARBON_CHECK(result.is_constant(), "{0} is not constant", inst); + return ResolveResult::Done(result); +} - // Produces a resolve result for the given instruction that describes a - // constant value. This should only be used for instructions that describe - // constants, and not for instructions that represent declarations. For a - // declaration, we need an associated location, so AddInstInNoBlock should be - // used instead. Requires that there is no new work. - auto ResolveAsUntyped(SemIR::Inst inst) -> ResolveResult { - CARBON_CHECK(!HasNewWork()); - auto result = TryEvalInst(context_, SemIR::InstId::Invalid, inst); - CARBON_CHECK(result.is_constant(), "{0} is not constant", inst); - return {.const_id = result}; - } +// Same as ResolveAsUntyped, but with an explicit type for convenience. +template +static auto ResolveAs(ImportContext& context, InstT inst) -> ResolveResult { + return ResolveAsUntyped(context, inst); +} - // Same as ResolveAsUntyped, but with an explicit type for convenience. - template - auto ResolveAs(InstT inst) -> ResolveResult { - return ResolveAsUntyped(inst); +static auto TryResolveTypedInst(ImportRefResolver& resolver, + SemIR::AssociatedEntity inst) -> ResolveResult { + auto type_const_id = GetLocalConstantId(resolver, inst.type_id); + if (resolver.HasNewWork()) { + return ResolveResult::Retry(); } - auto TryResolveTypedInst(SemIR::AssociatedEntity inst) -> ResolveResult { - auto type_const_id = GetLocalConstantId(inst.type_id); - if (HasNewWork()) { - return Retry(); - } + // Add a lazy reference to the target declaration. + auto decl_id = AddImportRef(resolver, inst.decl_id); - // Add a lazy reference to the target declaration. - auto decl_id = AddImportRef( - context_, {.ir_id = import_ir_id_, .inst_id = inst.decl_id}); + return ResolveAs( + resolver, {.type_id = resolver.local_context().GetTypeIdForTypeConstant( + type_const_id), + .index = inst.index, + .decl_id = decl_id}); +} - return ResolveAs( - {.type_id = context_.GetTypeIdForTypeConstant(type_const_id), - .index = inst.index, - .decl_id = decl_id}); - } +static auto TryResolveTypedInst(ImportRefResolver& resolver, + SemIR::AssociatedEntityType inst) + -> ResolveResult { + CARBON_CHECK(inst.type_id == SemIR::TypeId::TypeType); - auto TryResolveTypedInst(SemIR::AssociatedEntityType inst) -> ResolveResult { - CARBON_CHECK(inst.type_id == SemIR::TypeId::TypeType); + auto entity_type_const_id = GetLocalConstantId(resolver, inst.entity_type_id); + auto interface_inst_id = GetLocalConstantId(resolver, inst.interface_type_id); + if (resolver.HasNewWork()) { + return ResolveResult::Retry(); + } - auto entity_type_const_id = GetLocalConstantId(inst.entity_type_id); - auto interface_inst_id = GetLocalConstantId(inst.interface_type_id); - if (HasNewWork()) { - return Retry(); - } + return ResolveAs( + resolver, + {.type_id = SemIR::TypeId::TypeType, + .interface_type_id = + resolver.local_context().GetTypeIdForTypeConstant(interface_inst_id), + .entity_type_id = resolver.local_context().GetTypeIdForTypeConstant( + entity_type_const_id)}); +} - return ResolveAs( - {.type_id = SemIR::TypeId::TypeType, - .interface_type_id = - context_.GetTypeIdForTypeConstant(interface_inst_id), - .entity_type_id = - context_.GetTypeIdForTypeConstant(entity_type_const_id)}); - } +static auto TryResolveTypedInst(ImportRefResolver& resolver, + SemIR::BaseDecl inst, + SemIR::InstId import_inst_id) -> ResolveResult { + auto type_const_id = GetLocalConstantId(resolver, inst.type_id); + auto base_type_const_id = GetLocalConstantId(resolver, inst.base_type_id); + if (resolver.HasNewWork()) { + return ResolveResult::Retry(); + } + + // Import the instruction in order to update contained base_type_id and + // track the import location. + auto inst_id = resolver.local_context().AddInstInNoBlock( + resolver.local_context().MakeImportedLocAndInst( + AddImportIRInst(resolver, import_inst_id), + {.type_id = + resolver.local_context().GetTypeIdForTypeConstant(type_const_id), + .base_type_id = resolver.local_context().GetTypeIdForTypeConstant( + base_type_const_id), + .index = inst.index})); + return ResolveResult::Done(resolver.local_constant_values().Get(inst_id)); +} - auto TryResolveTypedInst(SemIR::BaseDecl inst, SemIR::InstId import_inst_id) - -> ResolveResult { - auto type_const_id = GetLocalConstantId(inst.type_id); - auto base_type_const_id = GetLocalConstantId(inst.base_type_id); - if (HasNewWork()) { - return Retry(); - } +static auto TryResolveTypedInst(ImportRefResolver& resolver, + SemIR::BindAlias inst) -> ResolveResult { + auto value_id = GetLocalConstantId(resolver, inst.value_id); + return RetryOrDone(resolver, value_id); +} - // Import the instruction in order to update contained base_type_id and - // track the import location. - auto inst_id = context_.AddInstInNoBlock( - context_.MakeImportedLocAndInst( - AddImportIRInst(import_inst_id), - {.type_id = context_.GetTypeIdForTypeConstant(type_const_id), - .base_type_id = - context_.GetTypeIdForTypeConstant(base_type_const_id), - .index = inst.index})); - return ResolveAsConstant(context_.constant_values().Get(inst_id)); - } +static auto TryResolveTypedInst(ImportRefResolver& resolver, + SemIR::BindSymbolicName inst) -> ResolveResult { + auto type_id = GetLocalConstantId(resolver, inst.type_id); + if (resolver.HasNewWork()) { + return ResolveResult::Retry(); + } + + const auto& import_entity_name = + resolver.import_entity_names().Get(inst.entity_name_id); + auto name_id = GetLocalNameId(resolver, import_entity_name.name_id); + auto entity_name_id = resolver.local_entity_names().Add( + {.name_id = name_id, + .parent_scope_id = SemIR::NameScopeId::Invalid, + .bind_index = import_entity_name.bind_index}); + return ResolveAs( + resolver, + {.type_id = resolver.local_context().GetTypeIdForTypeConstant(type_id), + .entity_name_id = entity_name_id, + .value_id = SemIR::InstId::Invalid}); +} - auto TryResolveTypedInst(SemIR::BindAlias inst) -> ResolveResult { - auto value_id = GetLocalConstantId(inst.value_id); - return RetryOrResolveAsConstant(value_id); - } +static auto TryResolveTypedInst(ImportRefResolver& resolver, + SemIR::SymbolicBindingPattern inst) + -> ResolveResult { + auto type_id = GetLocalConstantId(resolver, inst.type_id); + if (resolver.HasNewWork()) { + return ResolveResult::Retry(); + } + + const auto& import_entity_name = + resolver.import_entity_names().Get(inst.entity_name_id); + auto name_id = GetLocalNameId(resolver, import_entity_name.name_id); + auto entity_name_id = resolver.local_entity_names().Add( + {.name_id = name_id, + .parent_scope_id = SemIR::NameScopeId::Invalid, + .bind_index = import_entity_name.bind_index}); + return ResolveAs( + resolver, + {.type_id = resolver.local_context().GetTypeIdForTypeConstant(type_id), + .entity_name_id = entity_name_id}); +} - auto TryResolveTypedInst(SemIR::BindSymbolicName inst) -> ResolveResult { - auto type_id = GetLocalConstantId(inst.type_id); - if (HasNewWork()) { - return Retry(); - } +// Makes an incomplete class. This is necessary even with classes with a +// complete declaration, because things such as `Self` may refer back to the +// type. +static auto MakeIncompleteClass(ImportContext& context, + const SemIR::Class& import_class, + SemIR::SpecificId enclosing_specific_id) + -> std::pair { + SemIR::ClassDecl class_decl = {.type_id = SemIR::TypeId::TypeType, + .class_id = SemIR::ClassId::Invalid, + .decl_block_id = SemIR::InstBlockId::Empty}; + auto class_decl_id = context.local_context().AddPlaceholderInstInNoBlock( + context.local_context().MakeImportedLocAndInst( + AddImportIRInst(context, import_class.latest_decl_id()), class_decl)); + // Regardless of whether ClassDecl is a complete type, we first need an + // incomplete type so that any references have something to point at. + class_decl.class_id = context.local_classes().Add( + {GetIncompleteLocalEntityBase(context, class_decl_id, import_class), + {.self_type_id = SemIR::TypeId::Invalid, + .inheritance_kind = import_class.inheritance_kind, + .is_dynamic = import_class.is_dynamic}}); + + if (import_class.has_parameters()) { + class_decl.type_id = context.local_context().GetGenericClassType( + class_decl.class_id, enclosing_specific_id); + } + + // Write the class ID into the ClassDecl. + context.local_context().ReplaceInstBeforeConstantUse(class_decl_id, + class_decl); + auto self_const_id = context.local_constant_values().Get(class_decl_id); + return {class_decl.class_id, self_const_id}; +} - const auto& import_entity_name = - import_ir_.entity_names().Get(inst.entity_name_id); - auto name_id = GetLocalNameId(import_entity_name.name_id); - auto entity_name_id = context_.entity_names().Add( - {.name_id = name_id, - .parent_scope_id = SemIR::NameScopeId::Invalid, - .bind_index = import_entity_name.bind_index}); - return ResolveAs( - {.type_id = context_.GetTypeIdForTypeConstant(type_id), - .entity_name_id = entity_name_id, - .value_id = SemIR::InstId::Invalid}); - } +// Fills out the class definition for an incomplete class. +static auto AddClassDefinition(ImportContext& context, + const SemIR::Class& import_class, + SemIR::Class& new_class, + SemIR::InstId complete_type_witness_id, + SemIR::InstId base_id) -> void { + new_class.definition_id = new_class.first_owning_decl_id; - auto TryResolveTypedInst(SemIR::SymbolicBindingPattern inst) - -> ResolveResult { - auto type_id = GetLocalConstantId(inst.type_id); - if (HasNewWork()) { - return Retry(); - } - - const auto& import_entity_name = - import_ir_.entity_names().Get(inst.entity_name_id); - auto name_id = GetLocalNameId(import_entity_name.name_id); - auto entity_name_id = context_.entity_names().Add( - {.name_id = name_id, - .parent_scope_id = SemIR::NameScopeId::Invalid, - .bind_index = import_entity_name.bind_index}); - return ResolveAs( - {.type_id = context_.GetTypeIdForTypeConstant(type_id), - .entity_name_id = entity_name_id}); - } - - // Makes an incomplete class. This is necessary even with classes with a - // complete declaration, because things such as `Self` may refer back to the - // type. - auto MakeIncompleteClass(const SemIR::Class& import_class, - SemIR::SpecificId enclosing_specific_id) - -> std::pair { - SemIR::ClassDecl class_decl = {.type_id = SemIR::TypeId::TypeType, - .class_id = SemIR::ClassId::Invalid, - .decl_block_id = SemIR::InstBlockId::Empty}; - auto class_decl_id = - context_.AddPlaceholderInstInNoBlock(context_.MakeImportedLocAndInst( - AddImportIRInst(import_class.latest_decl_id()), class_decl)); - // Regardless of whether ClassDecl is a complete type, we first need an - // incomplete type so that any references have something to point at. - class_decl.class_id = context_.classes().Add( - {GetIncompleteLocalEntityBase(class_decl_id, import_class), - {.self_type_id = SemIR::TypeId::Invalid, - .inheritance_kind = import_class.inheritance_kind, - .is_dynamic = import_class.is_dynamic}}); - - if (import_class.has_parameters()) { - class_decl.type_id = context_.GetGenericClassType(class_decl.class_id, - enclosing_specific_id); - } - - // Write the class ID into the ClassDecl. - context_.ReplaceInstBeforeConstantUse(class_decl_id, class_decl); - auto self_const_id = context_.constant_values().Get(class_decl_id); - return {class_decl.class_id, self_const_id}; - } - - // Fills out the class definition for an incomplete class. - auto AddClassDefinition(const SemIR::Class& import_class, - SemIR::Class& new_class, - SemIR::InstId complete_type_witness_id, - SemIR::InstId base_id) -> void { - new_class.definition_id = new_class.first_owning_decl_id; - - new_class.complete_type_witness_id = complete_type_witness_id; - - new_class.scope_id = context_.name_scopes().Add( - new_class.first_owning_decl_id, SemIR::NameId::Invalid, - new_class.parent_scope_id); - auto& new_scope = context_.name_scopes().Get(new_class.scope_id); - const auto& import_scope = - import_ir_.name_scopes().Get(import_class.scope_id); - - // Push a block so that we can add scoped instructions to it. - context_.inst_block_stack().Push(); - AddNameScopeImportRefs(import_scope, new_scope); - new_class.body_block_id = context_.inst_block_stack().Pop(); - - if (import_class.base_id.is_valid()) { - new_class.base_id = base_id; - } - } - - auto TryResolveTypedInst(SemIR::ClassDecl inst, - SemIR::ConstantId class_const_id) -> ResolveResult { - // TODO: The handling of interfaces repeats a lot with the handling of - // classes, and will likely also be repeated for named constraints and - // choice types. Factor out some of this functionality. - const auto& import_class = import_ir_.classes().Get(inst.class_id); - - SemIR::ClassId class_id = SemIR::ClassId::Invalid; - if (!class_const_id.is_valid()) { - auto import_specific_id = SemIR::SpecificId::Invalid; - if (auto import_generic_class_type = - import_ir_.types().TryGetAs( - inst.type_id)) { - import_specific_id = import_generic_class_type->enclosing_specific_id; - } - auto specific_data = GetLocalSpecificData(import_specific_id); - if (HasNewWork()) { - // This is the end of the first phase. Don't make a new class yet if - // we already have new work. - return Retry(); - } + new_class.complete_type_witness_id = complete_type_witness_id; - // On the second phase, create a forward declaration of the class for any - // recursive references. - auto enclosing_specific_id = - GetOrAddLocalSpecific(import_specific_id, specific_data); - std::tie(class_id, class_const_id) = - MakeIncompleteClass(import_class, enclosing_specific_id); - } else { - // On the third phase, compute the class ID from the constant - // value of the declaration. - auto class_const_inst = context_.insts().Get( - context_.constant_values().GetInstId(class_const_id)); - if (auto class_type = class_const_inst.TryAs()) { - class_id = class_type->class_id; - } else { - auto generic_class_type = - context_.types().GetAs( - class_const_inst.type_id()); - class_id = generic_class_type.class_id; - } - } + new_class.scope_id = context.local_name_scopes().Add( + new_class.first_owning_decl_id, SemIR::NameId::Invalid, + new_class.parent_scope_id); + auto& new_scope = context.local_name_scopes().Get(new_class.scope_id); + const auto& import_scope = + context.import_name_scopes().Get(import_class.scope_id); - // Load constants for the definition. - auto parent_scope_id = GetLocalNameScopeId(import_class.parent_scope_id); - LoadLocalPatternConstantIds(import_class.implicit_param_patterns_id); - LoadLocalPatternConstantIds(import_class.param_patterns_id); - auto generic_data = GetLocalGenericData(import_class.generic_id); - auto self_const_id = GetLocalConstantId(import_class.self_type_id); - auto complete_type_witness_id = - import_class.complete_type_witness_id.is_valid() - ? GetLocalConstantInstId(import_class.complete_type_witness_id) - : SemIR::InstId::Invalid; - auto base_id = import_class.base_id.is_valid() - ? GetLocalConstantInstId(import_class.base_id) - : SemIR::InstId::Invalid; - - if (HasNewWork()) { - return Retry(class_const_id); - } - - auto& new_class = context_.classes().Get(class_id); - new_class.parent_scope_id = parent_scope_id; - new_class.implicit_param_patterns_id = - GetLocalParamPatternsId(import_class.implicit_param_patterns_id); - new_class.param_patterns_id = - GetLocalParamPatternsId(import_class.param_patterns_id); - SetGenericData(import_class.generic_id, new_class.generic_id, generic_data); - new_class.self_type_id = context_.GetTypeIdForTypeConstant(self_const_id); - - if (import_class.is_defined()) { - AddClassDefinition(import_class, new_class, complete_type_witness_id, - base_id); - } - - return ResolveAsConstant(class_const_id); - } - - auto TryResolveTypedInst(SemIR::ClassType inst) -> ResolveResult { - CARBON_CHECK(inst.type_id == SemIR::TypeId::TypeType); - auto class_const_id = GetLocalConstantId( - import_ir_.classes().Get(inst.class_id).first_owning_decl_id); - auto specific_data = GetLocalSpecificData(inst.specific_id); - if (HasNewWork()) { - return Retry(); - } - - // Find the corresponding class type. For a non-generic class, this is the - // type of the class declaration. For a generic class, build a class type - // referencing this specialization of the generic class. - auto class_const_inst = context_.insts().Get( - context_.constant_values().GetInstId(class_const_id)); - if (class_const_inst.Is()) { - return ResolveAsConstant(class_const_id); - } else { - auto generic_class_type = context_.types().GetAs( - class_const_inst.type_id()); - auto specific_id = GetOrAddLocalSpecific(inst.specific_id, specific_data); - return ResolveAs( - {.type_id = SemIR::TypeId::TypeType, - .class_id = generic_class_type.class_id, - .specific_id = specific_id}); - } - } + // Push a block so that we can add scoped instructions to it. + context.local_context().inst_block_stack().Push(); + AddNameScopeImportRefs(context, import_scope, new_scope); + new_class.body_block_id = context.local_context().inst_block_stack().Pop(); - auto TryResolveTypedInst(SemIR::CompleteTypeWitness inst) -> ResolveResult { - CARBON_CHECK(import_ir_.types().GetInstId(inst.type_id) == - SemIR::InstId::BuiltinWitnessType); - auto object_repr_const_id = GetLocalConstantId(inst.object_repr_id); - if (HasNewWork()) { - return Retry(); - } - auto object_repr_id = - context_.GetTypeIdForTypeConstant(object_repr_const_id); - return ResolveAs( - {.type_id = - context_.GetBuiltinType(SemIR::BuiltinInstKind::WitnessType), - .object_repr_id = object_repr_id}); + if (import_class.base_id.is_valid()) { + new_class.base_id = base_id; } +} - auto TryResolveTypedInst(SemIR::ConstType inst) -> ResolveResult { - CARBON_CHECK(inst.type_id == SemIR::TypeId::TypeType); - auto inner_const_id = GetLocalConstantId(inst.inner_id); - if (HasNewWork()) { - return Retry(); - } - auto inner_type_id = context_.GetTypeIdForTypeConstant(inner_const_id); - return ResolveAs( - {.type_id = SemIR::TypeId::TypeType, .inner_id = inner_type_id}); - } +static auto TryResolveTypedInst(ImportRefResolver& resolver, + SemIR::ClassDecl inst, + SemIR::ConstantId class_const_id) + -> ResolveResult { + // TODO: The handling of interfaces repeats a lot with the handling of + // classes, and will likely also be repeated for named constraints and + // choice types. Factor out some of this functionality. + const auto& import_class = resolver.import_classes().Get(inst.class_id); + + SemIR::ClassId class_id = SemIR::ClassId::Invalid; + if (!class_const_id.is_valid()) { + auto import_specific_id = SemIR::SpecificId::Invalid; + if (auto import_generic_class_type = + resolver.import_types().TryGetAs( + inst.type_id)) { + import_specific_id = import_generic_class_type->enclosing_specific_id; + } + auto specific_data = GetLocalSpecificData(resolver, import_specific_id); + if (resolver.HasNewWork()) { + // This is the end of the first phase. Don't make a new class yet if + // we already have new work. + return ResolveResult::Retry(); + } + + // On the second phase, create a forward declaration of the class for any + // recursive references. + auto enclosing_specific_id = + GetOrAddLocalSpecific(resolver, import_specific_id, specific_data); + std::tie(class_id, class_const_id) = + MakeIncompleteClass(resolver, import_class, enclosing_specific_id); + } else { + // On the third phase, compute the class ID from the constant + // value of the declaration. + auto class_const_inst = resolver.local_insts().Get( + resolver.local_constant_values().GetInstId(class_const_id)); + if (auto class_type = class_const_inst.TryAs()) { + class_id = class_type->class_id; + } else { + auto generic_class_type = + resolver.local_types().GetAs( + class_const_inst.type_id()); + class_id = generic_class_type.class_id; + } + } + + // Load constants for the definition. + auto parent_scope_id = + GetLocalNameScopeId(resolver, import_class.parent_scope_id); + LoadLocalPatternConstantIds(resolver, + import_class.implicit_param_patterns_id); + LoadLocalPatternConstantIds(resolver, import_class.param_patterns_id); + auto generic_data = GetLocalGenericData(resolver, import_class.generic_id); + auto self_const_id = GetLocalConstantId(resolver, import_class.self_type_id); + auto complete_type_witness_id = + import_class.complete_type_witness_id.is_valid() + ? GetLocalConstantInstId(resolver, + import_class.complete_type_witness_id) + : SemIR::InstId::Invalid; + auto base_id = import_class.base_id.is_valid() + ? GetLocalConstantInstId(resolver, import_class.base_id) + : SemIR::InstId::Invalid; + + if (resolver.HasNewWork()) { + return ResolveResult::Retry(class_const_id); + } + + auto& new_class = resolver.local_classes().Get(class_id); + new_class.parent_scope_id = parent_scope_id; + new_class.implicit_param_patterns_id = GetLocalParamPatternsId( + resolver, import_class.implicit_param_patterns_id); + new_class.param_patterns_id = + GetLocalParamPatternsId(resolver, import_class.param_patterns_id); + SetGenericData(resolver, import_class.generic_id, new_class.generic_id, + generic_data); + new_class.self_type_id = + resolver.local_context().GetTypeIdForTypeConstant(self_const_id); + + if (import_class.is_defined()) { + AddClassDefinition(resolver, import_class, new_class, + complete_type_witness_id, base_id); + } + + return ResolveResult::Done(class_const_id); +} - auto TryResolveTypedInst(SemIR::ExportDecl inst) -> ResolveResult { - auto value_id = GetLocalConstantId(inst.value_id); - return RetryOrResolveAsConstant(value_id); +static auto TryResolveTypedInst(ImportRefResolver& resolver, + SemIR::ClassType inst) -> ResolveResult { + CARBON_CHECK(inst.type_id == SemIR::TypeId::TypeType); + auto class_const_id = GetLocalConstantId( + resolver, + resolver.import_classes().Get(inst.class_id).first_owning_decl_id); + auto specific_data = GetLocalSpecificData(resolver, inst.specific_id); + if (resolver.HasNewWork()) { + return ResolveResult::Retry(); + } + + // Find the corresponding class type. For a non-generic class, this is the + // type of the class declaration. For a generic class, build a class type + // referencing this specialization of the generic class. + auto class_const_inst = resolver.local_insts().Get( + resolver.local_constant_values().GetInstId(class_const_id)); + if (class_const_inst.Is()) { + return ResolveResult::Done(class_const_id); + } else { + auto generic_class_type = + resolver.local_types().GetAs( + class_const_inst.type_id()); + auto specific_id = + GetOrAddLocalSpecific(resolver, inst.specific_id, specific_data); + return ResolveAs(resolver, + {.type_id = SemIR::TypeId::TypeType, + .class_id = generic_class_type.class_id, + .specific_id = specific_id}); } +} - auto TryResolveTypedInst(SemIR::FieldDecl inst, SemIR::InstId import_inst_id) - -> ResolveResult { - auto const_id = GetLocalConstantId(inst.type_id); - if (HasNewWork()) { - return Retry(); - } - auto inst_id = context_.AddInstInNoBlock( - context_.MakeImportedLocAndInst( - AddImportIRInst(import_inst_id), - {.type_id = context_.GetTypeIdForTypeConstant(const_id), - .name_id = GetLocalNameId(inst.name_id), - .index = inst.index})); - return {.const_id = context_.constant_values().Get(inst_id)}; - } - - // Make a declaration of a function. This is done as a separate step from - // importing the function declaration in order to resolve cycles. - auto MakeFunctionDecl(const SemIR::Function& import_function, - SemIR::SpecificId specific_id) - -> std::pair { - SemIR::FunctionDecl function_decl = { - .type_id = SemIR::TypeId::Invalid, - .function_id = SemIR::FunctionId::Invalid, - .decl_block_id = SemIR::InstBlockId::Empty}; - auto function_decl_id = - context_.AddPlaceholderInstInNoBlock(context_.MakeImportedLocAndInst( - AddImportIRInst(import_function.first_decl_id()), function_decl)); - - // Start with an incomplete function. - function_decl.function_id = context_.functions().Add( - {GetIncompleteLocalEntityBase(function_decl_id, import_function), - {.return_slot_pattern_id = SemIR::InstId::Invalid, - .return_slot_id = SemIR::InstId::Invalid, - .builtin_function_kind = import_function.builtin_function_kind}}); - - function_decl.type_id = - context_.GetFunctionType(function_decl.function_id, specific_id); - - // Write the function ID and type into the FunctionDecl. - context_.ReplaceInstBeforeConstantUse(function_decl_id, function_decl); - return {function_decl.function_id, - context_.constant_values().Get(function_decl_id)}; - } - - auto TryResolveTypedInst(SemIR::FunctionDecl inst, - SemIR::ConstantId function_const_id) - -> ResolveResult { - const auto& import_function = import_ir_.functions().Get(inst.function_id); - - SemIR::FunctionId function_id = SemIR::FunctionId::Invalid; - if (!function_const_id.is_valid()) { - auto import_specific_id = import_ir_.types() - .GetAs(inst.type_id) - .specific_id; - auto specific_data = GetLocalSpecificData(import_specific_id); - if (HasNewWork()) { - // This is the end of the first phase. Don't make a new function yet if - // we already have new work. - return Retry(); - } +static auto TryResolveTypedInst(ImportRefResolver& resolver, + SemIR::CompleteTypeWitness inst) + -> ResolveResult { + CARBON_CHECK(resolver.import_types().GetInstId(inst.type_id) == + SemIR::InstId::BuiltinWitnessType); + auto object_repr_const_id = GetLocalConstantId(resolver, inst.object_repr_id); + if (resolver.HasNewWork()) { + return ResolveResult::Retry(); + } + auto object_repr_id = + resolver.local_context().GetTypeIdForTypeConstant(object_repr_const_id); + return ResolveAs( + resolver, {.type_id = resolver.local_context().GetBuiltinType( + SemIR::BuiltinInstKind::WitnessType), + .object_repr_id = object_repr_id}); +} - // On the second phase, create a forward declaration of the interface. - auto specific_id = - GetOrAddLocalSpecific(import_specific_id, specific_data); - std::tie(function_id, function_const_id) = - MakeFunctionDecl(import_function, specific_id); - } else { - // On the third phase, compute the function ID from the constant value of - // the declaration. - auto function_const_inst = context_.insts().Get( - context_.constant_values().GetInstId(function_const_id)); - auto function_type = context_.types().GetAs( - function_const_inst.type_id()); - function_id = function_type.function_id; - } - - auto return_type_const_id = SemIR::ConstantId::Invalid; - if (import_function.return_slot_id.is_valid()) { - return_type_const_id = GetLocalConstantId( - import_ir_.insts().Get(import_function.return_slot_id).type_id()); - } - auto parent_scope_id = GetLocalNameScopeId(import_function.parent_scope_id); - LoadLocalPatternConstantIds(import_function.implicit_param_patterns_id); - LoadLocalPatternConstantIds(import_function.param_patterns_id); - auto generic_data = GetLocalGenericData(import_function.generic_id); - - if (HasNewWork()) { - return Retry(function_const_id); - } - - // Add the function declaration. - auto& new_function = context_.functions().Get(function_id); - new_function.parent_scope_id = parent_scope_id; - new_function.implicit_param_patterns_id = - GetLocalParamPatternsId(import_function.implicit_param_patterns_id); - new_function.param_patterns_id = - GetLocalParamPatternsId(import_function.param_patterns_id); - new_function.return_slot_pattern_id = - GetLocalReturnSlotPatternId(import_function.return_slot_pattern_id); - SetGenericData(import_function.generic_id, new_function.generic_id, - generic_data); - - if (import_function.return_slot_id.is_valid()) { - // Recreate the return slot from scratch. - // TODO: Once we import function definitions, we'll need to make sure we - // use the same return storage variable in the declaration and definition. - new_function.return_slot_id = - context_.AddInstInNoBlock( - AddImportIRInst(import_function.return_slot_id), - {.type_id = - context_.GetTypeIdForTypeConstant(return_type_const_id), - .name_id = SemIR::NameId::ReturnSlot}); - } - - if (import_function.definition_id.is_valid()) { - new_function.definition_id = new_function.first_owning_decl_id; - } - - return ResolveAsConstant(function_const_id); - } - - auto TryResolveTypedInst(SemIR::FunctionType inst) -> ResolveResult { - CARBON_CHECK(inst.type_id == SemIR::TypeId::TypeType); - auto fn_val_id = GetLocalConstantInstId( - import_ir_.functions().Get(inst.function_id).first_decl_id()); - auto specific_data = GetLocalSpecificData(inst.specific_id); - if (HasNewWork()) { - return Retry(); - } - auto fn_type_id = context_.insts().Get(fn_val_id).type_id(); - return ResolveAs( - {.type_id = SemIR::TypeId::TypeType, - .function_id = context_.types() - .GetAs(fn_type_id) - .function_id, - .specific_id = - GetOrAddLocalSpecific(inst.specific_id, specific_data)}); - } - - auto TryResolveTypedInst(SemIR::GenericClassType inst) -> ResolveResult { - CARBON_CHECK(inst.type_id == SemIR::TypeId::TypeType); - auto class_val_id = GetLocalConstantInstId( - import_ir_.classes().Get(inst.class_id).first_owning_decl_id); - if (HasNewWork()) { - return Retry(); - } - auto class_val = context_.insts().Get(class_val_id); - CARBON_CHECK( - context_.types().Is(class_val.type_id())); - return ResolveAsConstant( - context_.types().GetConstantId(class_val.type_id())); - } - - auto TryResolveTypedInst(SemIR::GenericInterfaceType inst) -> ResolveResult { - CARBON_CHECK(inst.type_id == SemIR::TypeId::TypeType); - auto interface_val_id = GetLocalConstantInstId( - import_ir_.interfaces().Get(inst.interface_id).first_owning_decl_id); - if (HasNewWork()) { - return Retry(); - } - auto interface_val = context_.insts().Get(interface_val_id); - CARBON_CHECK(context_.types().Is( - interface_val.type_id())); - return ResolveAsConstant( - context_.types().GetConstantId(interface_val.type_id())); - } - - // Make a declaration of an impl. This is done as a separate step from - // importing the impl definition in order to resolve cycles. - auto MakeImplDeclaration(const SemIR::Impl& import_impl) - -> std::pair { - SemIR::ImplDecl impl_decl = {.impl_id = SemIR::ImplId::Invalid, - .decl_block_id = SemIR::InstBlockId::Empty}; - auto impl_decl_id = - context_.AddPlaceholderInstInNoBlock(context_.MakeImportedLocAndInst( - AddImportIRInst(import_impl.latest_decl_id()), impl_decl)); - impl_decl.impl_id = context_.impls().Add( - {GetIncompleteLocalEntityBase(impl_decl_id, import_impl), - {.self_id = SemIR::InstId::Invalid, - .constraint_id = SemIR::InstId::Invalid, - .witness_id = SemIR::InstId::Invalid}}); - - // Write the impl ID into the ImplDecl. - context_.ReplaceInstBeforeConstantUse(impl_decl_id, impl_decl); - return {impl_decl.impl_id, context_.constant_values().Get(impl_decl_id)}; - } - - // Imports the definition of an impl. - auto AddImplDefinition(const SemIR::Impl& import_impl, SemIR::Impl& new_impl, - SemIR::InstId witness_id) -> void { - new_impl.definition_id = new_impl.first_owning_decl_id; - - new_impl.witness_id = witness_id; - - if (import_impl.scope_id.is_valid()) { - new_impl.scope_id = context_.name_scopes().Add( - new_impl.first_owning_decl_id, SemIR::NameId::Invalid, - new_impl.parent_scope_id); - // Import the contents of the definition scope, if we might need it. Name - // lookup is never performed into this scope by a user of the impl, so - // this is only necessary in the same library that defined the impl, in - // order to support defining members of the impl out of line in the impl - // file when the impl is defined in the API file. - // TODO: Check to see if this impl is owned by the API file, rather than - // merely being imported into it. - if (import_ir_id_ == SemIR::ImportIRId::ApiForImpl) { - auto& new_scope = context_.name_scopes().Get(new_impl.scope_id); - const auto& import_scope = - import_ir_.name_scopes().Get(import_impl.scope_id); - - // Push a block so that we can add scoped instructions to it. - context_.inst_block_stack().Push(); - AddNameScopeImportRefs(import_scope, new_scope); - new_impl.body_block_id = context_.inst_block_stack().Pop(); - } - } - } +static auto TryResolveTypedInst(ImportRefResolver& resolver, + SemIR::ConstType inst) -> ResolveResult { + CARBON_CHECK(inst.type_id == SemIR::TypeId::TypeType); + auto inner_const_id = GetLocalConstantId(resolver, inst.inner_id); + if (resolver.HasNewWork()) { + return ResolveResult::Retry(); + } + auto inner_type_id = + resolver.local_context().GetTypeIdForTypeConstant(inner_const_id); + return ResolveAs( + resolver, + {.type_id = SemIR::TypeId::TypeType, .inner_id = inner_type_id}); +} - auto TryResolveTypedInst(SemIR::ImplDecl inst, - SemIR::ConstantId impl_const_id) -> ResolveResult { - // TODO: This duplicates a lot of the handling of interfaces, classes, and - // functions. Factor out the commonality. - const auto& import_impl = import_ir_.impls().Get(inst.impl_id); +static auto TryResolveTypedInst(ImportRefResolver& resolver, + SemIR::ExportDecl inst) -> ResolveResult { + auto value_id = GetLocalConstantId(resolver, inst.value_id); + return RetryOrDone(resolver, value_id); +} - SemIR::ImplId impl_id = SemIR::ImplId::Invalid; - if (!impl_const_id.is_valid()) { - if (HasNewWork()) { - // This is the end of the first phase. Don't make a new impl yet if we - // already have new work. - return Retry(); - } +static auto TryResolveTypedInst(ImportRefResolver& resolver, + SemIR::FieldDecl inst, + SemIR::InstId import_inst_id) -> ResolveResult { + auto const_id = GetLocalConstantId(resolver, inst.type_id); + if (resolver.HasNewWork()) { + return ResolveResult::Retry(); + } + auto inst_id = resolver.local_context().AddInstInNoBlock( + resolver.local_context().MakeImportedLocAndInst( + AddImportIRInst(resolver, import_inst_id), + {.type_id = + resolver.local_context().GetTypeIdForTypeConstant(const_id), + .name_id = GetLocalNameId(resolver, inst.name_id), + .index = inst.index})); + return {.const_id = resolver.local_constant_values().Get(inst_id)}; +} - // On the second phase, create a forward declaration of the impl for any - // recursive references. - std::tie(impl_id, impl_const_id) = MakeImplDeclaration(import_impl); - } else { - // On the third phase, compute the impl ID from the "constant value" of - // the declaration, which is a reference to the created ImplDecl. - auto impl_const_inst = context_.insts().GetAs( - context_.constant_values().GetInstId(impl_const_id)); - impl_id = impl_const_inst.impl_id; - } - - // Load constants for the definition. - auto parent_scope_id = GetLocalNameScopeId(import_impl.parent_scope_id); - LoadLocalPatternConstantIds(import_impl.implicit_param_patterns_id); - auto generic_data = GetLocalGenericData(import_impl.generic_id); - auto self_const_id = GetLocalConstantId( - import_ir_.constant_values().Get(import_impl.self_id)); - auto constraint_const_id = GetLocalConstantId( - import_ir_.constant_values().Get(import_impl.constraint_id)); - - if (HasNewWork()) { - return Retry(impl_const_id); - } - - auto& new_impl = context_.impls().Get(impl_id); - new_impl.parent_scope_id = parent_scope_id; - new_impl.implicit_param_patterns_id = - GetLocalParamPatternsId(import_impl.implicit_param_patterns_id); - SetGenericData(import_impl.generic_id, new_impl.generic_id, generic_data); - - // Create instructions for self and constraint to hold the symbolic constant - // value for a generic impl. - new_impl.self_id = AddLoadedImportRef( - context_, {.ir_id = import_ir_id_, .inst_id = import_impl.self_id}, - SemIR::TypeId::TypeType, self_const_id); - new_impl.constraint_id = AddLoadedImportRef( - context_, - {.ir_id = import_ir_id_, .inst_id = import_impl.constraint_id}, - SemIR::TypeId::TypeType, constraint_const_id); - - if (import_impl.is_defined()) { - auto witness_id = AddImportRef( - context_, - {.ir_id = import_ir_id_, .inst_id = import_impl.witness_id}); - AddImplDefinition(import_impl, new_impl, witness_id); - } - - // If the `impl` is declared in the API file corresponding to the current - // file, add this to impl lookup so that it can be found by redeclarations - // in the current file. - if (import_ir_id_ == SemIR::ImportIRId::ApiForImpl) { - context_.impls().GetOrAddLookupBucket(new_impl).push_back(impl_id); - } - - return ResolveAsConstant(impl_const_id); - } - - auto TryResolveTypedInst(SemIR::ImportRefLoaded /*inst*/, - SemIR::InstId inst_id) -> ResolveResult { - // Return the constant for the instruction of the imported constant. - auto constant_id = import_ir_.constant_values().Get(inst_id); - if (!constant_id.is_valid()) { - return ResolveAsConstant(SemIR::ConstantId::Error); - } - if (!constant_id.is_constant()) { - context_.TODO(inst_id, - "Non-constant ImportRefLoaded (comes up with var)"); - return ResolveAsConstant(SemIR::ConstantId::Error); - } - - auto new_constant_id = - GetLocalConstantId(import_ir_.constant_values().GetInstId(constant_id)); - return RetryOrResolveAsConstant(new_constant_id); - } - - // Make a declaration of an interface. This is done as a separate step from - // importing the interface definition in order to resolve cycles. - auto MakeInterfaceDecl(const SemIR::Interface& import_interface, - SemIR::SpecificId enclosing_specific_id) - -> std::pair { - SemIR::InterfaceDecl interface_decl = { - .type_id = SemIR::TypeId::TypeType, - .interface_id = SemIR::InterfaceId::Invalid, - .decl_block_id = SemIR::InstBlockId::Empty}; - auto interface_decl_id = - context_.AddPlaceholderInstInNoBlock(context_.MakeImportedLocAndInst( - AddImportIRInst(import_interface.first_owning_decl_id), - interface_decl)); - - // Start with an incomplete interface. - interface_decl.interface_id = context_.interfaces().Add( - {GetIncompleteLocalEntityBase(interface_decl_id, import_interface), - {}}); - - if (import_interface.has_parameters()) { - interface_decl.type_id = context_.GetGenericInterfaceType( - interface_decl.interface_id, enclosing_specific_id); - } - - // Write the interface ID into the InterfaceDecl. - context_.ReplaceInstBeforeConstantUse(interface_decl_id, interface_decl); - return {interface_decl.interface_id, - context_.constant_values().Get(interface_decl_id)}; - } - - // Imports the definition for an interface that has been imported as a forward - // declaration. - auto AddInterfaceDefinition(const SemIR::Interface& import_interface, - SemIR::Interface& new_interface, - SemIR::InstId self_param_id) -> void { - new_interface.scope_id = context_.name_scopes().Add( - new_interface.first_owning_decl_id, SemIR::NameId::Invalid, - new_interface.parent_scope_id); - auto& new_scope = context_.name_scopes().Get(new_interface.scope_id); - const auto& import_scope = - import_ir_.name_scopes().Get(import_interface.scope_id); - - // Push a block so that we can add scoped instructions to it. - context_.inst_block_stack().Push(); - AddNameScopeImportRefs(import_scope, new_scope); - new_interface.associated_entities_id = - AddAssociatedEntities(import_interface.associated_entities_id); - new_interface.body_block_id = context_.inst_block_stack().Pop(); - new_interface.self_param_id = self_param_id; - - CARBON_CHECK(import_scope.extended_scopes.empty(), - "Interfaces don't currently have extended scopes to support."); - } - - auto TryResolveTypedInst(SemIR::InterfaceDecl inst, - SemIR::ConstantId interface_const_id) - -> ResolveResult { - const auto& import_interface = - import_ir_.interfaces().Get(inst.interface_id); - - SemIR::InterfaceId interface_id = SemIR::InterfaceId::Invalid; - if (!interface_const_id.is_valid()) { - auto import_specific_id = SemIR::SpecificId::Invalid; - if (auto import_generic_interface_type = - import_ir_.types().TryGetAs( - inst.type_id)) { - import_specific_id = - import_generic_interface_type->enclosing_specific_id; - } - auto specific_data = GetLocalSpecificData(import_specific_id); - if (HasNewWork()) { - // This is the end of the first phase. Don't make a new interface yet if - // we already have new work. - return Retry(); - } +// Make a declaration of a function. This is done as a separate step from +// importing the function declaration in order to resolve cycles. +static auto MakeFunctionDecl(ImportContext& context, + const SemIR::Function& import_function, + SemIR::SpecificId specific_id) + -> std::pair { + SemIR::FunctionDecl function_decl = { + .type_id = SemIR::TypeId::Invalid, + .function_id = SemIR::FunctionId::Invalid, + .decl_block_id = SemIR::InstBlockId::Empty}; + auto function_decl_id = context.local_context().AddPlaceholderInstInNoBlock( + context.local_context().MakeImportedLocAndInst( + AddImportIRInst(context, import_function.first_decl_id()), + function_decl)); + + // Start with an incomplete function. + function_decl.function_id = context.local_functions().Add( + {GetIncompleteLocalEntityBase(context, function_decl_id, import_function), + {.return_slot_pattern_id = SemIR::InstId::Invalid, + .return_slot_id = SemIR::InstId::Invalid, + .builtin_function_kind = import_function.builtin_function_kind}}); + + function_decl.type_id = context.local_context().GetFunctionType( + function_decl.function_id, specific_id); + + // Write the function ID and type into the FunctionDecl. + context.local_context().ReplaceInstBeforeConstantUse(function_decl_id, + function_decl); + return {function_decl.function_id, + context.local_constant_values().Get(function_decl_id)}; +} - // On the second phase, create a forward declaration of the interface. - auto enclosing_specific_id = - GetOrAddLocalSpecific(import_specific_id, specific_data); - std::tie(interface_id, interface_const_id) = - MakeInterfaceDecl(import_interface, enclosing_specific_id); - } else { - // On the third phase, compute the interface ID from the constant value of - // the declaration. - auto interface_const_inst = context_.insts().Get( - context_.constant_values().GetInstId(interface_const_id)); - if (auto facet_type = interface_const_inst.TryAs()) { - const SemIR::FacetTypeInfo& facet_type_info = - context_.facet_types().Get(facet_type->facet_type_id); - auto interface_type = facet_type_info.TryAsSingleInterface(); - CARBON_CHECK(interface_type); - interface_id = interface_type->interface_id; - } else { - auto generic_interface_type = - context_.types().GetAs( - interface_const_inst.type_id()); - interface_id = generic_interface_type.interface_id; - } - } +static auto TryResolveTypedInst(ImportRefResolver& resolver, + SemIR::FunctionDecl inst, + SemIR::ConstantId function_const_id) + -> ResolveResult { + const auto& import_function = + resolver.import_functions().Get(inst.function_id); + + SemIR::FunctionId function_id = SemIR::FunctionId::Invalid; + if (!function_const_id.is_valid()) { + auto import_specific_id = resolver.import_types() + .GetAs(inst.type_id) + .specific_id; + auto specific_data = GetLocalSpecificData(resolver, import_specific_id); + if (resolver.HasNewWork()) { + // This is the end of the first phase. Don't make a new function yet if + // we already have new work. + return ResolveResult::Retry(); + } + + // On the second phase, create a forward declaration of the interface. + auto specific_id = + GetOrAddLocalSpecific(resolver, import_specific_id, specific_data); + std::tie(function_id, function_const_id) = + MakeFunctionDecl(resolver, import_function, specific_id); + } else { + // On the third phase, compute the function ID from the constant value of + // the declaration. + auto function_const_inst = resolver.local_insts().Get( + resolver.local_constant_values().GetInstId(function_const_id)); + auto function_type = resolver.local_types().GetAs( + function_const_inst.type_id()); + function_id = function_type.function_id; + } + + auto return_type_const_id = SemIR::ConstantId::Invalid; + if (import_function.return_slot_id.is_valid()) { + return_type_const_id = GetLocalConstantId( + resolver, + resolver.import_insts().Get(import_function.return_slot_id).type_id()); + } + auto parent_scope_id = + GetLocalNameScopeId(resolver, import_function.parent_scope_id); + LoadLocalPatternConstantIds(resolver, + import_function.implicit_param_patterns_id); + LoadLocalPatternConstantIds(resolver, import_function.param_patterns_id); + auto generic_data = GetLocalGenericData(resolver, import_function.generic_id); + + if (resolver.HasNewWork()) { + return ResolveResult::Retry(function_const_id); + } + + // Add the function declaration. + auto& new_function = resolver.local_functions().Get(function_id); + new_function.parent_scope_id = parent_scope_id; + new_function.implicit_param_patterns_id = GetLocalParamPatternsId( + resolver, import_function.implicit_param_patterns_id); + new_function.param_patterns_id = + GetLocalParamPatternsId(resolver, import_function.param_patterns_id); + new_function.return_slot_pattern_id = GetLocalReturnSlotPatternId( + resolver, import_function.return_slot_pattern_id); + SetGenericData(resolver, import_function.generic_id, new_function.generic_id, + generic_data); + + if (import_function.return_slot_id.is_valid()) { + // Recreate the return slot from scratch. + // TODO: Once we import function definitions, we'll need to make sure we + // use the same return storage variable in the declaration and definition. + new_function.return_slot_id = + resolver.local_context().AddInstInNoBlock( + AddImportIRInst(resolver, import_function.return_slot_id), + {.type_id = resolver.local_context().GetTypeIdForTypeConstant( + return_type_const_id), + .name_id = SemIR::NameId::ReturnSlot}); + } + + if (import_function.definition_id.is_valid()) { + new_function.definition_id = new_function.first_owning_decl_id; + } + + return ResolveResult::Done(function_const_id); +} - auto parent_scope_id = - GetLocalNameScopeId(import_interface.parent_scope_id); - LoadLocalPatternConstantIds(import_interface.implicit_param_patterns_id); - LoadLocalPatternConstantIds(import_interface.param_patterns_id); - auto generic_data = GetLocalGenericData(import_interface.generic_id); +static auto TryResolveTypedInst(ImportRefResolver& resolver, + SemIR::FunctionType inst) -> ResolveResult { + CARBON_CHECK(inst.type_id == SemIR::TypeId::TypeType); + auto fn_val_id = GetLocalConstantInstId( + resolver, + resolver.import_functions().Get(inst.function_id).first_decl_id()); + auto specific_data = GetLocalSpecificData(resolver, inst.specific_id); + if (resolver.HasNewWork()) { + return ResolveResult::Retry(); + } + auto fn_type_id = resolver.local_insts().Get(fn_val_id).type_id(); + return ResolveAs( + resolver, {.type_id = SemIR::TypeId::TypeType, + .function_id = resolver.local_types() + .GetAs(fn_type_id) + .function_id, + .specific_id = GetOrAddLocalSpecific( + resolver, inst.specific_id, specific_data)}); +} - std::optional self_param_id; - if (import_interface.is_defined()) { - self_param_id = GetLocalConstantInstId(import_interface.self_param_id); - } +static auto TryResolveTypedInst(ImportRefResolver& resolver, + SemIR::GenericClassType inst) -> ResolveResult { + CARBON_CHECK(inst.type_id == SemIR::TypeId::TypeType); + auto class_val_id = GetLocalConstantInstId( + resolver, + resolver.import_classes().Get(inst.class_id).first_owning_decl_id); + if (resolver.HasNewWork()) { + return ResolveResult::Retry(); + } + auto class_val = resolver.local_insts().Get(class_val_id); + CARBON_CHECK( + resolver.local_types().Is(class_val.type_id())); + return ResolveResult::Done( + resolver.local_types().GetConstantId(class_val.type_id())); +} - if (HasNewWork()) { - return Retry(interface_const_id); - } +static auto TryResolveTypedInst(ImportRefResolver& resolver, + SemIR::GenericInterfaceType inst) + -> ResolveResult { + CARBON_CHECK(inst.type_id == SemIR::TypeId::TypeType); + auto interface_val_id = GetLocalConstantInstId( + resolver, + resolver.import_interfaces().Get(inst.interface_id).first_owning_decl_id); + if (resolver.HasNewWork()) { + return ResolveResult::Retry(); + } + auto interface_val = resolver.local_insts().Get(interface_val_id); + CARBON_CHECK(resolver.local_types().Is( + interface_val.type_id())); + return ResolveResult::Done( + resolver.local_types().GetConstantId(interface_val.type_id())); +} - auto& new_interface = context_.interfaces().Get(interface_id); - new_interface.parent_scope_id = parent_scope_id; - new_interface.implicit_param_patterns_id = - GetLocalParamPatternsId(import_interface.implicit_param_patterns_id); - new_interface.param_patterns_id = - GetLocalParamPatternsId(import_interface.param_patterns_id); - SetGenericData(import_interface.generic_id, new_interface.generic_id, - generic_data); +// Make a declaration of an impl. This is done as a separate step from +// importing the impl definition in order to resolve cycles. +static auto MakeImplDeclaration(ImportContext& context, + const SemIR::Impl& import_impl) + -> std::pair { + SemIR::ImplDecl impl_decl = {.impl_id = SemIR::ImplId::Invalid, + .decl_block_id = SemIR::InstBlockId::Empty}; + auto impl_decl_id = context.local_context().AddPlaceholderInstInNoBlock( + context.local_context().MakeImportedLocAndInst( + AddImportIRInst(context, import_impl.latest_decl_id()), impl_decl)); + impl_decl.impl_id = context.local_impls().Add( + {GetIncompleteLocalEntityBase(context, impl_decl_id, import_impl), + {.self_id = SemIR::InstId::Invalid, + .constraint_id = SemIR::InstId::Invalid, + .witness_id = SemIR::InstId::Invalid}}); + + // Write the impl ID into the ImplDecl. + context.local_context().ReplaceInstBeforeConstantUse(impl_decl_id, impl_decl); + return {impl_decl.impl_id, context.local_constant_values().Get(impl_decl_id)}; +} - if (import_interface.is_defined()) { - CARBON_CHECK(self_param_id); - AddInterfaceDefinition(import_interface, new_interface, *self_param_id); +// Imports the definition of an impl. +static auto AddImplDefinition(ImportContext& context, + const SemIR::Impl& import_impl, + SemIR::Impl& new_impl, SemIR::InstId witness_id) + -> void { + new_impl.definition_id = new_impl.first_owning_decl_id; + + new_impl.witness_id = witness_id; + + if (import_impl.scope_id.is_valid()) { + new_impl.scope_id = context.local_name_scopes().Add( + new_impl.first_owning_decl_id, SemIR::NameId::Invalid, + new_impl.parent_scope_id); + // Import the contents of the definition scope, if we might need it. Name + // lookup is never performed into this scope by a user of the impl, so + // this is only necessary in the same library that defined the impl, in + // order to support defining members of the impl out of line in the impl + // file when the impl is defined in the API file. + // TODO: Check to see if this impl is owned by the API file, rather than + // merely being imported into it. + if (context.import_ir_id() == SemIR::ImportIRId::ApiForImpl) { + auto& new_scope = context.local_name_scopes().Get(new_impl.scope_id); + const auto& import_scope = + context.import_name_scopes().Get(import_impl.scope_id); + + // Push a block so that we can add scoped instructions to it. + context.local_context().inst_block_stack().Push(); + AddNameScopeImportRefs(context, import_scope, new_scope); + new_impl.body_block_id = context.local_context().inst_block_stack().Pop(); } - return ResolveAsConstant(interface_const_id); } +} - auto TryResolveTypedInst(SemIR::FacetAccessType inst) -> ResolveResult { - auto facet_value_inst_id = GetLocalConstantInstId(inst.facet_value_inst_id); - if (HasNewWork()) { - return Retry(); - } +static auto TryResolveTypedInst(ImportRefResolver& resolver, + SemIR::ImplDecl inst, + SemIR::ConstantId impl_const_id) + -> ResolveResult { + // TODO: This duplicates a lot of the handling of interfaces, classes, and + // functions. Factor out the commonality. + const auto& import_impl = resolver.import_impls().Get(inst.impl_id); + + SemIR::ImplId impl_id = SemIR::ImplId::Invalid; + if (!impl_const_id.is_valid()) { + if (resolver.HasNewWork()) { + // This is the end of the first phase. Don't make a new impl yet if we + // already have new work. + return ResolveResult::Retry(); + } + + // On the second phase, create a forward declaration of the impl for any + // recursive references. + std::tie(impl_id, impl_const_id) = + MakeImplDeclaration(resolver, import_impl); + } else { + // On the third phase, compute the impl ID from the "constant value" of + // the declaration, which is a reference to the created ImplDecl. + auto impl_const_inst = resolver.local_insts().GetAs( + resolver.local_constant_values().GetInstId(impl_const_id)); + impl_id = impl_const_inst.impl_id; + } + + // Load constants for the definition. + auto parent_scope_id = + GetLocalNameScopeId(resolver, import_impl.parent_scope_id); + LoadLocalPatternConstantIds(resolver, import_impl.implicit_param_patterns_id); + auto generic_data = GetLocalGenericData(resolver, import_impl.generic_id); + auto self_const_id = GetLocalConstantId( + resolver, resolver.import_constant_values().Get(import_impl.self_id)); + auto constraint_const_id = GetLocalConstantId( + resolver, + resolver.import_constant_values().Get(import_impl.constraint_id)); + + if (resolver.HasNewWork()) { + return ResolveResult::Retry(impl_const_id); + } + + auto& new_impl = resolver.local_impls().Get(impl_id); + new_impl.parent_scope_id = parent_scope_id; + new_impl.implicit_param_patterns_id = + GetLocalParamPatternsId(resolver, import_impl.implicit_param_patterns_id); + SetGenericData(resolver, import_impl.generic_id, new_impl.generic_id, + generic_data); + + // Create instructions for self and constraint to hold the symbolic constant + // value for a generic impl. + new_impl.self_id = AddLoadedImportRef(resolver, SemIR::TypeId::TypeType, + import_impl.self_id, self_const_id); + new_impl.constraint_id = + AddLoadedImportRef(resolver, SemIR::TypeId::TypeType, + import_impl.constraint_id, constraint_const_id); + + if (import_impl.is_defined()) { + auto witness_id = AddImportRef(resolver, import_impl.witness_id); + AddImplDefinition(resolver, import_impl, new_impl, witness_id); + } + + // If the `impl` is declared in the API file corresponding to the current + // file, add this to impl lookup so that it can be found by redeclarations + // in the current file. + if (resolver.import_ir_id() == SemIR::ImportIRId::ApiForImpl) { + resolver.local_impls().GetOrAddLookupBucket(new_impl).push_back(impl_id); + } + + return ResolveResult::Done(impl_const_id); +} - return ResolveAs( - {.type_id = SemIR::TypeId::TypeType, - .facet_value_inst_id = facet_value_inst_id}); +static auto TryResolveTypedInst(ImportRefResolver& resolver, + SemIR::ImportRefLoaded /*inst*/, + SemIR::InstId inst_id) -> ResolveResult { + // Return the constant for the instruction of the imported constant. + auto constant_id = resolver.import_constant_values().Get(inst_id); + if (!constant_id.is_valid()) { + return ResolveResult::Done(SemIR::ConstantId::Error); + } + if (!constant_id.is_constant()) { + resolver.local_context().TODO( + inst_id, "Non-constant ImportRefLoaded (comes up with var)"); + return ResolveResult::Done(SemIR::ConstantId::Error); } - auto TryResolveTypedInst(SemIR::FacetType inst) -> ResolveResult { - CARBON_CHECK(inst.type_id == SemIR::TypeId::TypeType); + auto new_constant_id = GetLocalConstantId( + resolver, resolver.import_constant_values().GetInstId(constant_id)); + return RetryOrDone(resolver, new_constant_id); +} - const SemIR::FacetTypeInfo& facet_type_info = - import_ir_.facet_types().Get(inst.facet_type_id); - for (auto interface : facet_type_info.impls_constraints) { - GetLocalConstantId(import_ir_.interfaces() - .Get(interface.interface_id) - .first_owning_decl_id); - GetLocalSpecificData(interface.specific_id); - } - if (HasNewWork()) { - return Retry(); - } +// Make a declaration of an interface. This is done as a separate step from +// importing the interface definition in order to resolve cycles. +static auto MakeInterfaceDecl(ImportContext& context, + const SemIR::Interface& import_interface, + SemIR::SpecificId enclosing_specific_id) + -> std::pair { + SemIR::InterfaceDecl interface_decl = { + .type_id = SemIR::TypeId::TypeType, + .interface_id = SemIR::InterfaceId::Invalid, + .decl_block_id = SemIR::InstBlockId::Empty}; + auto interface_decl_id = context.local_context().AddPlaceholderInstInNoBlock( + context.local_context().MakeImportedLocAndInst( + AddImportIRInst(context, import_interface.first_owning_decl_id), + interface_decl)); + + // Start with an incomplete interface. + interface_decl.interface_id = context.local_interfaces().Add( + {GetIncompleteLocalEntityBase(context, interface_decl_id, + import_interface), + {}}); + + if (import_interface.has_parameters()) { + interface_decl.type_id = context.local_context().GetGenericInterfaceType( + interface_decl.interface_id, enclosing_specific_id); + } + + // Write the interface ID into the InterfaceDecl. + context.local_context().ReplaceInstBeforeConstantUse(interface_decl_id, + interface_decl); + return {interface_decl.interface_id, + context.local_constant_values().Get(interface_decl_id)}; +} - llvm::SmallVector impls_constraints; - for (auto interface : facet_type_info.impls_constraints) { - auto interface_const_id = - GetLocalConstantId(import_ir_.interfaces() - .Get(interface.interface_id) - .first_owning_decl_id); - auto specific_data = GetLocalSpecificData(interface.specific_id); +// Imports the definition for an interface that has been imported as a forward +// declaration. +static auto AddInterfaceDefinition(ImportContext& context, + const SemIR::Interface& import_interface, + SemIR::Interface& new_interface, + SemIR::InstId self_param_id) -> void { + new_interface.scope_id = context.local_name_scopes().Add( + new_interface.first_owning_decl_id, SemIR::NameId::Invalid, + new_interface.parent_scope_id); + auto& new_scope = context.local_name_scopes().Get(new_interface.scope_id); + const auto& import_scope = + context.import_name_scopes().Get(import_interface.scope_id); + + // Push a block so that we can add scoped instructions to it. + context.local_context().inst_block_stack().Push(); + AddNameScopeImportRefs(context, import_scope, new_scope); + new_interface.associated_entities_id = + AddAssociatedEntities(context, import_interface.associated_entities_id); + new_interface.body_block_id = + context.local_context().inst_block_stack().Pop(); + new_interface.self_param_id = self_param_id; + + CARBON_CHECK(import_scope.extended_scopes.empty(), + "Interfaces don't currently have extended scopes to support."); +} - // Find the corresponding interface type. For a non-generic interface, - // this is the type of the interface declaration. For a generic interface, - // build a interface type referencing this specialization of the generic - // interface. - auto interface_const_inst = context_.insts().Get( - context_.constant_values().GetInstId(interface_const_id)); - if (auto facet_type = interface_const_inst.TryAs()) { - const SemIR::FacetTypeInfo& new_facet_type_info = - context_.facet_types().Get(facet_type->facet_type_id); - impls_constraints.append(new_facet_type_info.impls_constraints); - } else { - auto generic_interface_type = - context_.types().GetAs( - interface_const_inst.type_id()); - auto specific_id = - GetOrAddLocalSpecific(interface.specific_id, specific_data); - impls_constraints.push_back( - {generic_interface_type.interface_id, specific_id}); - } +static auto TryResolveTypedInst(ImportRefResolver& resolver, + SemIR::InterfaceDecl inst, + SemIR::ConstantId interface_const_id) + -> ResolveResult { + const auto& import_interface = + resolver.import_interfaces().Get(inst.interface_id); + + SemIR::InterfaceId interface_id = SemIR::InterfaceId::Invalid; + if (!interface_const_id.is_valid()) { + auto import_specific_id = SemIR::SpecificId::Invalid; + if (auto import_generic_interface_type = + resolver.import_types().TryGetAs( + inst.type_id)) { + import_specific_id = import_generic_interface_type->enclosing_specific_id; + } + auto specific_data = GetLocalSpecificData(resolver, import_specific_id); + if (resolver.HasNewWork()) { + // This is the end of the first phase. Don't make a new interface yet if + // we already have new work. + return ResolveResult::Retry(); + } + + // On the second phase, create a forward declaration of the interface. + auto enclosing_specific_id = + GetOrAddLocalSpecific(resolver, import_specific_id, specific_data); + std::tie(interface_id, interface_const_id) = + MakeInterfaceDecl(resolver, import_interface, enclosing_specific_id); + } else { + // On the third phase, compute the interface ID from the constant value of + // the declaration. + auto interface_const_inst = resolver.local_insts().Get( + resolver.local_constant_values().GetInstId(interface_const_id)); + if (auto facet_type = interface_const_inst.TryAs()) { + const SemIR::FacetTypeInfo& facet_type_info = + resolver.local_facet_types().Get(facet_type->facet_type_id); + auto interface_type = facet_type_info.TryAsSingleInterface(); + CARBON_CHECK(interface_type); + interface_id = interface_type->interface_id; + } else { + auto generic_interface_type = + resolver.local_types().GetAs( + interface_const_inst.type_id()); + interface_id = generic_interface_type.interface_id; } - // TODO: Also process the other requirements. - SemIR::FacetTypeId facet_type_id = - context_.facet_types().Add(SemIR::FacetTypeInfo{ - .impls_constraints = impls_constraints, - .requirement_block_id = SemIR::InstBlockId::Invalid}); - return ResolveAs( - {.type_id = SemIR::TypeId::TypeType, .facet_type_id = facet_type_id}); } - auto TryResolveTypedInst(SemIR::FacetValue inst) -> ResolveResult { - auto type_id = GetLocalConstantId(inst.type_id); - auto type_inst_id = GetLocalConstantInstId(inst.type_inst_id); - auto witness_inst_id = GetLocalConstantInstId(inst.witness_inst_id); - if (HasNewWork()) { - return Retry(); - } + auto parent_scope_id = + GetLocalNameScopeId(resolver, import_interface.parent_scope_id); + LoadLocalPatternConstantIds(resolver, + import_interface.implicit_param_patterns_id); + LoadLocalPatternConstantIds(resolver, import_interface.param_patterns_id); + auto generic_data = + GetLocalGenericData(resolver, import_interface.generic_id); - return ResolveAs( - {.type_id = context_.GetTypeIdForTypeConstant(type_id), - .type_inst_id = type_inst_id, - .witness_inst_id = witness_inst_id}); + std::optional self_param_id; + if (import_interface.is_defined()) { + self_param_id = + GetLocalConstantInstId(resolver, import_interface.self_param_id); } - auto TryResolveTypedInst(SemIR::InterfaceWitness inst) -> ResolveResult { - auto elements = GetLocalInstBlockContents(inst.elements_id); - if (HasNewWork()) { - return Retry(); - } - - auto elements_id = GetLocalCanonicalInstBlockId(inst.elements_id, elements); - return ResolveAs( - {.type_id = - context_.GetBuiltinType(SemIR::BuiltinInstKind::WitnessType), - .elements_id = elements_id}); + if (resolver.HasNewWork()) { + return ResolveResult::Retry(interface_const_id); } - auto TryResolveTypedInst(SemIR::IntValue inst) -> ResolveResult { - auto type_id = GetLocalConstantId(inst.type_id); - if (HasNewWork()) { - return Retry(); - } + auto& new_interface = resolver.local_interfaces().Get(interface_id); + new_interface.parent_scope_id = parent_scope_id; + new_interface.implicit_param_patterns_id = GetLocalParamPatternsId( + resolver, import_interface.implicit_param_patterns_id); + new_interface.param_patterns_id = + GetLocalParamPatternsId(resolver, import_interface.param_patterns_id); + SetGenericData(resolver, import_interface.generic_id, + new_interface.generic_id, generic_data); - // We can directly reuse the value IDs across file IRs. Otherwise, we need - // to add a new canonical int in this IR. - auto int_id = - inst.int_id.is_value() - ? inst.int_id - : context_.ints().AddSigned(import_ir_.ints().Get(inst.int_id)); + if (import_interface.is_defined()) { + CARBON_CHECK(self_param_id); + AddInterfaceDefinition(resolver, import_interface, new_interface, + *self_param_id); + } + return ResolveResult::Done(interface_const_id); +} - return ResolveAs( - {.type_id = context_.GetTypeIdForTypeConstant(type_id), - .int_id = int_id}); +static auto TryResolveTypedInst(ImportRefResolver& resolver, + SemIR::FacetAccessType inst) -> ResolveResult { + auto facet_value_inst_id = + GetLocalConstantInstId(resolver, inst.facet_value_inst_id); + if (resolver.HasNewWork()) { + return ResolveResult::Retry(); } - auto TryResolveTypedInst(SemIR::IntType inst) -> ResolveResult { - CARBON_CHECK(inst.type_id == SemIR::TypeId::TypeType); - auto bit_width_id = GetLocalConstantInstId(inst.bit_width_id); - if (HasNewWork()) { - return Retry(); - } + return ResolveAs( + resolver, {.type_id = SemIR::TypeId::TypeType, + .facet_value_inst_id = facet_value_inst_id}); +} - return ResolveAs({.type_id = SemIR::TypeId::TypeType, - .int_kind = inst.int_kind, - .bit_width_id = bit_width_id}); +static auto TryResolveTypedInst(ImportRefResolver& resolver, + SemIR::FacetType inst) -> ResolveResult { + CARBON_CHECK(inst.type_id == SemIR::TypeId::TypeType); + + const SemIR::FacetTypeInfo& facet_type_info = + resolver.import_facet_types().Get(inst.facet_type_id); + for (auto interface : facet_type_info.impls_constraints) { + GetLocalConstantId(resolver, resolver.import_interfaces() + .Get(interface.interface_id) + .first_owning_decl_id); + GetLocalSpecificData(resolver, interface.specific_id); + } + if (resolver.HasNewWork()) { + return ResolveResult::Retry(); + } + + llvm::SmallVector impls_constraints; + for (auto interface : facet_type_info.impls_constraints) { + auto interface_const_id = + GetLocalConstantId(resolver, resolver.import_interfaces() + .Get(interface.interface_id) + .first_owning_decl_id); + auto specific_data = GetLocalSpecificData(resolver, interface.specific_id); + + // Find the corresponding interface type. For a non-generic interface, + // this is the type of the interface declaration. For a generic interface, + // build a interface type referencing this specialization of the generic + // interface. + auto interface_const_inst = resolver.local_insts().Get( + resolver.local_constant_values().GetInstId(interface_const_id)); + if (auto facet_type = interface_const_inst.TryAs()) { + const SemIR::FacetTypeInfo& new_facet_type_info = + resolver.local_facet_types().Get(facet_type->facet_type_id); + impls_constraints.append(new_facet_type_info.impls_constraints); + } else { + auto generic_interface_type = + resolver.local_types().GetAs( + interface_const_inst.type_id()); + auto specific_id = + GetOrAddLocalSpecific(resolver, interface.specific_id, specific_data); + impls_constraints.push_back( + {generic_interface_type.interface_id, specific_id}); + } + } + // TODO: Also process the other requirements. + SemIR::FacetTypeId facet_type_id = + resolver.local_facet_types().Add(SemIR::FacetTypeInfo{ + .impls_constraints = impls_constraints, + .requirement_block_id = SemIR::InstBlockId::Invalid}); + return ResolveAs( + resolver, + {.type_id = SemIR::TypeId::TypeType, .facet_type_id = facet_type_id}); +} + +static auto TryResolveTypedInst(ImportRefResolver& resolver, + SemIR::FacetValue inst) -> ResolveResult { + auto type_id = GetLocalConstantId(resolver, inst.type_id); + auto type_inst_id = GetLocalConstantInstId(resolver, inst.type_inst_id); + auto witness_inst_id = GetLocalConstantInstId(resolver, inst.witness_inst_id); + if (resolver.HasNewWork()) { + return ResolveResult::Retry(); } - auto TryResolveTypedInst(SemIR::PointerType inst) -> ResolveResult { - CARBON_CHECK(inst.type_id == SemIR::TypeId::TypeType); - auto pointee_const_id = GetLocalConstantId(inst.pointee_id); - if (HasNewWork()) { - return Retry(); - } + return ResolveAs( + resolver, + {.type_id = resolver.local_context().GetTypeIdForTypeConstant(type_id), + .type_inst_id = type_inst_id, + .witness_inst_id = witness_inst_id}); +} - auto pointee_type_id = context_.GetTypeIdForTypeConstant(pointee_const_id); - return ResolveAs( - {.type_id = SemIR::TypeId::TypeType, .pointee_id = pointee_type_id}); +static auto TryResolveTypedInst(ImportRefResolver& resolver, + SemIR::InterfaceWitness inst) -> ResolveResult { + auto elements = GetLocalInstBlockContents(resolver, inst.elements_id); + if (resolver.HasNewWork()) { + return ResolveResult::Retry(); } - auto TryResolveTypedInst(SemIR::SpecificFunction inst) -> ResolveResult { - auto type_const_id = GetLocalConstantId(inst.type_id); - auto callee_id = GetLocalConstantInstId(inst.callee_id); - auto specific_data = GetLocalSpecificData(inst.specific_id); - if (HasNewWork()) { - return Retry(); - } + auto elements_id = + GetLocalCanonicalInstBlockId(resolver, inst.elements_id, elements); + return ResolveAs( + resolver, {.type_id = resolver.local_context().GetBuiltinType( + SemIR::BuiltinInstKind::WitnessType), + .elements_id = elements_id}); +} - auto type_id = context_.GetTypeIdForTypeConstant(type_const_id); - auto specific_id = GetOrAddLocalSpecific(inst.specific_id, specific_data); - return ResolveAs({.type_id = type_id, - .callee_id = callee_id, - .specific_id = specific_id}); +static auto TryResolveTypedInst(ImportRefResolver& resolver, + SemIR::IntValue inst) -> ResolveResult { + auto type_id = GetLocalConstantId(resolver, inst.type_id); + if (resolver.HasNewWork()) { + return ResolveResult::Retry(); } - auto TryResolveTypedInst(SemIR::StructType inst) -> ResolveResult { - CARBON_CHECK(inst.type_id == SemIR::TypeId::TypeType); - auto orig_fields = import_ir_.struct_type_fields().Get(inst.fields_id); - llvm::SmallVector field_const_ids; - field_const_ids.reserve(orig_fields.size()); - for (auto field : orig_fields) { - field_const_ids.push_back(GetLocalConstantId(field.type_id)); - } - if (HasNewWork()) { - return Retry(); - } + // We can directly reuse the value IDs across file IRs. Otherwise, we need + // to add a new canonical int in this IR. + auto int_id = inst.int_id.is_value() + ? inst.int_id + : resolver.local_ints().AddSigned( + resolver.import_ints().Get(inst.int_id)); - // Prepare a vector of fields for GetStructType. - llvm::SmallVector new_fields; - new_fields.reserve(orig_fields.size()); - for (auto [orig_field, field_const_id] : - llvm::zip(orig_fields, field_const_ids)) { - auto name_id = GetLocalNameId(orig_field.name_id); - auto field_type_id = context_.GetTypeIdForTypeConstant(field_const_id); - new_fields.push_back({.name_id = name_id, .type_id = field_type_id}); - } + return ResolveAs( + resolver, + {.type_id = resolver.local_context().GetTypeIdForTypeConstant(type_id), + .int_id = int_id}); +} - return ResolveAs( - {.type_id = SemIR::TypeId::TypeType, - .fields_id = context_.struct_type_fields().AddCanonical(new_fields)}); +static auto TryResolveTypedInst(ImportRefResolver& resolver, + SemIR::IntType inst) -> ResolveResult { + CARBON_CHECK(inst.type_id == SemIR::TypeId::TypeType); + auto bit_width_id = GetLocalConstantInstId(resolver, inst.bit_width_id); + if (resolver.HasNewWork()) { + return ResolveResult::Retry(); } - auto TryResolveTypedInst(SemIR::StructValue inst) -> ResolveResult { - auto type_id = GetLocalConstantId(inst.type_id); - auto elems = GetLocalInstBlockContents(inst.elements_id); - if (HasNewWork()) { - return Retry(); - } + return ResolveAs(resolver, + {.type_id = SemIR::TypeId::TypeType, + .int_kind = inst.int_kind, + .bit_width_id = bit_width_id}); +} - return ResolveAs( - {.type_id = context_.GetTypeIdForTypeConstant(type_id), - .elements_id = GetLocalCanonicalInstBlockId(inst.elements_id, elems)}); +static auto TryResolveTypedInst(ImportRefResolver& resolver, + SemIR::PointerType inst) -> ResolveResult { + CARBON_CHECK(inst.type_id == SemIR::TypeId::TypeType); + auto pointee_const_id = GetLocalConstantId(resolver, inst.pointee_id); + if (resolver.HasNewWork()) { + return ResolveResult::Retry(); } - auto TryResolveTypedInst(SemIR::TupleType inst) -> ResolveResult { - CARBON_CHECK(inst.type_id == SemIR::TypeId::TypeType); + auto pointee_type_id = + resolver.local_context().GetTypeIdForTypeConstant(pointee_const_id); + return ResolveAs( + resolver, + {.type_id = SemIR::TypeId::TypeType, .pointee_id = pointee_type_id}); +} - auto orig_elem_type_ids = import_ir_.type_blocks().Get(inst.elements_id); - llvm::SmallVector elem_const_ids; - elem_const_ids.reserve(orig_elem_type_ids.size()); - for (auto elem_type_id : orig_elem_type_ids) { - elem_const_ids.push_back(GetLocalConstantId(elem_type_id)); - } - if (HasNewWork()) { - return Retry(); - } +static auto TryResolveTypedInst(ImportRefResolver& resolver, + SemIR::SpecificFunction inst) -> ResolveResult { + auto type_const_id = GetLocalConstantId(resolver, inst.type_id); + auto callee_id = GetLocalConstantInstId(resolver, inst.callee_id); + auto specific_data = GetLocalSpecificData(resolver, inst.specific_id); + if (resolver.HasNewWork()) { + return ResolveResult::Retry(); + } + + auto type_id = + resolver.local_context().GetTypeIdForTypeConstant(type_const_id); + auto specific_id = + GetOrAddLocalSpecific(resolver, inst.specific_id, specific_data); + return ResolveAs( + resolver, + {.type_id = type_id, .callee_id = callee_id, .specific_id = specific_id}); +} - // Prepare a vector of the tuple types for GetTupleType. - llvm::SmallVector elem_type_ids; - elem_type_ids.reserve(orig_elem_type_ids.size()); - for (auto elem_const_id : elem_const_ids) { - elem_type_ids.push_back(context_.GetTypeIdForTypeConstant(elem_const_id)); - } +static auto TryResolveTypedInst(ImportRefResolver& resolver, + SemIR::StructType inst) -> ResolveResult { + CARBON_CHECK(inst.type_id == SemIR::TypeId::TypeType); + auto orig_fields = resolver.import_struct_type_fields().Get(inst.fields_id); + llvm::SmallVector field_const_ids; + field_const_ids.reserve(orig_fields.size()); + for (auto field : orig_fields) { + field_const_ids.push_back(GetLocalConstantId(resolver, field.type_id)); + } + if (resolver.HasNewWork()) { + return ResolveResult::Retry(); + } + + // Prepare a vector of fields for GetStructType. + llvm::SmallVector new_fields; + new_fields.reserve(orig_fields.size()); + for (auto [orig_field, field_const_id] : + llvm::zip(orig_fields, field_const_ids)) { + auto name_id = GetLocalNameId(resolver, orig_field.name_id); + auto field_type_id = + resolver.local_context().GetTypeIdForTypeConstant(field_const_id); + new_fields.push_back({.name_id = name_id, .type_id = field_type_id}); + } + + return ResolveAs( + resolver, {.type_id = SemIR::TypeId::TypeType, + .fields_id = resolver.local_struct_type_fields().AddCanonical( + new_fields)}); +} - return ResolveAsConstant( - context_.types().GetConstantId(context_.GetTupleType(elem_type_ids))); +static auto TryResolveTypedInst(ImportRefResolver& resolver, + SemIR::StructValue inst) -> ResolveResult { + auto type_id = GetLocalConstantId(resolver, inst.type_id); + auto elems = GetLocalInstBlockContents(resolver, inst.elements_id); + if (resolver.HasNewWork()) { + return ResolveResult::Retry(); } - auto TryResolveTypedInst(SemIR::TupleValue inst) -> ResolveResult { - auto type_id = GetLocalConstantId(inst.type_id); - auto elems = GetLocalInstBlockContents(inst.elements_id); - if (HasNewWork()) { - return Retry(); - } + return ResolveAs( + resolver, + {.type_id = resolver.local_context().GetTypeIdForTypeConstant(type_id), + .elements_id = + GetLocalCanonicalInstBlockId(resolver, inst.elements_id, elems)}); +} - return ResolveAs( - {.type_id = context_.GetTypeIdForTypeConstant(type_id), - .elements_id = GetLocalCanonicalInstBlockId(inst.elements_id, elems)}); - } +static auto TryResolveTypedInst(ImportRefResolver& resolver, + SemIR::TupleType inst) -> ResolveResult { + CARBON_CHECK(inst.type_id == SemIR::TypeId::TypeType); - auto TryResolveTypedInst(SemIR::UnboundElementType inst) -> ResolveResult { - CARBON_CHECK(inst.type_id == SemIR::TypeId::TypeType); - auto class_const_id = GetLocalConstantId(inst.class_type_id); - auto elem_const_id = GetLocalConstantId(inst.element_type_id); - if (HasNewWork()) { - return Retry(); - } + auto orig_elem_type_ids = resolver.import_type_blocks().Get(inst.elements_id); + llvm::SmallVector elem_const_ids; + elem_const_ids.reserve(orig_elem_type_ids.size()); + for (auto elem_type_id : orig_elem_type_ids) { + elem_const_ids.push_back(GetLocalConstantId(resolver, elem_type_id)); + } + if (resolver.HasNewWork()) { + return ResolveResult::Retry(); + } - return ResolveAs( - {.type_id = SemIR::TypeId::TypeType, - .class_type_id = context_.GetTypeIdForTypeConstant(class_const_id), - .element_type_id = context_.GetTypeIdForTypeConstant(elem_const_id)}); + // Prepare a vector of the tuple types for GetTupleType. + llvm::SmallVector elem_type_ids; + elem_type_ids.reserve(orig_elem_type_ids.size()); + for (auto elem_const_id : elem_const_ids) { + elem_type_ids.push_back( + resolver.local_context().GetTypeIdForTypeConstant(elem_const_id)); } - // Perform any work that we deferred until the end of the main Resolve loop. - auto PerformPendingWork() -> void { - // Note that the individual Finish steps can add new pending work, so keep - // going until we have no more work to do. - while (!pending_generics_.empty() || !pending_specifics_.empty()) { - // Process generics in the order that we added them because a later - // generic might refer to an earlier one, and the calls to - // RebuildGenericEvalBlock assume that the reachable SemIR is in a valid - // state. - // TODO: Import the generic eval block rather than calling - // RebuildGenericEvalBlock to rebuild it so that order doesn't matter. - // NOLINTNEXTLINE(modernize-loop-convert) - for (size_t i = 0; i != pending_generics_.size(); ++i) { - FinishPendingGeneric(pending_generics_[i]); - } - pending_generics_.clear(); + return ResolveResult::Done(resolver.local_types().GetConstantId( + resolver.local_context().GetTupleType(elem_type_ids))); +} - while (!pending_specifics_.empty()) { - FinishPendingSpecific(pending_specifics_.pop_back_val()); - } - } +static auto TryResolveTypedInst(ImportRefResolver& resolver, + SemIR::TupleValue inst) -> ResolveResult { + auto type_id = GetLocalConstantId(resolver, inst.type_id); + auto elems = GetLocalInstBlockContents(resolver, inst.elements_id); + if (resolver.HasNewWork()) { + return ResolveResult::Retry(); } - // Resolves and returns the local contents for an imported instruction block - // of constant instructions. - auto ResolveLocalInstBlockContents(SemIR::InstBlockId import_block_id) - -> llvm::SmallVector { - auto import_block = import_ir_.inst_blocks().Get(import_block_id); + return ResolveAs( + resolver, + {.type_id = resolver.local_context().GetTypeIdForTypeConstant(type_id), + .elements_id = + GetLocalCanonicalInstBlockId(resolver, inst.elements_id, elems)}); +} - llvm::SmallVector inst_ids; - inst_ids.reserve(import_block.size()); - for (auto import_inst_id : import_block) { - inst_ids.push_back( - context_.constant_values().GetInstId(ResolveOneInst(import_inst_id))); - } - return inst_ids; +static auto TryResolveTypedInst(ImportRefResolver& resolver, + SemIR::UnboundElementType inst) + -> ResolveResult { + CARBON_CHECK(inst.type_id == SemIR::TypeId::TypeType); + auto class_const_id = GetLocalConstantId(resolver, inst.class_type_id); + auto elem_const_id = GetLocalConstantId(resolver, inst.element_type_id); + if (resolver.HasNewWork()) { + return ResolveResult::Retry(); + } + + return ResolveAs( + resolver, + {.type_id = SemIR::TypeId::TypeType, + .class_type_id = + resolver.local_context().GetTypeIdForTypeConstant(class_const_id), + .element_type_id = + resolver.local_context().GetTypeIdForTypeConstant(elem_const_id)}); +} + +// Tries to resolve the InstId, returning a canonical constant when ready, or +// Invalid if more has been added to the stack. This is the same as +// TryResolveInst, except that it may resolve symbolic constants as canonical +// constants instead of as constants associated with a particular generic. +static auto TryResolveInstCanonical(ImportRefResolver& resolver, + SemIR::InstId inst_id, + SemIR::ConstantId const_id) + -> ResolveResult { + if (inst_id.is_builtin()) { + CARBON_CHECK(!const_id.is_valid()); + // Constants for builtins can be directly copied. + return ResolveResult::Done(resolver.local_constant_values().Get(inst_id)); } - // Resolves and returns a local eval block for a region of an imported - // generic. - auto ResolveLocalEvalBlock(const SemIR::Generic& import_generic, - SemIR::GenericId generic_id, - SemIR::GenericInstIndex::Region region) - -> SemIR::InstBlockId { - auto import_block_id = import_generic.GetEvalBlock(region); - if (!import_block_id.is_valid()) { - return SemIR::InstBlockId::Invalid; + auto untyped_inst = resolver.import_insts().Get(inst_id); + CARBON_KIND_SWITCH(untyped_inst) { + case CARBON_KIND(SemIR::AssociatedEntity inst): { + return TryResolveTypedInst(resolver, inst); + } + case CARBON_KIND(SemIR::AssociatedEntityType inst): { + return TryResolveTypedInst(resolver, inst); + } + case CARBON_KIND(SemIR::BaseDecl inst): { + return TryResolveTypedInst(resolver, inst, inst_id); + } + case CARBON_KIND(SemIR::BindAlias inst): { + return TryResolveTypedInst(resolver, inst); + } + case SemIR::BindName::Kind: { + // TODO: Should we be resolving BindNames at all? + return ResolveResult::Done(SemIR::ConstantId::NotConstant); + } + case CARBON_KIND(SemIR::BindSymbolicName inst): { + return TryResolveTypedInst(resolver, inst); + } + case CARBON_KIND(SemIR::ClassDecl inst): { + return TryResolveTypedInst(resolver, inst, const_id); + } + case CARBON_KIND(SemIR::ClassType inst): { + return TryResolveTypedInst(resolver, inst); + } + case CARBON_KIND(SemIR::CompleteTypeWitness inst): { + return TryResolveTypedInst(resolver, inst); + } + case CARBON_KIND(SemIR::ConstType inst): { + return TryResolveTypedInst(resolver, inst); } + case CARBON_KIND(SemIR::ExportDecl inst): { + return TryResolveTypedInst(resolver, inst); + } + case CARBON_KIND(SemIR::FacetAccessType inst): { + return TryResolveTypedInst(resolver, inst); + } + case CARBON_KIND(SemIR::FacetType inst): { + return TryResolveTypedInst(resolver, inst); + } + case CARBON_KIND(SemIR::FacetValue inst): { + return TryResolveTypedInst(resolver, inst); + } + case CARBON_KIND(SemIR::FieldDecl inst): { + return TryResolveTypedInst(resolver, inst, inst_id); + } + case CARBON_KIND(SemIR::FunctionDecl inst): { + return TryResolveTypedInst(resolver, inst, const_id); + } + case CARBON_KIND(SemIR::FunctionType inst): { + return TryResolveTypedInst(resolver, inst); + } + case CARBON_KIND(SemIR::GenericClassType inst): { + return TryResolveTypedInst(resolver, inst); + } + case CARBON_KIND(SemIR::GenericInterfaceType inst): { + return TryResolveTypedInst(resolver, inst); + } + case CARBON_KIND(SemIR::ImplDecl inst): { + return TryResolveTypedInst(resolver, inst, const_id); + } + case CARBON_KIND(SemIR::ImportRefLoaded inst): { + return TryResolveTypedInst(resolver, inst, inst_id); + } + case CARBON_KIND(SemIR::InterfaceDecl inst): { + return TryResolveTypedInst(resolver, inst, const_id); + } + case CARBON_KIND(SemIR::InterfaceWitness inst): { + return TryResolveTypedInst(resolver, inst); + } + case CARBON_KIND(SemIR::IntValue inst): { + return TryResolveTypedInst(resolver, inst); + } + case CARBON_KIND(SemIR::IntType inst): { + return TryResolveTypedInst(resolver, inst); + } + case CARBON_KIND(SemIR::PointerType inst): { + return TryResolveTypedInst(resolver, inst); + } + case CARBON_KIND(SemIR::SpecificFunction inst): { + return TryResolveTypedInst(resolver, inst); + } + case CARBON_KIND(SemIR::SymbolicBindingPattern inst): { + return TryResolveTypedInst(resolver, inst); + } + case CARBON_KIND(SemIR::StructType inst): { + return TryResolveTypedInst(resolver, inst); + } + case CARBON_KIND(SemIR::StructValue inst): { + return TryResolveTypedInst(resolver, inst); + } + case CARBON_KIND(SemIR::TupleType inst): { + return TryResolveTypedInst(resolver, inst); + } + case CARBON_KIND(SemIR::TupleValue inst): { + return TryResolveTypedInst(resolver, inst); + } + case CARBON_KIND(SemIR::UnboundElementType inst): { + return TryResolveTypedInst(resolver, inst); + } + default: { + // This instruction might have a constant value of a different kind. + auto constant_inst_id = + resolver.import_constant_values().GetConstantInstId(inst_id); + if (constant_inst_id == inst_id) { + resolver.local_context().TODO( + SemIR::LocId(AddImportIRInst(resolver, inst_id)), + llvm::formatv("TryResolveInst on {0}", untyped_inst.kind()).str()); + return {.const_id = SemIR::ConstantId::Error}; + } + // Try to resolve the constant value instead. Note that this can only + // retry once. + CARBON_DCHECK(resolver.import_constant_values().GetConstantInstId( + constant_inst_id) == constant_inst_id, + "Constant value of constant instruction should refer to " + "the same instruction"); + return TryResolveInstCanonical(resolver, constant_inst_id, const_id); + } + } +} - auto inst_ids = ResolveLocalInstBlockContents(import_block_id); - return RebuildGenericEvalBlock(context_, generic_id, region, inst_ids); +// Tries to resolve the InstId, returning a constant when ready, or Invalid if +// more has been added to the stack. A similar API is followed for all +// following TryResolveTypedInst helper functions. +// +// `const_id` is Invalid unless we've tried to resolve this instruction +// before, in which case it's the previous result. +// +// TODO: Error is returned when support is missing, but that should go away. +static auto TryResolveInst(ImportRefResolver& resolver, SemIR::InstId inst_id, + SemIR::ConstantId const_id) -> ResolveResult { + auto inst_const_id = resolver.import_constant_values().Get(inst_id); + if (!inst_const_id.is_valid() || !inst_const_id.is_symbolic()) { + return TryResolveInstCanonical(resolver, inst_id, const_id); } - // Fills in the remaining information in a partially-imported generic. - auto FinishPendingGeneric(PendingGeneric pending) -> void { - const auto& import_generic = import_ir_.generics().Get(pending.import_id); + // Try to import the generic. This might add new work. + const auto& symbolic_const = + resolver.import_constant_values().GetSymbolicConstant(inst_const_id); + auto generic_const_id = + GetLocalConstantId(resolver, symbolic_const.generic_id); + + auto inner_const_id = SemIR::ConstantId::Invalid; + if (const_id.is_valid()) { + // For the third phase, extract the constant value that + // TryResolveInstCanonical produced previously. + inner_const_id = resolver.local_constant_values().Get( + resolver.local_constant_values().GetSymbolicConstant(const_id).inst_id); + } + + // Import the constant and rebuild the symbolic constant data. + auto result = TryResolveInstCanonical(resolver, inst_id, inner_const_id); + if (!result.const_id.is_valid()) { + // First phase: TryResolveInstCanoncial needs a retry. + return result; + } - // Don't store the local generic between calls: the generics list can be - // reallocated by ResolveLocalEvalBlock importing more specifics. + if (!const_id.is_valid()) { + // Second phase: we have created an abstract constant. Create a + // corresponding generic constant. + if (symbolic_const.generic_id.is_valid()) { + result.const_id = resolver.local_constant_values().AddSymbolicConstant( + {.inst_id = + resolver.local_constant_values().GetInstId(result.const_id), + .generic_id = GetLocalGenericId(resolver, generic_const_id), + .index = symbolic_const.index}); + } + } else { + // Third phase: perform a consistency check and produce the constant we + // created in the second phase. + CARBON_CHECK(result.const_id == inner_const_id, + "Constant value changed in third phase."); + result.const_id = const_id; + } - auto decl_block_id = - ResolveLocalEvalBlock(import_generic, pending.local_id, - SemIR::GenericInstIndex::Region::Declaration); - context_.generics().Get(pending.local_id).decl_block_id = decl_block_id; + return result; +} - auto self_specific_id = MakeSelfSpecific(context_, pending.local_id); - context_.generics().Get(pending.local_id).self_specific_id = - self_specific_id; - pending_specifics_.push_back({.import_id = import_generic.self_specific_id, - .local_id = self_specific_id}); +// Resolves and returns the local contents for an imported instruction block +// of constant instructions. +static auto ResolveLocalInstBlockContents(ImportRefResolver& resolver, + SemIR::InstBlockId import_block_id) + -> llvm::SmallVector { + auto import_block = resolver.import_inst_blocks().Get(import_block_id); - auto definition_block_id = - ResolveLocalEvalBlock(import_generic, pending.local_id, - SemIR::GenericInstIndex::Region::Definition); - context_.generics().Get(pending.local_id).definition_block_id = - definition_block_id; + llvm::SmallVector inst_ids; + inst_ids.reserve(import_block.size()); + for (auto import_inst_id : import_block) { + inst_ids.push_back(resolver.local_constant_values().GetInstId( + resolver.ResolveOneInst(import_inst_id))); } + return inst_ids; +} - // Resolves and returns a local inst block of constant instructions - // corresponding to an imported inst block. - auto ResolveLocalInstBlock(SemIR::InstBlockId import_block_id) - -> SemIR::InstBlockId { - if (!import_block_id.is_valid()) { - return SemIR::InstBlockId::Invalid; - } +// Resolves and returns a local eval block for a region of an imported +// generic. +static auto ResolveLocalEvalBlock(ImportRefResolver& resolver, + const SemIR::Generic& import_generic, + SemIR::GenericId generic_id, + SemIR::GenericInstIndex::Region region) + -> SemIR::InstBlockId { + auto import_block_id = import_generic.GetEvalBlock(region); + if (!import_block_id.is_valid()) { + return SemIR::InstBlockId::Invalid; + } + + auto inst_ids = ResolveLocalInstBlockContents(resolver, import_block_id); + return RebuildGenericEvalBlock(resolver.local_context(), generic_id, region, + inst_ids); +} - auto inst_ids = ResolveLocalInstBlockContents(import_block_id); - return context_.inst_blocks().Add(inst_ids); +// Fills in the remaining information in a partially-imported generic. +static auto FinishPendingGeneric(ImportRefResolver& resolver, + ImportContext::PendingGeneric pending) + -> void { + const auto& import_generic = + resolver.import_generics().Get(pending.import_id); + + // Don't store the local generic between calls: the generics list can be + // reallocated by ResolveLocalEvalBlock importing more specifics. + + auto decl_block_id = + ResolveLocalEvalBlock(resolver, import_generic, pending.local_id, + SemIR::GenericInstIndex::Region::Declaration); + resolver.local_generics().Get(pending.local_id).decl_block_id = decl_block_id; + + auto self_specific_id = + MakeSelfSpecific(resolver.local_context(), pending.local_id); + resolver.local_generics().Get(pending.local_id).self_specific_id = + self_specific_id; + resolver.AddPendingSpecific({.import_id = import_generic.self_specific_id, + .local_id = self_specific_id}); + + auto definition_block_id = + ResolveLocalEvalBlock(resolver, import_generic, pending.local_id, + SemIR::GenericInstIndex::Region::Definition); + resolver.local_generics().Get(pending.local_id).definition_block_id = + definition_block_id; +} + +// Resolves and returns a local inst block of constant instructions +// corresponding to an imported inst block. +static auto ResolveLocalInstBlock(ImportRefResolver& resolver, + SemIR::InstBlockId import_block_id) + -> SemIR::InstBlockId { + if (!import_block_id.is_valid()) { + return SemIR::InstBlockId::Invalid; } - // Fills in the remaining information in a partially-imported specific. - auto FinishPendingSpecific(PendingSpecific pending) -> void { - const auto& import_specific = import_ir_.specifics().Get(pending.import_id); + auto inst_ids = ResolveLocalInstBlockContents(resolver, import_block_id); + return resolver.local_inst_blocks().Add(inst_ids); +} - // Don't store the local specific between calls: the specifics list can be - // reallocated by ResolveLocalInstBlock importing more specifics. +// Fills in the remaining information in a partially-imported specific. +static auto FinishPendingSpecific(ImportRefResolver& resolver, + ImportContext::PendingSpecific pending) + -> void { + const auto& import_specific = + resolver.import_specifics().Get(pending.import_id); - if (!context_.specifics().Get(pending.local_id).decl_block_id.is_valid()) { - auto decl_block_id = ResolveLocalInstBlock(import_specific.decl_block_id); - context_.specifics().Get(pending.local_id).decl_block_id = decl_block_id; - } + // Don't store the local specific between calls: the specifics list can be + // reallocated by ResolveLocalInstBlock importing more specifics. - if (!context_.specifics() - .Get(pending.local_id) - .definition_block_id.is_valid() && - import_specific.definition_block_id.is_valid()) { - auto definition_block_id = - ResolveLocalInstBlock(import_specific.definition_block_id); - context_.specifics().Get(pending.local_id).definition_block_id = - definition_block_id; - } + if (!resolver.local_specifics() + .Get(pending.local_id) + .decl_block_id.is_valid()) { + auto decl_block_id = + ResolveLocalInstBlock(resolver, import_specific.decl_block_id); + resolver.local_specifics().Get(pending.local_id).decl_block_id = + decl_block_id; } - auto import_ir_constant_values() -> SemIR::ConstantValueStore& { - return context_.import_ir_constant_values()[import_ir_id_.index]; + if (!resolver.local_specifics() + .Get(pending.local_id) + .definition_block_id.is_valid() && + import_specific.definition_block_id.is_valid()) { + auto definition_block_id = + ResolveLocalInstBlock(resolver, import_specific.definition_block_id); + resolver.local_specifics().Get(pending.local_id).definition_block_id = + definition_block_id; } +} - Context& context_; - SemIR::ImportIRId import_ir_id_; - const SemIR::File& import_ir_; - llvm::SmallVector work_stack_; - // The size of work_stack_ at the start of resolving the current instruction. - size_t initial_work_ = 0; - // Generics that we have partially imported but not yet finished importing. - llvm::SmallVector pending_generics_; - // Specifics that we have partially imported but not yet finished importing. - llvm::SmallVector pending_specifics_; -}; +// Perform any work that we deferred until the end of the main Resolve loop. +auto ImportRefResolver::PerformPendingWork() -> void { + // Note that the individual Finish steps can add new pending work, so keep + // going until we have no more work to do. + while (!pending_generics_.empty() || !pending_specifics_.empty()) { + // Process generics in the order that we added them because a later + // generic might refer to an earlier one, and the calls to + // RebuildGenericEvalBlock assume that the reachable SemIR is in a valid + // state. + // TODO: Import the generic eval block rather than calling + // RebuildGenericEvalBlock to rebuild it so that order doesn't matter. + // NOLINTNEXTLINE(modernize-loop-convert) + for (size_t i = 0; i != pending_generics_.size(); ++i) { + FinishPendingGeneric(*this, pending_generics_[i]); + } + pending_generics_.clear(); + + while (!pending_specifics_.empty()) { + FinishPendingSpecific(*this, pending_specifics_.pop_back_val()); + } + } +} // Returns a list of ImportIRInsts equivalent to the ImportRef currently being // loaded (including the one pointed at directly by the ImportRef), and the