diff --git a/src/main/java/com/android/tools/r8/ir/desugar/typeswitch/TypeSwitchDesugaring.java b/src/main/java/com/android/tools/r8/ir/desugar/typeswitch/TypeSwitchDesugaring.java
index e6e99e7..da03ae1 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/typeswitch/TypeSwitchDesugaring.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/typeswitch/TypeSwitchDesugaring.java
@@ -43,6 +43,7 @@
 import com.google.common.collect.ImmutableList;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.function.BiConsumer;
 import org.objectweb.asm.Opcodes;
 
 public class TypeSwitchDesugaring implements CfInstructionDesugaring {
@@ -50,8 +51,9 @@
   private final AppView<?> appView;
 
   private final DexMethod typeSwitchMethod;
+  private final DexMethod enumSwitchMethod;
   private final DexProto typeSwitchProto;
-  private final DexProto typeSwitchHelperProto;
+  private final DexProto switchHelperProto;
   private final DexMethod enumDescMethod;
   private final DexMethod classDescMethod;
   private final DexType matchException;
@@ -62,18 +64,22 @@
     this.appView = appView;
     this.factory = appView.dexItemFactory();
     DexType switchBootstrap = factory.createType("Ljava/lang/runtime/SwitchBootstraps;");
+    DexProto methodHandleSwitchProto =
+        factory.createProto(
+            factory.callSiteType,
+            factory.methodHandlesLookupType,
+            factory.stringType,
+            factory.methodTypeType,
+            factory.objectArrayType);
     typeSwitchMethod =
         factory.createMethod(
-            switchBootstrap,
-            factory.createProto(
-                factory.callSiteType,
-                factory.methodHandlesLookupType,
-                factory.stringType,
-                factory.methodTypeType,
-                factory.objectArrayType),
-            factory.createString("typeSwitch"));
-    typeSwitchProto = factory.createProto(factory.intType, factory.objectType, factory.intType);
-    typeSwitchHelperProto =
+            switchBootstrap, methodHandleSwitchProto, factory.createString("typeSwitch"));
+    enumSwitchMethod =
+        factory.createMethod(
+            switchBootstrap, methodHandleSwitchProto, factory.createString("enumSwitch"));
+    this.typeSwitchProto =
+        factory.createProto(factory.intType, factory.objectType, factory.intType);
+    switchHelperProto =
         factory.createProto(
             factory.intType, factory.objectType, factory.intType, factory.objectArrayType);
     enumDescMethod =
@@ -147,31 +153,62 @@
       return DesugarDescription.nothing();
     }
     DexCallSite callSite = instruction.asInvokeDynamic().getCallSite();
