Switch GetExprCategory to be table-driven. (#6371)

Avoid using a large switch that needs to be manually extended when
adding a new kind of instruction. Instead, the expression category for
an instruction is now specified when defining the `InstKind`.

In passing, add a distinct expression category value for patterns. This
isn't used for much except some error checking at the moment, but it
keeps the number of instructions that we need to manually classify as
`NotExpr` despite having a type very low.

Author: zygoloid

toolchain/check/convert.cpp

@@ -1625,6 +1625,7 @@ auto Convert(Context& context, SemIR::LocId loc_id, SemIR::InstId expr_id,
           current_category) {
     case SemIR::ExprCategory::NotExpr:
     case SemIR::ExprCategory::Mixed:
+    case SemIR::ExprCategory::Pattern:
       CARBON_FATAL("Unexpected expression {0} after builtin conversions",
                    sem_ir.insts().Get(expr_id));
 

toolchain/check/cpp/type_mapping.cpp

@@ -262,6 +262,9 @@ auto InventClangArg(Context& context, SemIR::InstId arg_id) -> clang::Expr* {
     case SemIR::ExprCategory::Error:
       return nullptr;
 
+    case SemIR::ExprCategory::Pattern:
+      CARBON_FATAL("Passing a pattern as a function argument");
+
     case SemIR::ExprCategory::DurableRef:
       value_kind = clang::ExprValueKind::VK_LValue;
       break;

toolchain/lower/file_context.cpp

@@ -232,6 +232,7 @@ auto FileContext::GetConstant(SemIR::ConstantId const_id,
 
     case SemIR::ExprCategory::NotExpr:
     case SemIR::ExprCategory::Error:
+    case SemIR::ExprCategory::Pattern:
     case SemIR::ExprCategory::Mixed:
       CARBON_FATAL("Unexpected category {0} for lowered constant {1}", cat,
                    sem_ir().insts().Get(const_inst_id));

toolchain/lower/handle_aggregates.cpp

@@ -64,6 +64,7 @@ static auto GetAggregateElement(FunctionContext& context,
   switch (SemIR::GetExprCategory(context.sem_ir(), aggr_inst_id)) {
     case SemIR::ExprCategory::Error:
     case SemIR::ExprCategory::NotExpr:
+    case SemIR::ExprCategory::Pattern:
     case SemIR::ExprCategory::Initializing:
     case SemIR::ExprCategory::Mixed:
       CARBON_FATAL(

toolchain/sem_ir/expr_info.cpp

@@ -4,12 +4,24 @@
 
 #include "toolchain/sem_ir/expr_info.h"
 
+#include <concepts>
+
 #include "common/check.h"
 #include "toolchain/base/kind_switch.h"
+#include "toolchain/sem_ir/ids.h"
+#include "toolchain/sem_ir/inst_kind.h"
 #include "toolchain/sem_ir/typed_insts.h"
 
 namespace Carbon::SemIR {
 
+// Returns the InstId represented by an instruction operand.
+static auto AsAnyInstId(Inst::ArgAndKind arg) -> InstId {
+  if (auto inst_id = arg.TryAs<SemIR::InstId>()) {
+    return *inst_id;
+  }
+  return arg.As<SemIR::AbsoluteInstId>();
+}
+
 auto GetExprCategory(const File& file, InstId inst_id) -> ExprCategory {
   const File* ir = &file;
 
@@ -19,228 +31,64 @@ auto GetExprCategory(const File& file, InstId inst_id) -> ExprCategory {
 
   while (true) {
     auto untyped_inst = ir->insts().Get(inst_id);
-    CARBON_KIND_SWITCH(untyped_inst) {
-      case AdaptDecl::Kind:
-      case Assign::Kind:
-      case BaseDecl::Kind:
-      case Branch::Kind:
-      case BranchIf::Kind:
-      case BranchWithArg::Kind:
-      case FieldDecl::Kind:
-      case FunctionDecl::Kind:
-      case ImplDecl::Kind:
-      case NameBindingDecl::Kind:
-      case Namespace::Kind:
-      case OutParamPattern::Kind:
-      case RefBindingPattern::Kind:
-      case RefParamPattern::Kind:
-      case RequireImplsDecl::Kind:
-      case RequirementBaseFacetType::Kind:
-      case RequirementEquivalent::Kind:
-      case RequirementImpls::Kind:
-      case RequirementRewrite::Kind:
-      case Return::Kind:
-      case ReturnSlotPattern::Kind:
-      case ReturnExpr::Kind:
-      case SymbolicBindingPattern::Kind:
-      case TuplePattern::Kind:
-      case ValueBindingPattern::Kind:
-      case ValueParamPattern::Kind:
-      case VarParamPattern::Kind:
-      case VarPattern::Kind:
-        return ExprCategory::NotExpr;
-
-      case ImportRefUnloaded::Kind:
-      case ImportRefLoaded::Kind: {
-        auto import_ir_inst = ir->import_ir_insts().Get(
-            untyped_inst.As<AnyImportRef>().import_ir_inst_id);
-        ir = ir->import_irs().Get(import_ir_inst.ir_id()).sem_ir;
-        inst_id = import_ir_inst.inst_id();
-        continue;
-      }
-
-      case CARBON_KIND(AsCompatible inst): {
-        inst_id = inst.source_id;
-        continue;
-      }
+    auto category_from_kind = untyped_inst.kind().expr_category();
 
-      case CARBON_KIND(AliasBinding inst): {
-        inst_id = inst.value_id;
-        continue;
-      }
-      case CARBON_KIND(ExportDecl inst): {
-        inst_id = inst.value_id;
-        continue;
-      }
-      case CARBON_KIND(NameRef inst): {
-        inst_id = inst.value_id;
-        continue;
-      }
-
-      case CARBON_KIND(Converted inst): {
-        inst_id = inst.result_id;
-        continue;
-      }
-
-      case CARBON_KIND(ImplWitnessAssociatedConstant inst): {
-        inst_id = inst.inst_id;
-        continue;
-      }
-
-      case CARBON_KIND(SpecificConstant inst): {
-        inst_id = inst.inst_id;
-        continue;
-      }
-
-      case AccessMemberAction::Kind:
-      case AccessOptionalMemberAction::Kind:
-      case AddrOf::Kind:
-      case ArrayType::Kind:
-      case AssociatedConstantDecl::Kind:
-      case AssociatedEntity::Kind:
-      case AssociatedEntityType::Kind:
-      case AutoType::Kind:
-      case SymbolicBinding::Kind:
-      case AcquireValue::Kind:
-      case ValueBinding::Kind:
-      case BlockArg::Kind:
-      case BoolLiteral::Kind:
-      case BoolType::Kind:
-      case BoundMethod::Kind:
-      case BoundMethodType::Kind:
-      case CharLiteralType::Kind:
-      case CharLiteralValue::Kind:
-      case ClassDecl::Kind:
-      case ClassType::Kind:
-      case CompleteTypeWitness::Kind:
-      case ConstType::Kind:
-      case ConvertToValueAction::Kind:
-      case CppOverloadSetType::Kind:
-      case CppOverloadSetValue::Kind:
-      case CustomLayoutType::Kind:
-      case FacetAccessType::Kind:
-      case FacetType::Kind:
-      case FacetValue::Kind:
-      case FloatLiteralType::Kind:
-      case FloatLiteralValue::Kind:
-      case FloatType::Kind:
-      case FloatValue::Kind:
-      case FunctionType::Kind:
-      case FunctionTypeWithSelfType::Kind:
-      case GenericClassType::Kind:
-      case GenericInterfaceType::Kind:
-      case GenericNamedConstraintType::Kind:
-      case LookupImplWitness::Kind:
-      case ImplWitness::Kind:
-      case ImplWitnessAccess::Kind:
-      case ImplWitnessAccessSubstituted::Kind:
-      case ImplWitnessTable::Kind:
-      case ImportCppDecl::Kind:
-      case ImportDecl::Kind:
-      case InstType::Kind:
-      case InstValue::Kind:
-      case IntLiteralType::Kind:
-      case IntType::Kind:
-      case IntValue::Kind:
-      case InterfaceDecl::Kind:
-      case MaybeUnformedType::Kind:
-      case NamedConstraintDecl::Kind:
-      case NamespaceType::Kind:
-      case PartialType::Kind:
-      case PatternType::Kind:
-      case PointerType::Kind:
-      case RefineTypeAction::Kind:
-      case RequireCompleteType::Kind:
-      case SpecificFunction::Kind:
-      case SpecificFunctionType::Kind:
-      case SpecificImplFunction::Kind:
-      case StringLiteral::Kind:
-      case StructType::Kind:
-      case StructValue::Kind:
-      case SymbolicBindingType::Kind:
-      case TupleType::Kind:
-      case TupleValue::Kind:
-      case TypeOfInst::Kind:
-      case TypeType::Kind:
-      case UnaryOperatorNot::Kind:
-      case UnboundElementType::Kind:
-      case UninitializedValue::Kind:
-      case ValueOfInitializer::Kind:
-      case ValueParam::Kind:
-      case VtableType::Kind:
-      case WhereExpr::Kind:
-      case WitnessType::Kind:
-        return value_category;
-
-      case ErrorInst::Kind:
-        return ExprCategory::Error;
-
-      case CARBON_KIND(ArrayIndex inst): {
-        inst_id = inst.array_id;
-        continue;
-      }
-
-      case VtablePtr::Kind:
-      case VtableDecl::Kind:
-        return ExprCategory::EphemeralRef;
+    // If this instruction kind has a fixed category, return it.
+    if (auto fixed_category = category_from_kind.TryAsFixedCategory()) {
+      return *fixed_category == ExprCategory::Value ? value_category
+                                                    : *fixed_category;
+    }
 
-      case CARBON_KIND(ClassElementAccess inst): {
+    // Handle any special cases that use
+    // ComputedExprCategory::DependsOnOperands.
+    auto handle_special_case = [&]<typename TypedInstT>(TypedInstT inst) {
+      if constexpr (std::same_as<TypedInstT, ClassElementAccess>) {
         inst_id = inst.base_id;
         // A value of class type is a pointer to an object representation.
         // Therefore, if the base is a value, the result is an ephemeral
         // reference.
         value_category = ExprCategory::EphemeralRef;
-        continue;
+      } else if constexpr (std::same_as<TypedInstT, ImportRefLoaded> ||
+                           std::same_as<TypedInstT, ImportRefUnloaded>) {
+        auto import_ir_inst = ir->import_ir_insts().Get(inst.import_ir_inst_id);
+        ir = ir->import_irs().Get(import_ir_inst.ir_id()).sem_ir;
+        inst_id = import_ir_inst.inst_id();
+      } else {
+        static_assert(
+            TypedInstT::Kind.expr_category().TryAsComputedCategory() !=
+                ComputedExprCategory::DependsOnOperands,
+            "Missing expression category computation for type");
       }
+    };
 
-      case CARBON_KIND(StructAccess inst): {
-        inst_id = inst.struct_id;
-        continue;
+    // If the category depends on the operands of the instruction, determine it.
+    // Usually this means the category is the same as the category of an
+    // operand.
+    switch (*category_from_kind.TryAsComputedCategory()) {
+      case ComputedExprCategory::ValueIfHasType: {
+        return untyped_inst.kind().has_type() ? value_category
+                                              : ExprCategory::NotExpr;
       }
 
-      case CARBON_KIND(TupleAccess inst): {
-        inst_id = inst.tuple_id;
-        continue;
+      case ComputedExprCategory::SameAsFirstOperand: {
+        inst_id = AsAnyInstId(untyped_inst.arg0_and_kind());
+        break;
       }
 
-      case CARBON_KIND(SpliceBlock inst): {
-        inst_id = inst.result_id;
-        continue;
+      case ComputedExprCategory::SameAsSecondOperand: {
+        inst_id = AsAnyInstId(untyped_inst.arg1_and_kind());
+        break;
       }
 
-      case SpliceInst::Kind:
-        // TODO: Add ExprCategory::Dependent.
-        return value_category;
-
-      case StructLiteral::Kind:
-      case TupleLiteral::Kind:
-        return ExprCategory::Mixed;
-
-      case ArrayInit::Kind:
-      case Call::Kind:
-      case InitializeFrom::Kind:
-      case InPlaceInit::Kind:
-      case ClassInit::Kind:
-      case StructInit::Kind:
-      case TupleInit::Kind:
-        return ExprCategory::Initializing;
-
-      case RefBinding::Kind:
-      case Deref::Kind:
-      case VarStorage::Kind:
-      case ReturnSlot::Kind:
-        return ExprCategory::DurableRef;
-
-      case Temporary::Kind:
-      case TemporaryStorage::Kind:
-      case ValueAsRef::Kind:
-        return ExprCategory::EphemeralRef;
-
-      case OutParam::Kind:
-      case RefParam::Kind:
-        // TODO: Consider introducing a separate category for OutParam:
-        // unlike other DurableRefs, it permits initialization.
-        return ExprCategory::DurableRef;
+      case ComputedExprCategory::DependsOnOperands: {
+        switch (untyped_inst.kind()) {
+#define CARBON_SEM_IR_INST_KIND(TypedInstT)             \
+  case TypedInstT::Kind:                                \
+    handle_special_case(untyped_inst.As<TypedInstT>()); \
+    break;
+#include "toolchain/sem_ir/inst_kind.def"
+        }
+      }
     }
   }
 }

toolchain/sem_ir/expr_info.h

@@ -9,36 +9,10 @@
 
 #include "toolchain/sem_ir/file.h"
 #include "toolchain/sem_ir/ids.h"
+#include "toolchain/sem_ir/inst_kind.h"
 
 namespace Carbon::SemIR {
 
-// The expression category of a sem_ir instruction. See /docs/design/values.md
-// for details.
-enum class ExprCategory : int8_t {
-  // This instruction does not correspond to an expression, and as such has no
-  // category.
-  NotExpr,
-  // The category of this instruction is not known due to an error.
-  Error,
-  // This instruction represents a value expression.
-  Value,
-  // This instruction represents a durable reference expression, that denotes an
-  // object that outlives the current full expression context.
-  DurableRef,
-  // This instruction represents an ephemeral reference expression, that denotes
-  // an object that does not outlive the current full expression context.
-  EphemeralRef,
-  // This instruction represents an initializing expression, that describes how
-  // to initialize an object.
-  Initializing,
-  // This instruction represents a syntactic combination of expressions that are
-  // permitted to have different expression categories. This is used for tuple
-  // and struct literals, where the subexpressions for different elements can
-  // have different categories.
-  Mixed,
-  Last = Mixed
-};
-
 // Returns the expression category for an instruction.
 auto GetExprCategory(const File& file, InstId inst_id) -> ExprCategory;
 

toolchain/sem_ir/formatter.cpp

@@ -1002,6 +1002,7 @@ auto Formatter::FormatInstLhs(InstId inst_id, Inst inst) -> void {
       case ExprCategory::NotExpr:
       case ExprCategory::Error:
       case ExprCategory::Value:
+      case ExprCategory::Pattern:
       case ExprCategory::Mixed:
         break;
       case ExprCategory::DurableRef: