Remove InstId::Builtin members (#4632)

- `InstId::Builtin<Inst>` -> `<Inst>::SingletonInstId`
- `InstId::PackageNamespace` -> `Namespace::PackageInstId`

toolchain/check/call.cpp

@@ -94,7 +94,7 @@ static auto PerformCallToGenericClass(Context& context, SemIR::LocId loc_id,
                           EntityKind::GenericClass, enclosing_specific_id,
                           /*self_id=*/SemIR::InstId::Invalid, arg_ids);
   if (!callee_specific_id) {
-    return SemIR::InstId::BuiltinErrorInst;
+    return SemIR::ErrorInst::SingletonInstId;
   }
   return context.GetOrAddInst<SemIR::ClassType>(
       loc_id, {.type_id = SemIR::TypeType::SingletonTypeId,
@@ -114,7 +114,7 @@ static auto PerformCallToGenericInterface(
                           EntityKind::GenericInterface, enclosing_specific_id,
                           /*self_id=*/SemIR::InstId::Invalid, arg_ids);
   if (!callee_specific_id) {
-    return SemIR::InstId::BuiltinErrorInst;
+    return SemIR::ErrorInst::SingletonInstId;
   }
   return context.GetOrAddInst(loc_id, context.FacetTypeFromInterface(
                                           interface_id, *callee_specific_id));
@@ -144,7 +144,7 @@ auto PerformCall(Context& context, SemIR::LocId loc_id, SemIR::InstId callee_id,
                             "value of type {0} is not callable", TypeOfInstId);
           context.emitter().Emit(loc_id, CallToNonCallable, callee_id);
         }
-        return SemIR::InstId::BuiltinErrorInst;
+        return SemIR::ErrorInst::SingletonInstId;
       }
     }
   }
@@ -156,7 +156,7 @@ auto PerformCall(Context& context, SemIR::LocId loc_id, SemIR::InstId callee_id,
       EntityKind::Function, callee_function.enclosing_specific_id,
       callee_function.self_id, arg_ids);
   if (!callee_specific_id) {
-    return SemIR::InstId::BuiltinErrorInst;
+    return SemIR::ErrorInst::SingletonInstId;
   }
   if (callee_specific_id->is_valid()) {
     callee_id = context.GetOrAddInst(

toolchain/check/check.cpp

@@ -324,7 +324,7 @@ static auto InitPackageScopeAndImports(Context& context, UnitInfo& unit_info,
   // Define the package scope, with an instruction for `package` expressions to
   // reference.
   auto package_scope_id = context.name_scopes().Add(
-      SemIR::InstId::PackageNamespace, SemIR::NameId::PackageNamespace,
+      SemIR::Namespace::PackageInstId, SemIR::NameId::PackageNamespace,
       SemIR::NameScopeId::Invalid);
   CARBON_CHECK(package_scope_id == SemIR::NameScopeId::Package);
 
@@ -332,7 +332,7 @@ static auto InitPackageScopeAndImports(Context& context, UnitInfo& unit_info,
       Parse::NodeId::Invalid, {.type_id = namespace_type_id,
                                .name_scope_id = SemIR::NameScopeId::Package,
                                .import_id = SemIR::InstId::Invalid});
-  CARBON_CHECK(package_inst_id == SemIR::InstId::PackageNamespace);
+  CARBON_CHECK(package_inst_id == SemIR::Namespace::PackageInstId);
 
   // If there is an implicit `api` import, set it first so that it uses the
   // ImportIRId::ApiForImpl when processed for imports.

toolchain/check/context.cpp

@@ -60,10 +60,10 @@ Context::Context(const Lex::TokenizedBuffer& tokens, DiagnosticEmitter& emitter,
   // Map the builtin `<error>` and `type` type constants to their corresponding
   // special `TypeId` values.
   type_ids_for_type_constants_.Insert(
-      SemIR::ConstantId::ForTemplateConstant(SemIR::InstId::BuiltinErrorInst),
+      SemIR::ConstantId::ForTemplateConstant(SemIR::ErrorInst::SingletonInstId),
       SemIR::ErrorInst::SingletonTypeId);
   type_ids_for_type_constants_.Insert(
-      SemIR::ConstantId::ForTemplateConstant(SemIR::InstId::BuiltinTypeType),
+      SemIR::ConstantId::ForTemplateConstant(SemIR::TypeType::SingletonInstId),
       SemIR::TypeType::SingletonTypeId);
 
   // TODO: Remove this and add a `VerifyOnFinish` once we properly push and pop
@@ -355,7 +355,7 @@ auto Context::LookupUnqualifiedName(Parse::NodeId node_id,
   }
 
   return {.specific_id = SemIR::SpecificId::Invalid,
-          .inst_id = SemIR::InstId::BuiltinErrorInst};
+          .inst_id = SemIR::ErrorInst::SingletonInstId};
 }
 
 auto Context::LookupNameInExactScope(SemIRLoc loc, SemIR::NameId name_id,
@@ -583,7 +583,7 @@ auto Context::LookupQualifiedName(SemIRLoc loc, SemIR::NameId name_id,
       emitter_->Emit(loc, NameAmbiguousDueToExtend, name_id);
       // TODO: Add notes pointing to the scopes.
       return {.specific_id = SemIR::SpecificId::Invalid,
-              .inst_id = SemIR::InstId::BuiltinErrorInst};
+              .inst_id = SemIR::ErrorInst::SingletonInstId};
     }
 
     result.inst_id = scope_result_id;
@@ -609,7 +609,7 @@ auto Context::LookupQualifiedName(SemIRLoc loc, SemIR::NameId name_id,
     }
 
     return {.specific_id = SemIR::SpecificId::Invalid,
-            .inst_id = SemIR::InstId::BuiltinErrorInst};
+            .inst_id = SemIR::ErrorInst::SingletonInstId};
   }
 
   return result;
@@ -653,7 +653,7 @@ auto Context::LookupNameInCore(SemIRLoc loc, llvm::StringRef name)
     -> SemIR::InstId {
   auto core_package_id = GetCorePackage(*this, loc, name);
   if (!core_package_id.is_valid()) {
-    return SemIR::InstId::BuiltinErrorInst;
+    return SemIR::ErrorInst::SingletonInstId;
   }
 
   auto name_id = SemIR::NameId::ForIdentifier(identifiers().Add(name));
@@ -665,7 +665,7 @@ auto Context::LookupNameInCore(SemIRLoc loc, llvm::StringRef name)
         "name `Core.{0}` implicitly referenced here, but not found",
         SemIR::NameId);
     emitter_->Emit(loc, CoreNameNotFound, name_id);
-    return SemIR::InstId::BuiltinErrorInst;
+    return SemIR::ErrorInst::SingletonInstId;
   }
 
   // Look through import_refs and aliases.

toolchain/check/convert.cpp

@@ -249,7 +249,7 @@ static auto ConvertTupleToArray(Context& context, SemIR::TupleType tuple_type,
                                ? ArrayInitFromExprArgCountMismatch
                                : ArrayInitFromLiteralArgCountMismatch,
                            array_bound, tuple_elem_types.size());
-    return SemIR::InstId::BuiltinErrorInst;
+    return SemIR::ErrorInst::SingletonInstId;
   }
 
   PendingBlock target_block_storage(context);
@@ -278,8 +278,8 @@ static auto ConvertTupleToArray(Context& context, SemIR::TupleType tuple_type,
             context, value_loc_id, value_id, src_type_id, literal_elems,
             ConversionTarget::FullInitializer, return_slot_arg_id,
             array_type.element_type_id, target_block, i, i);
