diff --git a/src/test/java/com/android/tools/r8/regress/Regress353279141.java b/src/test/java/com/android/tools/r8/regress/Regress353279141.java
new file mode 100644
index 0000000..ff82dcf
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/regress/Regress353279141.java
@@ -0,0 +1,136 @@
+// 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 com.android.tools.r8.regress;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.R8TestRunResult;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.TestShrinkerBuilder;
+import com.android.tools.r8.references.MethodReference;
+import java.io.IOException;
+import java.util.concurrent.ExecutionException;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class Regress353279141 extends TestBase {
+
+  private final TestParameters parameters;
+
+  @Parameterized.Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withDefaultRuntimes().build();
+  }
+
+  public Regress353279141(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    runR8Compat(false)
+        .inspect(
+            codeInspector -> {
+              MethodReference method =
+                  codeInspector
+                      .clazz(TestClass.class.getName() + "$1")
+                      .getFinalEnclosingMethod()
+                      .asMethodReference();
+
+              // TODO(b/353279141): Rewrite the enclosing method to the correct one.
+              // This does not illustrate the exact issue in the bug, where we would rename a
+              // different
+              // method, with the same proto to the original name, and then have it output twice
+              // in the method table. This does trigger the same issue, the original method is
+              // present in the indexed items though (because we add it when iterating the
+              // annotation)
+              // although there are no classes that have it.
+              assertFalse(codeInspector.clazz(TestClass.class).method(method).isPresent());
+            });
+  }
+
+  @Test
+  public void testR8KeepIt() throws Exception {
+    runR8Compat(true)
+        .inspect(
+            codeInspector -> {
+              MethodReference method =
+                  codeInspector
+                      .clazz(TestClass.class.getName() + "$1")
+                      .getFinalEnclosingMethod()
+                      .asMethodReference();
+              assertTrue(codeInspector.clazz(TestClass.class).method(method).isPresent());
+            });
+  }
+
+  private R8TestRunResult runR8Compat(boolean dontOptimize)
+      throws CompilationFailedException, ExecutionException, IOException {
+    return testForR8Compat(parameters.getBackend())
+        .addInnerClasses(getClass())
+        .addKeepMainRule(TestClass.class)
+        .enableInliningAnnotations()
+        .applyIf(dontOptimize, TestShrinkerBuilder::addDontOptimize)
+        .addKeepRules(
+            "-keep class **TestClass$1 { *; }", "-keepattributes InnerClasses,EnclosingMethod")
+        .run(parameters.getRuntime(), TestClass.class)
+        .assertSuccessWithOutputLines("foo");
+  }
+
+  interface RunWithIt {
+    void run();
+
+    void init();
+  }
+
+  public static class TestClass {
+    public static void main(String[] args) {
+      TestClass testClass = new TestClass();
+      long l = System.currentTimeMillis();
+      String s = l == 0 ? "x" : "y";
+      int a = l == 0 ? 42 : 43;
+      testClass.b(a, s);
+      testClass.a(s, a);
+    }
+
+    @NeverInline
+    public void a(String a, int b) {
+      if (System.currentTimeMillis() == 0) {
+        System.out.println(a + b);
+      }
+      RunWithIt foo =
+          new RunWithIt() {
+            private long value;
+
+            @Override
+            public void run() {
+              value = System.currentTimeMillis();
+              System.out.println("foo");
+            }
+
+            @Override
+            public void init() {
+              value = System.currentTimeMillis();
+            }
+          };
+      foo.init();
+      foo.run();
+    }
+
+    // This method introduce a proto with opposite order, we will rewrite the a method to
+    // use this order.
+    @NeverInline
+    public void b(int a, String s) {
+      if (System.currentTimeMillis() == 0) {
+        System.out.println("a value " + a + s);
+      }
+    }
+  }
+}