-    if (!(callSite.methodName.isIdenticalTo(typeSwitchMethod.getName())
+    if (callSite.methodName.isIdenticalTo(typeSwitchMethod.getName())
         && callSite.methodProto.isIdenticalTo(typeSwitchProto)
-        && methodHandleIsInvokeStaticTo(callSite.bootstrapMethod, typeSwitchMethod))) {
-      return DesugarDescription.nothing();
+        && methodHandleIsInvokeStaticTo(callSite.bootstrapMethod, typeSwitchMethod)) {
+      return DesugarDescription.builder()
+          .setDesugarRewrite(
+              (position,
+                  freshLocalProvider,
+                  localStackAllocator,
+                  desugaringInfo,
+                  eventConsumer,
+                  theContext,
+                  methodProcessingContext,
+                  desugaringCollection,
+                  dexItemFactory) -> {
+                // We add on stack (2) array, (3) dupped array, (4) index, (5) value.
+                localStackAllocator.allocateLocalStack(4);
+                List<CfInstruction> cfInstructions =
+                    generateTypeSwitchLoadArguments(callSite, context);
+                generateInvokeToDesugaredMethod(
+                    methodProcessingContext, cfInstructions, theContext, eventConsumer);
+                return cfInstructions;
+              })
+          .build();
     }
-    // Call the desugared method.
-    return DesugarDescription.builder()
-        .setDesugarRewrite(
-            (position,
-                freshLocalProvider,
-                localStackAllocator,
-                desugaringInfo,
-                eventConsumer,
-                theContext,
-                methodProcessingContext,
-                desugaringCollection,
-                dexItemFactory) -> {
-              // We add on stack (2) array, (3) dupped array, (4) index, (5) value.
-              localStackAllocator.allocateLocalStack(4);
-              List<CfInstruction> cfInstructions = generateLoadArguments(callSite, context);
-              generateInvokeToDesugaredMethod(
-                  methodProcessingContext, cfInstructions, theContext, eventConsumer);
-              return cfInstructions;
-            })
-        .build();
+    if (callSite.methodName.isIdenticalTo(enumSwitchMethod.getName())
+        && isEnumSwitchProto(callSite.methodProto)
+        && methodHandleIsInvokeStaticTo(callSite.bootstrapMethod, enumSwitchMethod)) {
+      DexType enumType = callSite.methodProto.getParameter(0);
+      return DesugarDescription.builder()
+          .setDesugarRewrite(
+              (position,
+                  freshLocalProvider,
+                  localStackAllocator,
+                  desugaringInfo,
+                  eventConsumer,
+                  theContext,
+                  methodProcessingContext,
+                  desugaringCollection,
+                  dexItemFactory) -> {
+                // We add on stack (2) array, (3) dupped array, (4) index, (5) value.
+                localStackAllocator.allocateLocalStack(4);
+                List<CfInstruction> cfInstructions =
+                    generateEnumSwitchLoadArguments(callSite, context, enumType);
+                generateInvokeToDesugaredMethod(
+                    methodProcessingContext, cfInstructions, theContext, eventConsumer);
+                return cfInstructions;
+              })
+          .build();
+    }
+    return DesugarDescription.nothing();
+  }
+
+  private boolean isEnumSwitchProto(DexProto methodProto) {
+    return methodProto.getReturnType().isIdenticalTo(factory.intType)
+        && methodProto.getArity() == 2
+        && methodProto.getParameter(1).isIdenticalTo(factory.intType);
   }
 
   private void generateInvokeToDesugaredMethod(
@@ -189,7 +226,7 @@
                 builder ->
                     builder
                         .disableAndroidApiLevelCheck()
-                        .setProto(typeSwitchHelperProto)
+                        .setProto(switchHelperProto)
                         .setAccessFlags(MethodAccessFlags.createPublicStaticSynthetic())
                         .setCode(
                             methodSig -> {
@@ -206,7 +243,50 @@
     cfInstructions.add(new CfInvoke(Opcodes.INVOKESTATIC, method.getReference(), false));
   }
 
-  private List<CfInstruction> generateLoadArguments(DexCallSite callSite, ProgramMethod context) {
+  private List<CfInstruction> generateEnumSwitchLoadArguments(
+      DexCallSite callSite, ProgramMethod context, DexType enumType) {
+    return generateSwitchLoadArguments(
+        callSite,
+        (bootstrapArg, cfInstructions) -> {
+          if (bootstrapArg.isDexValueType()) {
+            cfInstructions.add(new CfConstClass(bootstrapArg.asDexValueType().getValue()));
+          } else if (bootstrapArg.isDexValueString()) {
+            DexField enumField =
+                getEnumField(bootstrapArg.asDexValueString().getValue(), enumType, context);
+            cfInstructions.add(new CfStaticFieldRead(enumField));
+          } else {
+            throw new CompilationError(
+                "Invalid bootstrap arg for enum switch " + bootstrapArg, context.getOrigin());
+          }
+        });
+  }
+
+  private List<CfInstruction> generateTypeSwitchLoadArguments(
+      DexCallSite callSite, ProgramMethod context) {
+    return generateSwitchLoadArguments(
+        callSite,
+        (bootstrapArg, cfInstructions) -> {
+          if (bootstrapArg.isDexValueType()) {
+            cfInstructions.add(new CfConstClass(bootstrapArg.asDexValueType().getValue()));
+          } else if (bootstrapArg.isDexValueInt()) {
+            cfInstructions.add(
+                new CfConstNumber(bootstrapArg.asDexValueInt().getValue(), ValueType.INT));
+            cfInstructions.add(
+                new CfInvoke(Opcodes.INVOKESTATIC, factory.integerMembers.valueOf, false));
+          } else if (bootstrapArg.isDexValueString()) {
+            cfInstructions.add(new CfConstString(bootstrapArg.asDexValueString().getValue()));
+          } else if (bootstrapArg.isDexValueConstDynamic()) {
+            DexField enumField = extractEnumField(bootstrapArg.asDexValueConstDynamic(), context);
+            cfInstructions.add(new CfStaticFieldRead(enumField));
+          } else {
+            throw new CompilationError(
+                "Invalid bootstrap arg for type switch " + bootstrapArg, context.getOrigin());
+          }
+        });
+  }
+
+  private List<CfInstruction> generateSwitchLoadArguments(
+      DexCallSite callSite, BiConsumer<DexValue, List<CfInstruction>> adder) {
     // We need to call the method with the bootstrap args as parameters.
     // We need to convert the bootstrap args into a list of cf instructions.
     // The object and the int are already pushed on stack, we simply need to push the extra array.
@@ -217,20 +297,7 @@
       DexValue bootstrapArg = callSite.bootstrapArgs.get(i);
       cfInstructions.add(new CfStackInstruction(Opcode.Dup));
       cfInstructions.add(new CfConstNumber(i, ValueType.INT));
-      if (bootstrapArg.isDexValueType()) {
-        cfInstructions.add(new CfConstClass(bootstrapArg.asDexValueType().getValue()));
-      } else if (bootstrapArg.isDexValueInt()) {
-        cfInstructions.add(
-            new CfConstNumber(bootstrapArg.asDexValueInt().getValue(), ValueType.INT));
-        cfInstructions.add(
-            new CfInvoke(Opcodes.INVOKESTATIC, factory.integerMembers.valueOf, false));
-      } else if (bootstrapArg.isDexValueString()) {
-        cfInstructions.add(new CfConstString(bootstrapArg.asDexValueString().getValue()));
-      } else {
-        assert bootstrapArg.isDexValueConstDynamic();
-        DexField enumField = extractEnumField(bootstrapArg.asDexValueConstDynamic(), context);
-        cfInstructions.add(new CfStaticFieldRead(enumField));
-      }
+      adder.accept(bootstrapArg, cfInstructions);
       cfInstructions.add(new CfArrayStore(MemberType.OBJECT));
     }
     return cfInstructions;
@@ -280,6 +347,10 @@
     DexString className = dexValueClassName.asDexValueString().getValue();
     DexType enumType =
         factory.createType(DescriptorUtils.javaTypeToDescriptor(className.toString()));
+    return getEnumField(fieldName, enumType, context);
+  }
+
+  private DexField getEnumField(DexString fieldName, DexType enumType, ProgramMethod context) {
     DexClass enumClass = appView.definitionFor(enumType);
     if (enumClass == null) {
       throw throwEnumFieldConstantDynamic("Missing enum class " + enumType, context);
diff --git a/src/test/examplesJava21/switchpatternmatching/EnumSwitchUsingEnumSwitchBootstrapMethod.java b/src/test/examplesJava21/switchpatternmatching/EnumSwitchUsingEnumSwitchBootstrapMethod.java
new file mode 100644
index 0000000..32fad72
--- /dev/null
+++ b/src/test/examplesJava21/switchpatternmatching/EnumSwitchUsingEnumSwitchBootstrapMethod.java
@@ -0,0 +1,140 @@
+// Copyright (c) 2024, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package switchpatternmatching;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assume.assumeTrue;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.TestRuntime.CfVm;
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.InstructionSubject;
+import org.junit.Assume;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class EnumSwitchUsingEnumSwitchBootstrapMethod extends TestBase {
+
+  @Parameter public TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  public static String EXPECTED_OUTPUT =
+      StringUtils.lines(
+          "null",
+          "Spades or Piques",
+          "Hearts or C\u0153ur",
+          "Diamonds or Carreaux",
+          "Clubs or Trefles",
+          "Trumps or Atouts",
+          "The Fool or L'Excuse");
+
+  @Test
+  public void testJvm() throws Exception {
+    assumeTrue(parameters.isCfRuntime());
+    CodeInspector inspector = new CodeInspector(ToolHelper.getClassFileForTestClass(Main.class));
+    // javac generated an invokedynamic using bootstrap method
+    // java.lang.runtime.SwitchBootstraps.enumSwitch.
+    assertEquals(
+        1,
+        inspector
+            .clazz(Main.class)
+            .uniqueMethodWithOriginalName("enumSwitch")
+            .streamInstructions()
+            .filter(InstructionSubject::isInvokeDynamic)
+            .map(
+                instruction ->
+                    instruction
+                        .asCfInstruction()
+                        .getInstruction()
+                        .asInvokeDynamic()
+                        .getCallSite()
+                        .getBootstrapMethod()
+                        .member
+                        .asDexMethod())
+            .filter(
+                method ->
+                    method
+                        .getHolderType()
+                        .toString()
+                        .contains("java.lang.runtime.SwitchBootstraps"))
+            .filter(method -> method.toString().contains("enumSwitch"))
+            .count());
+
+    parameters.assumeJvmTestParameters();
+    testForJvm(parameters)
+        .addInnerClassesAndStrippedOuter(getClass())
+        .run(parameters.getRuntime(), Main.class)
+        .applyIf(
+            parameters.getCfRuntime().isNewerThanOrEqual(CfVm.JDK21),
+            r -> r.assertSuccessWithOutput(EXPECTED_OUTPUT),
+            r -> r.assertFailureWithErrorThatThrows(UnsupportedClassVersionError.class));
+  }
+
+  @Test
+  public void testD8() throws Exception {
+    parameters.assumeDexRuntime();
+    testForD8()
+        .addInnerClassesAndStrippedOuter(getClass())
+        .setMinApi(parameters)
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutput(EXPECTED_OUTPUT);
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    Assume.assumeTrue("For Cf we should compile with Jdk 21 library", parameters.isDexRuntime());
+    testForR8(parameters.getBackend())
+        .addInnerClassesAndStrippedOuter(getClass())
+        .setMinApi(parameters)
+        .addKeepMainRule(Main.class)
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutput(EXPECTED_OUTPUT);
+  }
+
+  public enum Tarot {
+    SPADE,
+    HEART,
+    DIAMOND,
+    CLUB,
+    TRUMP,
+    EXCUSE
+  }
+
+  public static class Main {
+
+    public static void main(String[] args) {
+      enumSwitch(null);
+      enumSwitch(Tarot.SPADE);
+      enumSwitch(Tarot.HEART);
+      enumSwitch(Tarot.DIAMOND);
+      enumSwitch(Tarot.CLUB);
+      enumSwitch(Tarot.TRUMP);
+      enumSwitch(Tarot.EXCUSE);
+    }
+
+    static void enumSwitch(Tarot t1) {
+      switch (t1) {
+        case null -> System.out.println("null");
+        case SPADE -> System.out.println("Spades or Piques");
+        case HEART -> System.out.println("Hearts or C\u0153ur");
+        case Tarot t when t == Tarot.DIAMOND -> System.out.println("Diamonds or Carreaux");
+        case Tarot t when t == Tarot.CLUB -> System.out.println("Clubs or Trefles");
+        case Tarot t when t == Tarot.TRUMP -> System.out.println("Trumps or Atouts");
+        case Tarot t -> System.out.println("The Fool or L'Excuse");
+      }
+    }
+  }
+}