-    if (init_id == SemIR::InstId::BuiltinErrorInst) {
-      return SemIR::InstId::BuiltinErrorInst;
+    if (init_id == SemIR::ErrorInst::SingletonInstId) {
+      return SemIR::ErrorInst::SingletonInstId;
     }
     inits.push_back(init_id);
   }
@@ -327,7 +327,7 @@ static auto ConvertTupleToTuple(Context& context, SemIR::TupleType src_type,
                       IntAsSelect, IntAsSelect);
     context.emitter().Emit(value_loc_id, TupleInitElementCountMismatch,
                            dest_elem_types.size(), src_elem_types.size());
-    return SemIR::InstId::BuiltinErrorInst;
+    return SemIR::ErrorInst::SingletonInstId;
   }
 
   // If we're forming an initializer, then we want an initializer for each
@@ -359,8 +359,8 @@ static auto ConvertTupleToTuple(Context& context, SemIR::TupleType src_type,
         ConvertAggregateElement<SemIR::TupleAccess, SemIR::TupleAccess>(
             context, value_loc_id, value_id, src_type_id, literal_elems,
             inner_kind, target.init_id, dest_type_id, target.init_block, i, i);
-    if (init_id == SemIR::InstId::BuiltinErrorInst) {
-      return SemIR::InstId::BuiltinErrorInst;
+    if (init_id == SemIR::ErrorInst::SingletonInstId) {
+      return SemIR::ErrorInst::SingletonInstId;
     }
     new_block.Set(i, init_id);
   }
@@ -426,7 +426,7 @@ static auto ConvertStructToStructOrClass(Context& context,
     context.emitter().Emit(value_loc_id, StructInitElementCountMismatch,
                            ToClass, dest_elem_fields_size,
                            src_elem_fields.size());
-    return SemIR::InstId::BuiltinErrorInst;
+    return SemIR::ErrorInst::SingletonInstId;
   }
 
   // Prepare to look up fields in the source by index.
@@ -462,7 +462,7 @@ static auto ConvertStructToStructOrClass(Context& context,
   for (auto [i, dest_field] : llvm::enumerate(dest_elem_fields)) {
     if (dest_field.name_id == SemIR::NameId::Vptr) {
       // TODO: Initialize the vptr to point to a vtable.
-      new_block.Set(i, SemIR::InstId::BuiltinErrorInst);
+      new_block.Set(i, SemIR::ErrorInst::SingletonInstId);
       continue;
     }
 
@@ -488,7 +488,7 @@ static auto ConvertStructToStructOrClass(Context& context,
                                  StructInitMissingFieldInConversion, value_id,
                                  target.type_id, dest_field.name_id);
         }
-        return SemIR::InstId::BuiltinErrorInst;
+        return SemIR::ErrorInst::SingletonInstId;
       }
     }
     auto src_field = src_elem_fields[src_field_index];
@@ -500,8 +500,8 @@ static auto ConvertStructToStructOrClass(Context& context,
             context, value_loc_id, value_id, src_field.type_id, literal_elems,
             inner_kind, target.init_id, dest_field.type_id, target.init_block,
             src_field_index, src_field_index + dest_vptr_offset);
-    if (init_id == SemIR::InstId::BuiltinErrorInst) {
-      return SemIR::InstId::BuiltinErrorInst;
+    if (init_id == SemIR::ErrorInst::SingletonInstId) {
+      return SemIR::ErrorInst::SingletonInstId;
     }
     new_block.Set(i, init_id);
   }
@@ -551,7 +551,7 @@ static auto ConvertStructToClass(Context& context, SemIR::StructType src_type,
   auto object_repr_id =
       dest_class_info.GetObjectRepr(context.sem_ir(), dest_type.specific_id);
   if (object_repr_id == SemIR::ErrorInst::SingletonTypeId) {
-    return SemIR::InstId::BuiltinErrorInst;
+    return SemIR::ErrorInst::SingletonInstId;
   }
   auto dest_struct_type =
       context.types().GetAs<SemIR::StructType>(object_repr_id);
@@ -914,7 +914,7 @@ static auto PerformCopy(Context& context, SemIR::InstId expr_id)
   auto expr = context.insts().Get(expr_id);
   auto type_id = expr.type_id();
   if (type_id == SemIR::ErrorInst::SingletonTypeId) {
-    return SemIR::InstId::BuiltinErrorInst;
+    return SemIR::ErrorInst::SingletonInstId;
   }
 
   // TODO: Directly track on the value representation whether it's a copy of
@@ -933,7 +933,7 @@ static auto PerformCopy(Context& context, SemIR::InstId expr_id)
   CARBON_DIAGNOSTIC(CopyOfUncopyableType, Error,
                     "cannot copy value of type {0}", TypeOfInstId);
   context.emitter().Emit(expr_id, CopyOfUncopyableType, expr_id);
-  return SemIR::InstId::BuiltinErrorInst;
+  return SemIR::ErrorInst::SingletonInstId;
 }
 
 auto Convert(Context& context, SemIR::LocId loc_id, SemIR::InstId expr_id,
@@ -946,7 +946,7 @@ auto Convert(Context& context, SemIR::LocId loc_id, SemIR::InstId expr_id,
   if (sem_ir.insts().Get(expr_id).type_id() ==
           SemIR::ErrorInst::SingletonTypeId ||
       target.type_id == SemIR::ErrorInst::SingletonTypeId) {
-    return SemIR::InstId::BuiltinErrorInst;
+    return SemIR::ErrorInst::SingletonInstId;
   }
 
   if (SemIR::GetExprCategory(sem_ir, expr_id) == SemIR::ExprCategory::NotExpr) {
@@ -956,7 +956,7 @@ auto Convert(Context& context, SemIR::LocId loc_id, SemIR::InstId expr_id,
     CARBON_DIAGNOSTIC(UseOfNonExprAsValue, Error,
                       "expression cannot be used as a value");
     context.emitter().Emit(expr_id, UseOfNonExprAsValue);
-    return SemIR::InstId::BuiltinErrorInst;
+    return SemIR::ErrorInst::SingletonInstId;
   }
 
   // We can only perform initialization for complete types.
@@ -989,12 +989,12 @@ auto Convert(Context& context, SemIR::LocId loc_id, SemIR::InstId expr_id,
             return context.emitter().Build(loc_id, AbstractTypeInInit,
                                            target.type_id);
           })) {
-    return SemIR::InstId::BuiltinErrorInst;
+    return SemIR::ErrorInst::SingletonInstId;
   }
 
   // Check whether any builtin conversion applies.
   expr_id = PerformBuiltinConversion(context, loc_id, expr_id, target);
-  if (expr_id == SemIR::InstId::BuiltinErrorInst) {
+  if (expr_id == SemIR::ErrorInst::SingletonInstId) {
     return expr_id;
   }
 
@@ -1024,7 +1024,7 @@ auto Convert(Context& context, SemIR::LocId loc_id, SemIR::InstId expr_id,
     });
 
     // Pull a value directly out of the initializer if possible and wanted.
-    if (expr_id != SemIR::InstId::BuiltinErrorInst &&
+    if (expr_id != SemIR::ErrorInst::SingletonInstId &&
         CanUseValueOfInitializer(sem_ir, target.type_id, target.kind)) {
       expr_id = context.AddInst<SemIR::ValueOfInitializer>(
           loc_id, {.type_id = target.type_id, .init_id = expr_id});
@@ -1053,7 +1053,7 @@ auto Convert(Context& context, SemIR::LocId loc_id, SemIR::InstId expr_id,
                    sem_ir.insts().Get(expr_id));
 
     case SemIR::ExprCategory::Error:
-      return SemIR::InstId::BuiltinErrorInst;
+      return SemIR::ErrorInst::SingletonInstId;
 
     case SemIR::ExprCategory::Initializing:
       if (target.is_initializer()) {
@@ -1206,7 +1206,7 @@ auto ConvertCallArgs(Context& context, SemIR::LocId call_loc_id,
         .Build(call_loc_id, MissingObjectInMethodCall)
         .Note(callee_decl_id, InCallToFunction)
         .Emit();
-    self_id = SemIR::InstId::BuiltinErrorInst;
+    self_id = SemIR::ErrorInst::SingletonInstId;
   }
 
   return CallerPatternMatch(context, callee_specific_id, self_param_id,
@@ -1218,7 +1218,7 @@ auto ExprAsType(Context& context, SemIR::LocId loc_id, SemIR::InstId value_id)
     -> TypeExpr {
   auto type_inst_id = ConvertToValueOfType(context, loc_id, value_id,
                                            SemIR::TypeType::SingletonTypeId);
-  if (type_inst_id == SemIR::InstId::BuiltinErrorInst) {
+  if (type_inst_id == SemIR::ErrorInst::SingletonInstId) {
     return {.inst_id = type_inst_id,
             .type_id = SemIR::ErrorInst::SingletonTypeId};
   }
@@ -1228,7 +1228,7 @@ auto ExprAsType(Context& context, SemIR::LocId loc_id, SemIR::InstId value_id)
     CARBON_DIAGNOSTIC(TypeExprEvaluationFailure, Error,
                       "cannot evaluate type expression");
     context.emitter().Emit(loc_id, TypeExprEvaluationFailure);
-    return {.inst_id = SemIR::InstId::BuiltinErrorInst,
+    return {.inst_id = SemIR::ErrorInst::SingletonInstId,
             .type_id = SemIR::ErrorInst::SingletonTypeId};
   }
 

toolchain/check/convert.h

@@ -102,7 +102,7 @@ auto ConvertCallArgs(Context& context, SemIR::LocId call_loc_id,
 
 // A type that has been converted for use as a type expression.
 struct TypeExpr {
-  // The converted expression of type `type`, or `InstId::BuiltinErrorInst`.
+  // The converted expression of type `type`, or `ErrorInst::SingletonInstId`.
   SemIR::InstId inst_id;
   // The corresponding type, or `ErrorInst::SingletonTypeId`.
   SemIR::TypeId type_id;

toolchain/check/deduce.cpp

@@ -324,7 +324,7 @@ auto DeductionContext::Deduce() -> bool {
       DiagnosticAnnotationScope annotate_diagnostics(&context().emitter(),
                                                      note_initializing_param);
       arg_id = ConvertToValueOfType(context(), loc_id_, arg_id, param_type_id);
-      if (arg_id == SemIR::InstId::BuiltinErrorInst) {
+      if (arg_id == SemIR::ErrorInst::SingletonInstId) {
         return false;
       }
     }

toolchain/check/eval.cpp

@@ -1092,7 +1092,7 @@ static auto MakeConstantForBuiltinCall(Context& context, SemIRLoc loc,
 
     case SemIR::BuiltinFunctionKind::IntLiteralMakeType: {
       return context.constant_values().Get(
-          SemIR::InstId::BuiltinIntLiteralType);
+          SemIR::IntLiteralType::SingletonInstId);
     }
 
     case SemIR::BuiltinFunctionKind::IntMakeTypeSigned: {
@@ -1114,11 +1114,11 @@ static auto MakeConstantForBuiltinCall(Context& context, SemIRLoc loc,
         return SemIR::ErrorInst::SingletonConstantId;
       }
       return context.constant_values().Get(
-          SemIR::InstId::BuiltinLegacyFloatType);
+          SemIR::LegacyFloatType::SingletonInstId);
     }
 
     case SemIR::BuiltinFunctionKind::BoolMakeType: {
-      return context.constant_values().Get(SemIR::InstId::BuiltinBoolType);
+      return context.constant_values().Get(SemIR::BoolType::SingletonInstId);
     }
 
     // Integer conversions.
@@ -1826,7 +1826,7 @@ auto TryEvalBlockForSpecific(Context& context, SemIR::SpecificId specific_id,
     result[i] = context.constant_values().GetInstId(const_id);
 
     // TODO: If this becomes possible through monomorphization failure, produce
-    // a diagnostic and put `SemIR::InstId::BuiltinErrorInst` in the table
+    // a diagnostic and put `SemIR::ErrorInst::SingletonInstId` in the table
     // entry.
     CARBON_CHECK(result[i].is_valid());
   }

toolchain/check/handle_alias.cpp

@@ -62,7 +62,7 @@ auto HandleParseNode(Context& context, Parse::AliasId /*node_id*/) -> bool {
                       "alias initializer must be a name reference");
     context.emitter().Emit(expr_node, AliasRequiresNameRef);
     alias_type_id = SemIR::ErrorInst::SingletonTypeId;
-    alias_value_id = SemIR::InstId::BuiltinErrorInst;
+    alias_value_id = SemIR::ErrorInst::SingletonInstId;
   }
   auto alias_id = context.AddInst<SemIR::BindAlias>(
       name_context.loc_id, {.type_id = alias_type_id,

toolchain/check/handle_array.cpp

@@ -46,7 +46,7 @@ auto HandleParseNode(Context& context, Parse::ArrayExprId node_id) -> bool {
   if (!context.constant_values().Get(bound_inst_id).is_constant()) {
     CARBON_DIAGNOSTIC(InvalidArrayExpr, Error, "array bound is not a constant");
     context.emitter().Emit(bound_inst_id, InvalidArrayExpr);
-    context.node_stack().Push(node_id, SemIR::InstId::BuiltinErrorInst);
+    context.node_stack().Push(node_id, SemIR::ErrorInst::SingletonInstId);
     return true;
   }
 

toolchain/check/handle_binding_pattern.cpp

@@ -197,10 +197,10 @@ static auto HandleAnyBindingPattern(Context& context, Parse::NodeId node_id,
           break;
       }
       if (had_error) {
-        context.AddNameToLookup(name_id, SemIR::InstId::BuiltinErrorInst);
+        context.AddNameToLookup(name_id, SemIR::ErrorInst::SingletonInstId);
         // Replace the parameter with an invalid instruction so that we don't
         // try constructing a generic based on it.
-        param_pattern_id = SemIR::InstId::BuiltinErrorInst;
+        param_pattern_id = SemIR::ErrorInst::SingletonInstId;
       } else {
         auto bind_id = context.AddInstInNoBlock(
             make_bind_name(cast_type_id, SemIR::InstId::Invalid));

toolchain/check/handle_class.cpp

@@ -400,7 +400,7 @@ auto HandleParseNode(Context& context, Parse::AdaptDeclId node_id) -> bool {
                                        adapted_inst_id);
       });
   if (adapted_type_id == SemIR::ErrorInst::SingletonTypeId) {
-    adapted_inst_id = SemIR::InstId::BuiltinErrorInst;
+    adapted_inst_id = SemIR::ErrorInst::SingletonInstId;
   }
 
   // Build a SemIR representation for the declaration.
@@ -439,7 +439,7 @@ struct BaseInfo {
 constexpr BaseInfo BaseInfo::Error = {
     .type_id = SemIR::ErrorInst::SingletonTypeId,
     .scope_id = SemIR::NameScopeId::Invalid,
-    .inst_id = SemIR::InstId::BuiltinErrorInst};
+    .inst_id = SemIR::ErrorInst::SingletonInstId};
 }  // namespace
 
 // Diagnoses an attempt to derive from a final type.
@@ -577,7 +577,7 @@ static auto CheckCompleteAdapterClassType(Context& context,
         .Build(class_info.adapt_id, AdaptWithBase)
         .Note(class_info.base_id, AdaptWithBaseHere)
         .Emit();
-    return SemIR::InstId::BuiltinErrorInst;
+    return SemIR::ErrorInst::SingletonInstId;
   }
 
   auto field_decls = context.field_decls_stack().PeekArray();
@@ -589,7 +589,7 @@ static auto CheckCompleteAdapterClassType(Context& context,
         .Build(class_info.adapt_id, AdaptWithFields)
         .Note(field_decls.front(), AdaptWithFieldHere)
         .Emit();
-    return SemIR::InstId::BuiltinErrorInst;
+    return SemIR::ErrorInst::SingletonInstId;
   }
 
   for (auto inst_id : context.inst_block_stack().PeekCurrentBlockContents()) {
@@ -606,7 +606,7 @@ static auto CheckCompleteAdapterClassType(Context& context,
             .Build(class_info.adapt_id, AdaptWithVirtual)
             .Note(inst_id, AdaptWithVirtualHere)
             .Emit();
-        return SemIR::InstId::BuiltinErrorInst;
+        return SemIR::ErrorInst::SingletonInstId;
       }
     }
   }

toolchain/check/handle_function.cpp

@@ -355,7 +355,7 @@ static auto HandleFunctionDefinitionAfterSignature(
   }
   // Check the parameter types are complete.
   for (auto param_ref_id : params_to_complete) {
-    if (param_ref_id == SemIR::InstId::BuiltinErrorInst) {
+    if (param_ref_id == SemIR::ErrorInst::SingletonInstId) {
       continue;
     }
 

toolchain/check/handle_if_expr.cpp

@@ -38,7 +38,7 @@ static auto DecayIntLiteralToSizedInt(Context& context, Parse::NodeId node_id,
                                       SemIR::InstId operand_id)
     -> SemIR::InstId {
   if (context.types().GetInstId(context.insts().Get(operand_id).type_id()) ==
-      SemIR::InstId::BuiltinIntLiteralType) {
+      SemIR::IntLiteralType::SingletonInstId) {
     operand_id = ConvertToValueOfType(
         context, node_id, operand_id,
         MakeIntType(context, node_id, SemIR::IntKind::Signed,

toolchain/check/handle_index.cpp

@@ -98,7 +98,7 @@ static auto PerformIndexWith(Context& context, Parse::NodeId node_id,
     CARBON_DIAGNOSTIC(TypeNotIndexable, Error,
                       "type {0} does not support indexing", SemIR::TypeId);
     context.emitter().Emit(node_id, TypeNotIndexable, operand_type_id);
-    return SemIR::InstId::BuiltinErrorInst;
+    return SemIR::ErrorInst::SingletonInstId;
   }
 
   Operator op{
@@ -164,7 +164,7 @@ auto HandleParseNode(Context& context, Parse::IndexExprId node_id) -> bool {
     }
 
     default: {
-      auto elem_id = SemIR::InstId::BuiltinErrorInst;
+      auto elem_id = SemIR::ErrorInst::SingletonInstId;
       if (operand_type_id != SemIR::ErrorInst::SingletonTypeId) {
         elem_id = PerformIndexWith(context, node_id, operand_inst_id,
                                    operand_type_id, index_inst_id);

toolchain/check/handle_let_and_var.cpp

@@ -246,7 +246,7 @@ auto HandleParseNode(Context& context, Parse::LetDeclId node_id) -> bool {
   CARBON_CHECK(!bind_name.value_id.is_valid(),
                "Binding should not already have a value!");
   bind_name.value_id = decl_info->init_id ? *decl_info->init_id
-                                          : SemIR::InstId::BuiltinErrorInst;
+                                          : SemIR::ErrorInst::SingletonInstId;
   context.ReplaceInstBeforeConstantUse(decl_info->pattern_id, bind_name);
   context.inst_block_stack().AddInstId(decl_info->pattern_id);
 

toolchain/check/handle_literal.cpp

@@ -55,7 +55,7 @@ auto HandleParseNode(Context& context, Parse::RealLiteralId node_id) -> bool {
                       llvm::APSInt);
     context.emitter().Emit(node_id, RealMantissaTooLargeForI64,
                            llvm::APSInt(real_value.mantissa, true));
-    context.node_stack().Push(node_id, SemIR::InstId::BuiltinErrorInst);
+    context.node_stack().Push(node_id, SemIR::ErrorInst::SingletonInstId);
     return true;
   }
 
@@ -65,7 +65,7 @@ auto HandleParseNode(Context& context, Parse::RealLiteralId node_id) -> bool {
                       llvm::APSInt);
     context.emitter().Emit(node_id, RealExponentTooLargeForI64,
                            llvm::APSInt(real_value.exponent, false));
-    context.node_stack().Push(node_id, SemIR::InstId::BuiltinErrorInst);
+    context.node_stack().Push(node_id, SemIR::ErrorInst::SingletonInstId);
     return true;
   }
 
@@ -151,13 +151,13 @@ auto HandleParseNode(Context& context, Parse::FloatTypeLiteralId node_id)
 
 auto HandleParseNode(Context& context, Parse::StringTypeLiteralId node_id)
     -> bool {
-  context.node_stack().Push(node_id, SemIR::InstId::BuiltinStringType);
+  context.node_stack().Push(node_id, SemIR::StringType::SingletonInstId);
   return true;
 }
 
 auto HandleParseNode(Context& context, Parse::TypeTypeLiteralId node_id)
     -> bool {
-  context.node_stack().Push(node_id, SemIR::InstId::BuiltinTypeType);
+  context.node_stack().Push(node_id, SemIR::TypeType::SingletonInstId);
   return true;
 }
 

toolchain/check/handle_name.cpp

@@ -225,7 +225,7 @@ auto HandleParseNode(Context& context, Parse::PackageExprId node_id) -> bool {
       node_id,
       {.type_id = context.GetBuiltinType(SemIR::BuiltinInstKind::NamespaceType),
        .name_id = SemIR::NameId::PackageNamespace,
-       .value_id = SemIR::InstId::PackageNamespace});
+       .value_id = SemIR::Namespace::PackageInstId});
   return true;
 }
 

toolchain/check/handle_operator.cpp

@@ -233,13 +233,13 @@ auto HandleParseNode(Context& context, Parse::PrefixOperatorAmpId node_id)
       CARBON_DIAGNOSTIC(AddrOfEphemeralRef, Error,
                         "cannot take the address of a temporary object");
       context.emitter().Emit(TokenOnly(node_id), AddrOfEphemeralRef);
-      value_id = SemIR::InstId::BuiltinErrorInst;
+      value_id = SemIR::ErrorInst::SingletonInstId;
       break;
     default:
       CARBON_DIAGNOSTIC(AddrOfNonRef, Error,
                         "cannot take the address of non-reference expression");
       context.emitter().Emit(TokenOnly(node_id), AddrOfNonRef);
-      value_id = SemIR::InstId::BuiltinErrorInst;
+      value_id = SemIR::ErrorInst::SingletonInstId;
       break;
   }
   context.AddInstAndPush<SemIR::AddrOf>(

toolchain/check/handle_struct.cpp

@@ -139,7 +139,7 @@ auto HandleParseNode(Context& context, Parse::StructLiteralId node_id) -> bool {
 
   if (DiagnoseDuplicateNames(context, field_name_nodes, fields,
                              /*is_struct_type_literal=*/false)) {
-    context.node_stack().Push(node_id, SemIR::InstId::BuiltinErrorInst);
+    context.node_stack().Push(node_id, SemIR::ErrorInst::SingletonInstId);
   } else {
     auto type_id = context.GetStructType(
         context.struct_type_fields().AddCanonical(fields));
@@ -165,7 +165,7 @@ auto HandleParseNode(Context& context, Parse::StructTypeLiteralId node_id)
 
   if (DiagnoseDuplicateNames(context, field_name_nodes, fields,
                              /*is_struct_type_literal=*/true)) {
-    context.node_stack().Push(node_id, SemIR::InstId::BuiltinErrorInst);
+    context.node_stack().Push(node_id, SemIR::ErrorInst::SingletonInstId);
   } else {
     auto fields_id = context.struct_type_fields().AddCanonical(fields);
     context.AddInstAndPush<SemIR::StructType>(

toolchain/check/handle_where.cpp

@@ -100,7 +100,7 @@ auto HandleParseNode(Context& context, Parse::RequirementImplsId node_id)
         ImplsOnNonFacetType, Error,
         "right argument of `impls` requirement must be a facet type");
     context.emitter().Emit(rhs_node, ImplsOnNonFacetType);
-    rhs_as_type.inst_id = SemIR::InstId::BuiltinErrorInst;
+    rhs_as_type.inst_id = SemIR::ErrorInst::SingletonInstId;
   }
   // TODO: Require that at least one side uses a designator.
 

toolchain/check/impl.cpp

@@ -107,7 +107,7 @@ static auto CheckAssociatedFunctionImplementation(
                            interface_function_type.function_id);
     builder.Emit();
 
-    return SemIR::InstId::BuiltinErrorInst;
+    return SemIR::ErrorInst::SingletonInstId;
   }
 
   // Map from the specific for the function type to the specific for the
@@ -129,7 +129,7 @@ static auto CheckAssociatedFunctionImplementation(
           context.functions().Get(interface_function_type.function_id),
           interface_function_specific_id,
           /*check_syntax=*/false)) {
-    return SemIR::InstId::BuiltinErrorInst;
+    return SemIR::ErrorInst::SingletonInstId;
   }
   return impl_decl_id;
 }
@@ -150,7 +150,7 @@ static auto BuildInterfaceWitness(
         return context.emitter().Build(
             impl.definition_id, ImplOfUndefinedInterface, interface.name_id);
       })) {
-    return SemIR::InstId::BuiltinErrorInst;
+    return SemIR::ErrorInst::SingletonInstId;
   }
 
   auto& impl_scope = context.name_scopes().Get(impl.scope_id);
@@ -171,7 +171,7 @@ static auto BuildInterfaceWitness(
     CARBON_KIND_SWITCH(decl) {
       case CARBON_KIND(SemIR::StructValue struct_value): {
         if (struct_value.type_id == SemIR::ErrorInst::SingletonTypeId) {
-          return SemIR::InstId::BuiltinErrorInst;
+          return SemIR::ErrorInst::SingletonInstId;
         }
         auto type_inst = context.types().GetAsInst(struct_value.type_id);
         auto fn_type = type_inst.TryAs<SemIR::FunctionType>();
@@ -196,7 +196,7 @@ static auto BuildInterfaceWitness(
           NoteAssociatedFunction(context, builder, fn_type->function_id);
           builder.Emit();
 
-          table.push_back(SemIR::InstId::BuiltinErrorInst);
+          table.push_back(SemIR::ErrorInst::SingletonInstId);
         }
         break;
       }
@@ -206,12 +206,12 @@ static auto BuildInterfaceWitness(
             impl.definition_id,
             "impl of interface with associated constant " +
                 context.names().GetFormatted(associated.name_id).str());
-        return SemIR::InstId::BuiltinErrorInst;
+        return SemIR::ErrorInst::SingletonInstId;
       }
       default:
-        CARBON_CHECK(decl_id == SemIR::InstId::BuiltinErrorInst,
+        CARBON_CHECK(decl_id == SemIR::ErrorInst::SingletonInstId,
                      "Unexpected kind of associated entity {0}", decl);
-        table.push_back(SemIR::InstId::BuiltinErrorInst);
+        table.push_back(SemIR::ErrorInst::SingletonInstId);
         break;
     }
   }
@@ -230,13 +230,13 @@ auto BuildImplWitness(Context& context, SemIR::ImplId impl_id)
 
   auto facet_type_id = context.GetTypeIdForTypeInst(impl.constraint_id);
   if (facet_type_id == SemIR::ErrorInst::SingletonTypeId) {
-    return SemIR::InstId::BuiltinErrorInst;
+    return SemIR::ErrorInst::SingletonInstId;
   }
   auto facet_type = context.types().TryGetAs<SemIR::FacetType>(facet_type_id);
   if (!facet_type) {
     CARBON_DIAGNOSTIC(ImplAsNonFacetType, Error, "impl as non-facet-type");
     context.emitter().Emit(impl.definition_id, ImplAsNonFacetType);
-    return SemIR::InstId::BuiltinErrorInst;
+    return SemIR::ErrorInst::SingletonInstId;
   }
   const SemIR::FacetTypeInfo& facet_type_info =
       context.facet_types().Get(facet_type->facet_type_id);
@@ -244,7 +244,7 @@ auto BuildImplWitness(Context& context, SemIR::ImplId impl_id)
   auto interface = facet_type_info.TryAsSingleInterface();
   if (!interface) {
     context.TODO(impl.definition_id, "impl as not 1 interface");
-    return SemIR::InstId::BuiltinErrorInst;
+    return SemIR::ErrorInst::SingletonInstId;
   }
 
   llvm::SmallVector<SemIR::InstId> used_decl_ids;

toolchain/check/import.cpp

@@ -366,8 +366,8 @@ static auto ImportScopeFromApiFile(Context& context,
 auto ImportApiFile(Context& context, SemIR::TypeId namespace_type_id,
                    const SemIR::File& api_sem_ir) -> void {
   context.import_ir_constant_values()[SemIR::ImportIRId::ApiForImpl.index].Set(
-      SemIR::InstId::PackageNamespace,
-      context.constant_values().Get(SemIR::InstId::PackageNamespace));
+      SemIR::Namespace::PackageInstId,
+      context.constant_values().Get(SemIR::Namespace::PackageInstId));
 
   llvm::SmallVector<TodoScope> todo_scopes = {};
   ImportScopeFromApiFile(context, api_sem_ir, SemIR::NameScopeId::Package,
@@ -393,8 +393,8 @@ auto ImportLibrariesFromCurrentPackage(
     auto ir_id = AddImportIR(context, import_ir);
 
     context.import_ir_constant_values()[ir_id.index].Set(
-        SemIR::InstId::PackageNamespace,
-        context.constant_values().Get(SemIR::InstId::PackageNamespace));
+        SemIR::Namespace::PackageInstId,
+        context.constant_values().Get(SemIR::Namespace::PackageInstId));
 
     for (const auto import_inst_id :
          import_ir.sem_ir->inst_blocks().Get(SemIR::InstBlockId::Exports)) {
@@ -455,7 +455,7 @@ auto ImportLibrariesFromOtherPackage(Context& context,
     auto ir_id = AddImportIR(context, import_ir);
     scope.import_ir_scopes.push_back({ir_id, SemIR::NameScopeId::Package});
     context.import_ir_constant_values()[ir_id.index].Set(
-        SemIR::InstId::PackageNamespace, namespace_const_id);
+        SemIR::Namespace::PackageInstId, namespace_const_id);
   }
   if (has_load_error) {
     scope.has_error = has_load_error;

toolchain/check/import_ref.cpp

@@ -1139,7 +1139,7 @@ static auto GetLocalNameScopeId(ImportRefResolver& resolver,
       break;
     }
     default: {
-      if (const_inst_id == SemIR::InstId::BuiltinErrorInst) {
+      if (const_inst_id == SemIR::ErrorInst::SingletonInstId) {
         return SemIR::NameScopeId::Invalid;
       }
       break;
@@ -1614,7 +1614,7 @@ static auto TryResolveTypedInst(ImportRefResolver& resolver,
                                 SemIR::CompleteTypeWitness inst)
     -> ResolveResult {
   CARBON_CHECK(resolver.import_types().GetInstId(inst.type_id) ==
-               SemIR::InstId::BuiltinWitnessType);
+               SemIR::WitnessType::SingletonInstId);
   auto object_repr_const_id = GetLocalConstantId(resolver, inst.object_repr_id);
   if (resolver.HasNewWork()) {
     return ResolveResult::Retry();

toolchain/check/interface.cpp

@@ -18,7 +18,7 @@ auto BuildAssociatedEntity(Context& context, SemIR::InterfaceId interface_id,
     // This should only happen if the interface is erroneously defined more than
     // once.
     // TODO: Find a way to CHECK this.
-    return SemIR::InstId::BuiltinErrorInst;
+    return SemIR::ErrorInst::SingletonInstId;
   }
 
   // The interface type is the type of `Self`.

toolchain/check/member_access.cpp

@@ -143,17 +143,17 @@ static auto AccessMemberOfInterfaceWitness(
     -> SemIR::InstId {
   auto member_value_id = context.constant_values().GetConstantInstId(member_id);
   if (!member_value_id.is_valid()) {
-    if (member_value_id != SemIR::InstId::BuiltinErrorInst) {
+    if (member_value_id != SemIR::ErrorInst::SingletonInstId) {
       context.TODO(member_id, "non-constant associated entity");
     }
-    return SemIR::InstId::BuiltinErrorInst;
+    return SemIR::ErrorInst::SingletonInstId;
   }
 
   auto assoc_entity =
       context.insts().TryGetAs<SemIR::AssociatedEntity>(member_value_id);
   if (!assoc_entity) {
     context.TODO(member_id, "unexpected value for associated entity");
-    return SemIR::InstId::BuiltinErrorInst;
+    return SemIR::ErrorInst::SingletonInstId;
   }
 
   // TODO: This produces the type of the associated entity with no value for
@@ -181,7 +181,7 @@ static auto PerformImplLookup(
     context.TODO(loc_id,
                  "Lookup of impl witness not yet supported except for a single "
                  "interface");
-    return SemIR::InstId::BuiltinErrorInst;
+    return SemIR::ErrorInst::SingletonInstId;
   }
 
   auto witness_id =
@@ -209,7 +209,7 @@ static auto PerformImplLookup(
                              interface_type_id,
                              context.GetTypeIdForTypeConstant(type_const_id));
     }
-    return SemIR::InstId::BuiltinErrorInst;
+    return SemIR::ErrorInst::SingletonInstId;
   }
   return AccessMemberOfInterfaceWitness(context, loc_id, witness_id,
                                         interface_type->specific_id, assoc_type,
@@ -236,7 +236,7 @@ static auto LookupMemberNameInScope(Context& context, SemIR::LocId loc_id,
                                   /*required=*/true, access_info);
 
   if (!result.inst_id.is_valid()) {
-    return SemIR::InstId::BuiltinErrorInst;
+    return SemIR::ErrorInst::SingletonInstId;
   }
 
   // TODO: This duplicates the work that HandleNameAsExpr does. Factor this out.
@@ -310,7 +310,7 @@ static auto LookupMemberNameInScope(Context& context, SemIR::LocId loc_id,
           context.TODO(member_id,
                        "associated entity not found in facet type, need to do "
                        "impl lookup");
-          return SemIR::InstId::BuiltinErrorInst;
+          return SemIR::ErrorInst::SingletonInstId;
         }
 
         member_id = AccessMemberOfInterfaceWitness(
@@ -432,7 +432,7 @@ auto PerformMemberAccess(Context& context, SemIR::LocId loc_id,
         return context.emitter().Build(base_id, IncompleteTypeInMemberAccess,
                                        base_id);
       })) {
-    return SemIR::InstId::BuiltinErrorInst;
+    return SemIR::ErrorInst::SingletonInstId;
   }
 
   // Materialize a temporary for the base expression if necessary.
@@ -464,7 +464,7 @@ auto PerformMemberAccess(Context& context, SemIR::LocId loc_id,
                         SemIR::NameId);
       context.emitter().Emit(loc_id, QualifiedExprNameNotFound, base_id,
                              name_id);
-      return SemIR::InstId::BuiltinErrorInst;
+      return SemIR::ErrorInst::SingletonInstId;
     }
 
     if (base_type_id != SemIR::ErrorInst::SingletonTypeId) {
@@ -473,7 +473,7 @@ auto PerformMemberAccess(Context& context, SemIR::LocId loc_id,
                         TypeOfInstId);
       context.emitter().Emit(loc_id, QualifiedExprUnsupported, base_id);
     }
-    return SemIR::InstId::BuiltinErrorInst;
+    return SemIR::ErrorInst::SingletonInstId;
   }
 
   // Perform lookup into the base type.
@@ -540,7 +540,7 @@ auto PerformTupleAccess(Context& context, SemIR::LocId loc_id,
                       "tuples can be indexed that way",
                       TypeOfInstId);
     context.emitter().Emit(loc_id, TupleIndexOnANonTupleType, tuple_inst_id);
-    return SemIR::InstId::BuiltinErrorInst;
+    return SemIR::ErrorInst::SingletonInstId;
   }
 
   auto diag_non_constant_index = [&] {
@@ -548,7 +548,7 @@ auto PerformTupleAccess(Context& context, SemIR::LocId loc_id,
     CARBON_DIAGNOSTIC(TupleIndexNotConstant, Error,
                       "tuple index must be a constant");
     context.emitter().Emit(loc_id, TupleIndexNotConstant);
-    return SemIR::InstId::BuiltinErrorInst;
+    return SemIR::ErrorInst::SingletonInstId;
   };
   // Diagnose a non-constant index prior to conversion to IntLiteral, because
   // the conversion will fail if the index is not constant.
@@ -563,7 +563,7 @@ auto PerformTupleAccess(Context& context, SemIR::LocId loc_id,
       context.GetBuiltinType(SemIR::BuiltinInstKind::IntLiteralType));
   auto index_const_id = context.constant_values().Get(index_inst_id);
   if (index_const_id == SemIR::ErrorInst::SingletonConstantId) {
-    return SemIR::InstId::BuiltinErrorInst;
+    return SemIR::ErrorInst::SingletonInstId;
   } else if (!index_const_id.is_template()) {
     return diag_non_constant_index();
   }
@@ -574,7 +574,7 @@ auto PerformTupleAccess(Context& context, SemIR::LocId loc_id,
   std::optional<llvm::APInt> index_val = ValidateTupleIndex(
       context, loc_id, tuple_inst_id, index_literal, type_block.size());
   if (!index_val) {
-    return SemIR::InstId::BuiltinErrorInst;
+    return SemIR::ErrorInst::SingletonInstId;
   }
 
   // TODO: Handle the case when `index_val->getZExtValue()` has too many bits.

toolchain/check/operator.cpp

@@ -39,8 +39,8 @@ auto BuildUnaryOperator(Context& context, SemIR::LocId loc_id, Operator op,
   // Form `operand.(Op)`.
   auto bound_op_id = PerformCompoundMemberAccess(context, loc_id, operand_id,
                                                  op_fn, missing_impl_diagnoser);
-  if (bound_op_id == SemIR::InstId::BuiltinErrorInst) {
-    return SemIR::InstId::BuiltinErrorInst;
+  if (bound_op_id == SemIR::ErrorInst::SingletonInstId) {
+    return SemIR::ErrorInst::SingletonInstId;
   }
 
   // Form `bound_op()`.
@@ -57,8 +57,8 @@ auto BuildBinaryOperator(Context& context, SemIR::LocId loc_id, Operator op,
   // Form `lhs.(Op)`.
   auto bound_op_id = PerformCompoundMemberAccess(context, loc_id, lhs_id, op_fn,
                                                  missing_impl_diagnoser);
-  if (bound_op_id == SemIR::InstId::BuiltinErrorInst) {
-    return SemIR::InstId::BuiltinErrorInst;
+  if (bound_op_id == SemIR::ErrorInst::SingletonInstId) {
+    return SemIR::ErrorInst::SingletonInstId;
   }
 
   // Form `bound_op(rhs)`.

toolchain/check/pattern_match.cpp

@@ -124,8 +124,8 @@ auto MatchContext::DoWork(Context& context) -> SemIR::InstBlockId {
 
 auto MatchContext::EmitPatternMatch(Context& context,
                                     MatchContext::WorkItem entry) -> void {
-  if (entry.pattern_id == SemIR::InstId::BuiltinErrorInst) {
-    results_.push_back(SemIR::InstId::BuiltinErrorInst);
+  if (entry.pattern_id == SemIR::ErrorInst::SingletonInstId) {
+    results_.push_back(SemIR::ErrorInst::SingletonInstId);
     return;
   }
   DiagnosticAnnotationScope annotate_diagnostics(
@@ -182,7 +182,7 @@ auto MatchContext::EmitPatternMatch(Context& context,
           context.emitter().Emit(
               TokenOnly(context.insts().GetLocId(entry.scrutinee_id)),
               AddrSelfIsNonRef);
-          results_.push_back(SemIR::InstId::BuiltinErrorInst);
+          results_.push_back(SemIR::ErrorInst::SingletonInstId);
           return;
       }
       auto scrutinee_ref = context.insts().Get(scrutinee_ref_id);
@@ -203,8 +203,8 @@ auto MatchContext::EmitPatternMatch(Context& context,
       switch (kind_) {
         case MatchKind::Caller: {
           CARBON_CHECK(entry.scrutinee_id.is_valid());
-          if (entry.scrutinee_id == SemIR::InstId::BuiltinErrorInst) {
-            results_.push_back(SemIR::InstId::BuiltinErrorInst);
+          if (entry.scrutinee_id == SemIR::ErrorInst::SingletonInstId) {
+            results_.push_back(SemIR::ErrorInst::SingletonInstId);
           } else {
             results_.push_back(ConvertToValueOfType(
                 context, context.insts().GetLocId(entry.scrutinee_id),

toolchain/check/return.cpp

@@ -93,7 +93,7 @@ auto CheckReturnedVar(Context& context, Parse::NodeId returned_node,
         context.emitter().Build(returned_node, ReturnedVarWithNoReturnType);
     NoteNoReturnTypeProvided(diag, function);
     diag.Emit();
-    return SemIR::InstId::BuiltinErrorInst;
+    return SemIR::ErrorInst::SingletonInstId;
   }
 
   // The declared type of the var must match the return type of the function.
@@ -106,7 +106,7 @@ auto CheckReturnedVar(Context& context, Parse::NodeId returned_node,
         context.emitter().Build(type_node, ReturnedVarWrongType, type_id);
     NoteReturnType(context, diag, function);
     diag.Emit();
-    return SemIR::InstId::BuiltinErrorInst;
+    return SemIR::ErrorInst::SingletonInstId;
   }
 
   // The variable aliases the return slot if there is one. If not, it has its
@@ -161,7 +161,7 @@ auto BuildReturnWithExpr(Context& context, Parse::ReturnStatementId node_id,
     auto diag = context.emitter().Build(node_id, ReturnStatementDisallowExpr);
     NoteNoReturnTypeProvided(diag, function);
     diag.Emit();
-    expr_id = SemIR::InstId::BuiltinErrorInst;
+    expr_id = SemIR::ErrorInst::SingletonInstId;
   } else if (returned_var_id.is_valid()) {
     CARBON_DIAGNOSTIC(
         ReturnExprWithReturnedVar, Error,
@@ -169,11 +169,11 @@ auto BuildReturnWithExpr(Context& context, Parse::ReturnStatementId node_id,
     auto diag = context.emitter().Build(node_id, ReturnExprWithReturnedVar);
     NoteReturnedVar(diag, returned_var_id);
     diag.Emit();
-    expr_id = SemIR::InstId::BuiltinErrorInst;
+    expr_id = SemIR::ErrorInst::SingletonInstId;
   } else if (!return_info.is_valid()) {
     // We already diagnosed that the return type is invalid. Don't try to
     // convert to it.
-    expr_id = SemIR::InstId::BuiltinErrorInst;
+    expr_id = SemIR::ErrorInst::SingletonInstId;
   } else if (return_info.has_return_slot()) {
     return_slot_id = GetCurrentReturnSlot(context);
     // Note that this can import a function and invalidate `function`.
@@ -196,7 +196,7 @@ auto BuildReturnVar(Context& context, Parse::ReturnStatementId node_id)
     CARBON_DIAGNOSTIC(ReturnVarWithNoReturnedVar, Error,
                       "`return var;` with no `returned var` in scope");
     context.emitter().Emit(node_id, ReturnVarWithNoReturnedVar);
-    returned_var_id = SemIR::InstId::BuiltinErrorInst;
+    returned_var_id = SemIR::ErrorInst::SingletonInstId;
   }
 
   auto return_slot_id = GetCurrentReturnSlot(context);

toolchain/check/scope_stack.cpp

@@ -122,7 +122,7 @@ auto ScopeStack::LookupInLexicalScopes(SemIR::NameId name_id)
 
   // If we have no lexical results, check all non-lexical scopes.
   if (lexical_results.empty()) {
-    return {LexicalLookupHasLoadError() ? SemIR::InstId::BuiltinErrorInst
+    return {LexicalLookupHasLoadError() ? SemIR::ErrorInst::SingletonInstId
                                         : SemIR::InstId::Invalid,
             non_lexical_scope_stack_};
   }

toolchain/lower/handle.cpp

@@ -57,7 +57,7 @@ auto HandleInst(FunctionContext& context, SemIR::InstId /*inst_id*/,
 auto HandleInst(FunctionContext& context, SemIR::InstId inst_id,
                 SemIR::BindAlias inst) -> void {
   auto type_inst_id = context.sem_ir().types().GetInstId(inst.type_id);
-  if (type_inst_id == SemIR::InstId::BuiltinNamespaceType) {
+  if (type_inst_id == SemIR::NamespaceType::SingletonInstId) {
     return;
   }
 
@@ -67,7 +67,7 @@ auto HandleInst(FunctionContext& context, SemIR::InstId inst_id,
 auto HandleInst(FunctionContext& context, SemIR::InstId inst_id,
                 SemIR::ExportDecl inst) -> void {
   auto type_inst_id = context.sem_ir().types().GetInstId(inst.type_id);
-  if (type_inst_id == SemIR::InstId::BuiltinNamespaceType) {
+  if (type_inst_id == SemIR::NamespaceType::SingletonInstId) {
     return;
   }
 
@@ -170,7 +170,7 @@ auto HandleInst(FunctionContext& context, SemIR::InstId /*inst_id*/,
 auto HandleInst(FunctionContext& context, SemIR::InstId inst_id,
                 SemIR::NameRef inst) -> void {
   auto type_inst_id = context.sem_ir().types().GetInstId(inst.type_id);
-  if (type_inst_id == SemIR::InstId::BuiltinNamespaceType) {
+  if (type_inst_id == SemIR::NamespaceType::SingletonInstId) {
     return;
   }
 

toolchain/sem_ir/builtin_function_kind.cpp

@@ -73,14 +73,14 @@ struct NoReturn {
 };
 
 // Constraint that a type is `bool`.
-using Bool = BuiltinType<InstId::BuiltinBoolType>;
+using Bool = BuiltinType<BoolType::SingletonInstId>;
 
 // Constraint that requires the type to be an integer type.
 struct AnyInt {
   static auto Check(const File& sem_ir, ValidateState& state, TypeId type_id)
       -> bool {
-    if (BuiltinType<InstId::BuiltinIntLiteralType>::Check(sem_ir, state,
-                                                          type_id)) {
+    if (BuiltinType<IntLiteralType::SingletonInstId>::Check(sem_ir, state,
+                                                            type_id)) {
       return true;
     }
     return sem_ir.types().Is<IntType>(type_id);
@@ -91,8 +91,8 @@ struct AnyInt {
 struct AnyFloat {
   static auto Check(const File& sem_ir, ValidateState& state, TypeId type_id)
       -> bool {
-    if (BuiltinType<InstId::BuiltinLegacyFloatType>::Check(sem_ir, state,
-                                                           type_id)) {
+    if (BuiltinType<LegacyFloatType::SingletonInstId>::Check(sem_ir, state,
+                                                             type_id)) {
       return true;
     }
     return sem_ir.types().Is<FloatType>(type_id);
@@ -100,7 +100,7 @@ struct AnyFloat {
 };
 
 // Constraint that requires the type to be the type type.
-using Type = BuiltinType<InstId::BuiltinTypeType>;
+using Type = BuiltinType<TypeType::SingletonInstId>;
 
 }  // namespace
 

toolchain/sem_ir/class.cpp

@@ -16,7 +16,7 @@ static auto GetFoundationType(const File& file, SpecificId specific_id,
   if (!inst_id.is_valid()) {
     return TypeId::Invalid;
   }
-  if (inst_id == SemIR::InstId::BuiltinErrorInst) {
+  if (inst_id == SemIR::ErrorInst::SingletonInstId) {
     return ErrorInst::SingletonTypeId;
   }
   return TypeId::ForTypeConstant(GetConstantValueInSpecific(

toolchain/sem_ir/function.cpp

@@ -86,7 +86,7 @@ auto Function::GetNameFromPatternId(const File& sem_ir, InstId pattern_id)
     inst = sem_ir.insts().Get(inst_id);
   }
 
-  if (inst_id == SemIR::InstId::BuiltinErrorInst) {
+  if (inst_id == SemIR::ErrorInst::SingletonInstId) {
     return SemIR::NameId::Invalid;
   }
 

toolchain/sem_ir/ids.h

@@ -40,13 +40,6 @@ struct InstId : public IdBase<InstId> {
   // An explicitly invalid ID.
   static const InstId Invalid;
 
-// Builtin inst IDs.
-#define CARBON_SEM_IR_BUILTIN_INST_KIND(Name) static const InstId Builtin##Name;
-#include "toolchain/sem_ir/inst_kind.def"
-
-  // The namespace for a `package` expression.
-  static const InstId PackageNamespace;
-
   // Returns the instruction ID for a builtin. This relies on File guarantees
   // for builtin placement.
   static constexpr auto ForBuiltin(BuiltinInstKind kind) -> InstId {
@@ -72,11 +65,6 @@ struct InstId : public IdBase<InstId> {
 
 constexpr InstId InstId::Invalid = InstId(InvalidIndex);
 
-#define CARBON_SEM_IR_BUILTIN_INST_KIND(Name) \
-  constexpr InstId InstId::Builtin##Name =    \
-      InstId::ForBuiltin(BuiltinInstKind::Name);
-#include "toolchain/sem_ir/inst_kind.def"
-
 // An ID of an instruction that is referenced absolutely by another instruction.
 // This should only be used as the type of a field within a typed instruction
 // class.
@@ -96,9 +84,6 @@ class AbsoluteInstId : public InstId {
   using InstId::InstId;
 };
 
-// The package namespace will be the instruction after builtins.
-constexpr InstId InstId::PackageNamespace = InstId(BuiltinInstKind::ValidCount);
-
 // The ID of a constant value of an expression. An expression is either:
 //
 // - a template constant, with an immediate value, such as `42` or `i32*` or

toolchain/sem_ir/inst_namer.cpp

@@ -143,7 +143,7 @@ auto InstNamer::GetNameFor(ScopeId scope_id, InstId inst_id) const
     return sem_ir_.insts().Get(inst_id).kind().ir_name().str();
   }
 
-  if (inst_id == InstId::PackageNamespace) {
+  if (inst_id == SemIR::Namespace::PackageInstId) {
     return "package";
   }
 

toolchain/sem_ir/singleton_insts.h

@@ -64,13 +64,6 @@ inline constexpr auto MakeSingletonInstId() -> InstId {
   return InstId(index);
 }
 
-// TODO: This verifies values match while working on removing
-// `CARBON_SEM_IR_BUILTIN_INST_KIND`.
-#define CARBON_SEM_IR_BUILTIN_INST_KIND(Name) \
-  static_assert(InstId::Builtin##Name ==      \
-                MakeSingletonInstId<InstKind::RawEnumType::Name>());
-#include "toolchain/sem_ir/inst_kind.def"
-
 }  // namespace Carbon::SemIR
 
 #endif  // CARBON_TOOLCHAIN_SEM_IR_SINGLETON_INSTS_H_

toolchain/sem_ir/type.cpp

@@ -43,7 +43,7 @@ static auto TryGetIntTypeInfo(const File& file, TypeId type_id)
     return std::nullopt;
   }
   auto inst_id = file.types().GetInstId(object_repr_id);
-  if (inst_id == InstId::BuiltinIntLiteralType) {
+  if (inst_id == IntLiteralType::SingletonInstId) {
     // `Core.IntLiteral` has an unknown bit-width.
     return TypeStore::IntTypeInfo{.is_signed = true,
                                   .bit_width = IntId::Invalid};

toolchain/sem_ir/typed_insts.h

@@ -947,6 +947,9 @@ struct Namespace {
   static constexpr auto Kind =
       InstKind::Namespace.Define<Parse::AnyNamespaceId>(
           {.ir_name = "namespace", .constant_kind = InstConstantKind::Always});
+  // The file's package namespace is a well-known instruction to help `package.`
+  // qualified names. It will always be immediately after singletons.
+  static constexpr InstId PackageInstId = InstId(SingletonInstKinds.size());
 
   TypeId type_id;
   NameScopeId name_scope_id;