diff --git a/src/main/java/com/android/tools/r8/graph/DexDebugInfoForSingleLineMethod.java b/src/main/java/com/android/tools/r8/graph/DexDebugInfoForSingleLineMethod.java
new file mode 100644
index 0000000..32d3126
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/graph/DexDebugInfoForSingleLineMethod.java
@@ -0,0 +1,20 @@
+// Copyright (c) 2021, 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.graph;
+
+public class DexDebugInfoForSingleLineMethod extends DexDebugInfo {
+
+  private static final DexDebugInfoForSingleLineMethod INSTANCE =
+      new DexDebugInfoForSingleLineMethod(0, DexString.EMPTY_ARRAY, DexDebugEvent.EMPTY_ARRAY);
+
+  private DexDebugInfoForSingleLineMethod(
+      int startLine, DexString[] parameters, DexDebugEvent[] events) {
+    super(startLine, parameters, events);
+  }
+
+  public static DexDebugInfoForSingleLineMethod getInstance() {
+    return INSTANCE;
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/graph/DexDebugPositionState.java b/src/main/java/com/android/tools/r8/graph/DexDebugPositionState.java
index e17446d..b56ad04 100644
--- a/src/main/java/com/android/tools/r8/graph/DexDebugPositionState.java
+++ b/src/main/java/com/android/tools/r8/graph/DexDebugPositionState.java
@@ -21,10 +21,11 @@
  * the current state using the getters after a Default event.
  */
 public class DexDebugPositionState implements DexDebugEventVisitor {
+
   private int currentPc = 0;
   private int currentLine;
   private DexString currentFile = null;
-  private DexMethod currentMethod = null;
+  private DexMethod currentMethod;
   private Position currentCallerPosition = null;
 
   public DexDebugPositionState(int startLine, DexMethod method) {
diff --git a/src/main/java/com/android/tools/r8/utils/LineNumberOptimizer.java b/src/main/java/com/android/tools/r8/utils/LineNumberOptimizer.java
index 7a70c5a..37b3626 100644
--- a/src/main/java/com/android/tools/r8/utils/LineNumberOptimizer.java
+++ b/src/main/java/com/android/tools/r8/utils/LineNumberOptimizer.java
@@ -27,6 +27,7 @@
 import com.android.tools.r8.graph.DexDebugEventBuilder;
 import com.android.tools.r8.graph.DexDebugEventVisitor;
 import com.android.tools.r8.graph.DexDebugInfo;
+import com.android.tools.r8.graph.DexDebugInfoForSingleLineMethod;
 import com.android.tools.r8.graph.DexDebugPositionState;
 import com.android.tools.r8.graph.DexEncodedMethod;
 import com.android.tools.r8.graph.DexField;
@@ -67,6 +68,8 @@
 
 public class LineNumberOptimizer {
 
+  private static final int MAX_LINE_NUMBER = 65535;
+
   // PositionRemapper is a stateful function which takes a position (represented by a
   // DexDebugPositionState) and returns a remapped Position.
   private interface PositionRemapper {
@@ -373,21 +376,26 @@
 
         for (DexEncodedMethod method : methods) {
           kotlinRemapper.currentMethod = method;
-          List<MappedPosition> mappedPositions = new ArrayList<>();
+          List<MappedPosition> mappedPositions;
           Code code = method.getCode();
           if (code != null) {
             if (code.isDexCode() && doesContainPositions(code.asDexCode())) {
               if (appView.options().canUseDexPcAsDebugInformation() && methods.size() == 1) {
-                optimizeDexCodePositionsForPc(method, appView, kotlinRemapper, mappedPositions);
+                mappedPositions = optimizeDexCodePositionsForPc(method, appView, kotlinRemapper);
               } else {
-                optimizeDexCodePositions(
-                    method, appView, kotlinRemapper, mappedPositions, identityMapping);
+                mappedPositions =
+                    optimizeDexCodePositions(
+                        method, appView, kotlinRemapper, identityMapping, methods.size() != 1);
               }
             } else if (code.isCfCode()
                 && doesContainPositions(code.asCfCode())
                 && !appView.isCfByteCodePassThrough(method)) {
-              optimizeCfCodePositions(method, kotlinRemapper, mappedPositions, appView);
+              mappedPositions = optimizeCfCodePositions(method, kotlinRemapper, appView);
+            } else {
+              mappedPositions = new ArrayList<>();
             }
+          } else {
+            mappedPositions = new ArrayList<>();
           }
 
           DexMethod originalMethod =
@@ -472,10 +480,20 @@
                 lastPosition = mp;
               }
             }
-            Range obfuscatedRange =
-                new Range(firstPosition.obfuscatedLine, lastPosition.obfuscatedLine);
             Range originalRange = new Range(firstPosition.originalLine, lastPosition.originalLine);
 
+            Range obfuscatedRange;
+            if (method.getCode().isDexCode()
+                && method.getCode().asDexCode().getDebugInfo()
+                    == DexDebugInfoForSingleLineMethod.getInstance()) {
+              assert firstPosition.originalLine == lastPosition.originalLine;
+              method.getCode().asDexCode().setDebugInfo(null);
+              obfuscatedRange = new Range(0, MAX_LINE_NUMBER);
+            } else {
+              obfuscatedRange =
+                  new Range(firstPosition.obfuscatedLine, lastPosition.obfuscatedLine);
+            }
+
             ClassNaming.Builder classNamingBuilder = onDemandClassNamingBuilder.get();
             MappedRange lastMappedRange =
                 classNamingBuilder.addMappedRange(
@@ -498,6 +516,11 @@
             }
             i = j;
           }
+          if (method.getCode().isDexCode()
+              && method.getCode().asDexCode().getDebugInfo()
+                  == DexDebugInfoForSingleLineMethod.getInstance()) {
+            method.getCode().asDexCode().setDebugInfo(null);
+          }
         } // for each method of the group
       } // for each method group, grouped by name
     } // for each class
@@ -667,14 +690,15 @@
     return false;
   }
 
-  private static void optimizeDexCodePositions(
+  private static List<MappedPosition> optimizeDexCodePositions(
       DexEncodedMethod method,
       AppView<?> appView,
       PositionRemapper positionRemapper,
-      List<MappedPosition> mappedPositions,
-      boolean identityMapping) {
+      boolean identityMapping,
+      boolean hasOverloads) {
+    List<MappedPosition> mappedPositions = new ArrayList<>();
     // Do the actual processing for each method.
-    final DexApplication application = appView.appInfo().app();
+    DexApplication application = appView.appInfo().app();
     DexCode dexCode = method.getCode().asDexCode();
     DexDebugInfo debugInfo = dexCode.getDebugInfo();
     List<DexDebugEvent> processedEvents = new ArrayList<>();
@@ -688,7 +712,7 @@
     Box<Boolean> inlinedOriginalPosition = new Box<>(false);
 
     // Debug event visitor to map line numbers.
-    DexDebugEventVisitor visitor =
+    DexDebugPositionState visitor =
         new DexDebugPositionState(
             debugInfo.startLine,
             appView.graphLens().getOriginalMethodSignature(method.getReference())) {
@@ -768,6 +792,15 @@
       event.accept(visitor);
     }
 
+    // If we only have one line event we can always retrace back uniquely.
+    if (mappedPositions.size() <= 1
+        && !hasOverloads
+        && !appView.options().debug
+        && appView.options().lineNumberOptimization != LineNumberOptimization.OFF) {
+      dexCode.setDebugInfo(DexDebugInfoForSingleLineMethod.getInstance());
+      return mappedPositions;
+    }
+
     DexDebugInfo optimizedDebugInfo =
         new DexDebugInfo(
             positionEventEmitter.getStartLine(),
@@ -779,13 +812,12 @@
         || verifyIdentityMapping(debugInfo, optimizedDebugInfo);
 
     dexCode.setDebugInfo(optimizedDebugInfo);
+    return mappedPositions;
   }
 
-  private static void optimizeDexCodePositionsForPc(
-      DexEncodedMethod method,
-      AppView<?> appView,
-      PositionRemapper positionRemapper,
-      List<MappedPosition> mappedPositions) {
+  private static List<MappedPosition> optimizeDexCodePositionsForPc(
+      DexEncodedMethod method, AppView<?> appView, PositionRemapper positionRemapper) {
+    List<MappedPosition> mappedPositions = new ArrayList<>();
     // Do the actual processing for each method.
     DexCode dexCode = method.getCode().asDexCode();
     DexDebugInfo debugInfo = dexCode.getDebugInfo();
@@ -834,6 +866,7 @@
     }
 
     dexCode.setDebugInfo(null);
+    return mappedPositions;
   }
 
   private static boolean verifyIdentityMapping(
@@ -846,11 +879,9 @@
     return true;
   }
 
-  private static void optimizeCfCodePositions(
-      DexEncodedMethod method,
-      PositionRemapper positionRemapper,
-      List<MappedPosition> mappedPositions,
-      AppView<?> appView) {
+  private static List<MappedPosition> optimizeCfCodePositions(
+      DexEncodedMethod method, PositionRemapper positionRemapper, AppView<?> appView) {
+    List<MappedPosition> mappedPositions = new ArrayList<>();
     // Do the actual processing for each method.
     CfCode oldCode = method.getCode().asCfCode();
     List<CfInstruction> oldInstructions = oldCode.getInstructions();
@@ -877,6 +908,7 @@
             oldCode.getTryCatchRanges(),
             oldCode.getLocalVariables()),
         appView);
+    return mappedPositions;
   }
 
   private static Position remapAndAdd(
diff --git a/src/test/java/com/android/tools/r8/debug/LoadInvokeLoadOptimizationTestRunner.java b/src/test/java/com/android/tools/r8/debug/LoadInvokeLoadOptimizationTestRunner.java
index 785db86..18ae157 100644
--- a/src/test/java/com/android/tools/r8/debug/LoadInvokeLoadOptimizationTestRunner.java
+++ b/src/test/java/com/android/tools/r8/debug/LoadInvokeLoadOptimizationTestRunner.java
@@ -3,7 +3,6 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.debug;
 
-import com.android.tools.r8.CompilationMode;
 import com.android.tools.r8.ToolHelper;
 import com.android.tools.r8.debug.DebugTestBase.JUnit3Wrapper.FrameInspector;
 import com.android.tools.r8.utils.DescriptorUtils;
@@ -40,7 +39,7 @@
                   .noMinification()
                   .addKeepRules("-keepattributes SourceFile,LineNumberTable")
                   .addProgramClasses(CLASS)
-                  .setMode(CompilationMode.DEBUG)
+                  .debug()
                   .debugConfig());
     }
     return parameters.build();
diff --git a/src/test/java/com/android/tools/r8/debug/R8DebugNonMinifiedProgramTestRunner.java b/src/test/java/com/android/tools/r8/debug/R8DebugNonMinifiedProgramTestRunner.java
index 9771a28..c206daa 100644
--- a/src/test/java/com/android/tools/r8/debug/R8DebugNonMinifiedProgramTestRunner.java
+++ b/src/test/java/com/android/tools/r8/debug/R8DebugNonMinifiedProgramTestRunner.java
@@ -6,7 +6,6 @@
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
-import static org.junit.Assume.assumeTrue;
 
 import com.android.tools.r8.R8FullTestBuilder;
 import com.android.tools.r8.R8TestCompileResult;
@@ -37,22 +36,11 @@
   private static BiFunction<Backend, AndroidApiLevel, R8TestCompileResult> compiledDebug
       = memoizeBiFunction(R8DebugNonMinifiedProgramTestRunner::compileDebug);
 
-  private static BiFunction<Backend, AndroidApiLevel, R8TestCompileResult> compiledNoOptNoMinify
-      = memoizeBiFunction(R8DebugNonMinifiedProgramTestRunner::compileNoOptNoMinify);
-
   private static R8TestCompileResult compileDebug(Backend backend, AndroidApiLevel apiLevel)
       throws Exception {
     return compile(testForR8(getStaticTemp(), backend).debug(), apiLevel);
   }
 
-  private static R8TestCompileResult compileNoOptNoMinify(Backend backend, AndroidApiLevel apiLevel)
-      throws Exception {
-    return compile(
-        testForR8(getStaticTemp(), backend)
-            .addKeepRules("-dontoptimize", "-dontobfuscate", "-keepattributes LineNumberTable"),
-        apiLevel);
-  }
-
   private static R8TestCompileResult compile(R8FullTestBuilder builder, AndroidApiLevel apiLevel)
       throws Exception {
     return builder
@@ -70,24 +58,11 @@
             });
   }
 
-  private void assumeMappingIsNotToPCs() {
-    assumeTrue(
-        "Ignoring test when the line number table is removed.",
-        parameters.isCfRuntime()
-            || parameters.getApiLevel().isLessThan(apiLevelWithPcAsLineNumberSupport()));
-  }
-
   @Test
   public void testDebugMode() throws Throwable {
     runTest(compiledDebug.apply(parameters.getBackend(), parameters.getApiLevel()));
   }
 
-  @Test
-  public void testNoOptimizationAndNoMinification() throws Throwable {
-    assumeMappingIsNotToPCs();
-    runTest(compiledNoOptNoMinify.apply(parameters.getBackend(), parameters.getApiLevel()));
-  }
-
   private void runTest(R8TestCompileResult compileResult) throws Throwable {
     compileResult
         .run(parameters.getRuntime(), CLASS)
diff --git a/src/test/java/com/android/tools/r8/debuginfo/CanonicalizeWithInline.java b/src/test/java/com/android/tools/r8/debuginfo/CanonicalizeWithInline.java
index 73aff7f..48b9fc8 100644
--- a/src/test/java/com/android/tools/r8/debuginfo/CanonicalizeWithInline.java
+++ b/src/test/java/com/android/tools/r8/debuginfo/CanonicalizeWithInline.java
@@ -66,7 +66,7 @@
     result.app.write(classesPath, OutputMode.DexIndexed);
     int numberOfDebugInfos =
         getNumberOfDebugInfos(Paths.get(temp.getRoot().getCanonicalPath(), "classes.dex"));
-    Assert.assertEquals(1, numberOfDebugInfos);
+    Assert.assertEquals(0, numberOfDebugInfos);
   }
 
   // Two classes which has debug info that looks exactly the same, except for SetInlineFrame.
diff --git a/src/test/java/com/android/tools/r8/debuginfo/InliningWithoutPositionsTestRunner.java b/src/test/java/com/android/tools/r8/debuginfo/InliningWithoutPositionsTestRunner.java
index 17dadf2..4898ef3 100644
--- a/src/test/java/com/android/tools/r8/debuginfo/InliningWithoutPositionsTestRunner.java
+++ b/src/test/java/com/android/tools/r8/debuginfo/InliningWithoutPositionsTestRunner.java
@@ -140,7 +140,6 @@
     int expectedLineNumber = throwLocation == Location.FOO2 ? 2 : 1;
     String expectedFilePos = TEST_CLASS + ".java:" + expectedLineNumber;
     int idx = line.indexOf(expectedFilePos);
-    assertTrue(idx >= 0);
 
     // And the next character must be a non-digit or nothing.
     int idxAfter = idx + expectedFilePos.length();
diff --git a/src/test/java/com/android/tools/r8/debuginfo/SingleLineInfoInlineRemoveTest.java b/src/test/java/com/android/tools/r8/debuginfo/SingleLineInfoInlineRemoveTest.java
new file mode 100644
index 0000000..dd9bcc7
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/debuginfo/SingleLineInfoInlineRemoveTest.java
@@ -0,0 +1,102 @@
+// Copyright (c) 2021, 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.debuginfo;
+
+import static com.android.tools.r8.naming.retrace.StackTrace.isSame;
+import static com.android.tools.r8.utils.codeinspector.Matchers.hasLineNumberTable;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static com.android.tools.r8.utils.codeinspector.Matchers.notIf;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.TestRuntime.CfRuntime;
+import com.android.tools.r8.naming.retrace.StackTrace;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class SingleLineInfoInlineRemoveTest extends TestBase {
+
+  private final TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  public SingleLineInfoInlineRemoveTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  public StackTrace expectedStackTrace;
+
+  @Before
+  public void setup() throws Exception {
+    // Get the expected stack trace by running on the JVM.
+    expectedStackTrace =
+        testForJvm()
+            .addTestClasspath()
+            .run(CfRuntime.getSystemRuntime(), Main.class)
+            .assertFailureWithErrorThatThrows(NullPointerException.class)
+            .map(StackTrace::extractFromJvm);
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    testForR8(parameters.getBackend())
+        .addInnerClasses(getClass())
+        .setMinApi(parameters.getApiLevel())
+        .addKeepMainRule(Main.class)
+        .addKeepAttributeSourceFile()
+        .addKeepAttributeLineNumberTable()
+        .enableInliningAnnotations()
+        .run(parameters.getRuntime(), Main.class)
+        .assertFailureWithErrorThatThrows(NullPointerException.class)
+        .inspectStackTrace(
+            (stackTrace, inspector) -> {
+              assertThat(stackTrace, isSame(expectedStackTrace));
+              ClassSubject mainSubject = inspector.clazz(Main.class);
+              assertThat(mainSubject, isPresent());
+              assertThat(mainSubject.uniqueMethodWithName("inlinee"), not(isPresent()));
+              assertThat(
+                  mainSubject.uniqueMethodWithName("shouldRemoveLineNumberForInline"),
+                  notIf(hasLineNumberTable(), parameters.isDexRuntime()));
+            });
+  }
+
+  public static class Main {
+
+    @NeverInline
+    public static void printOrThrow(String message) {
+      if (System.currentTimeMillis() > 0) {
+        throw new NullPointerException(message);
+      }
+      System.out.println(message);
+    }
+
+    public static void inlinee() {
+      printOrThrow("Hello from inlinee");
+    }
+
+    @NeverInline
+    public static void shouldRemoveLineNumberForInline() {
+      inlinee();
+    }
+
+    public static void main(String[] args) {
+      if (args.length == 0) {
+        shouldRemoveLineNumberForInline();
+      }
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/debuginfo/SingleLineInfoMultipleCallsRemoveTest.java b/src/test/java/com/android/tools/r8/debuginfo/SingleLineInfoMultipleCallsRemoveTest.java
new file mode 100644
index 0000000..d7a5df3
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/debuginfo/SingleLineInfoMultipleCallsRemoveTest.java
@@ -0,0 +1,117 @@
+// Copyright (c) 2021, 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.debuginfo;
+
+import static com.android.tools.r8.naming.retrace.StackTrace.isSame;
+import static com.android.tools.r8.utils.codeinspector.Matchers.hasLineNumberTable;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static com.android.tools.r8.utils.codeinspector.Matchers.notIf;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.TestRuntime.CfRuntime;
+import com.android.tools.r8.naming.retrace.StackTrace;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class SingleLineInfoMultipleCallsRemoveTest extends TestBase {
+
+  private final TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  public SingleLineInfoMultipleCallsRemoveTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  public StackTrace expectedStackTrace;
+
+  @Before
+  public void setup() throws Exception {
+    // Get the expected stack trace by running on the JVM.
+    expectedStackTrace =
+        testForJvm()
+            .addTestClasspath()
+            .run(CfRuntime.getSystemRuntime(), Main.class)
+            .assertFailureWithErrorThatThrows(NullPointerException.class)
+            .map(StackTrace::extractFromJvm);
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    testForR8(parameters.getBackend())
+        .addInnerClasses(getClass())
+        .setMinApi(parameters.getApiLevel())
+        .addKeepMainRule(Main.class)
+        .addKeepAttributeSourceFile()
+        .addKeepAttributeLineNumberTable()
+        .enableNeverClassInliningAnnotations()
+        .enableInliningAnnotations()
+        .run(parameters.getRuntime(), Main.class)
+        .assertFailureWithErrorThatThrows(NullPointerException.class)
+        .inspectStackTrace(
+            (stackTrace, inspector) -> {
+              assertThat(stackTrace, isSame(expectedStackTrace));
+              assertThat(inspector.clazz(Builder.class), isPresent());
+              ClassSubject mainSubject = inspector.clazz(Main.class);
+              assertThat(mainSubject, isPresent());
+              assertThat(
+                  mainSubject.uniqueMethodWithName("shouldRemoveLineNumberForMultipleInvokes"),
+                  notIf(hasLineNumberTable(), parameters.isDexRuntime()));
+              assertThat(
+                  mainSubject.uniqueMethodWithName("main"),
+                  notIf(hasLineNumberTable(), parameters.isDexRuntime()));
+            });
+  }
+
+  @NeverClassInline
+  public static class Builder {
+
+    StringBuilder sb = new StringBuilder();
+
+    @NeverInline
+    public Builder add(String str) {
+      sb.append(str);
+      return this;
+    }
+
+    @NeverInline
+    public String build() {
+      return sb.toString();
+    }
+  }
+
+  public static class Main {
+
+    @NeverInline
+    public static void printOrThrow(String message) {
+      if (System.currentTimeMillis() > 0) {
+        throw new NullPointerException(message);
+      }
+      System.out.println(message);
+    }
+
+    @NeverInline
+    public static void shouldRemoveLineNumberForMultipleInvokes() {
+      printOrThrow(new Builder().add("foo").add("bar").add("baz").build());
+    }
+
+    public static void main(String[] args) {
+      shouldRemoveLineNumberForMultipleInvokes();
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/debuginfo/SingleLineInfoMultipleInlineTest.java b/src/test/java/com/android/tools/r8/debuginfo/SingleLineInfoMultipleInlineTest.java
new file mode 100644
index 0000000..bc0d012
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/debuginfo/SingleLineInfoMultipleInlineTest.java
@@ -0,0 +1,112 @@
+// Copyright (c) 2021, 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.debuginfo;
+
+import static com.android.tools.r8.naming.retrace.StackTrace.isSame;
+import static com.android.tools.r8.utils.codeinspector.Matchers.hasLineNumberTable;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static com.android.tools.r8.utils.codeinspector.Matchers.notIf;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.TestRuntime.CfRuntime;
+import com.android.tools.r8.naming.retrace.StackTrace;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class SingleLineInfoMultipleInlineTest extends TestBase {
+
+  private final TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  public SingleLineInfoMultipleInlineTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  public StackTrace expectedStackTrace;
+
+  @Before
+  public void setup() throws Exception {
+    // Get the expected stack trace by running on the JVM.
+    expectedStackTrace =
+        testForJvm()
+            .addTestClasspath()
+            .run(CfRuntime.getSystemRuntime(), Main.class)
+            .assertFailureWithErrorThatThrows(NullPointerException.class)
+            .map(StackTrace::extractFromJvm);
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    testForR8(parameters.getBackend())
+        .addInnerClasses(getClass())
+        .setMinApi(parameters.getApiLevel())
+        .addKeepMainRule(Main.class)
+        .addKeepAttributeSourceFile()
+        .addKeepAttributeLineNumberTable()
+        .enableInliningAnnotations()
+        .run(parameters.getRuntime(), Main.class)
+        .assertFailureWithErrorThatThrows(NullPointerException.class)
+        .inspectStackTrace(
+            (stackTrace, inspector) -> {
+              assertThat(stackTrace, isSame(expectedStackTrace));
+              ClassSubject mainSubject = inspector.clazz(Main.class);
+              assertThat(mainSubject, isPresent());
+              assertThat(mainSubject.uniqueMethodWithName("inlinee"), not(isPresent()));
+              assertThat(
+                  mainSubject.uniqueMethodWithName("shouldNotRemoveLineNumberForInline"),
+                  notIf(
+                      hasLineNumberTable(),
+                      parameters.isDexRuntime()
+                          && parameters
+                              .getApiLevel()
+                              .isGreaterThanOrEqualTo(apiLevelWithPcAsLineNumberSupport())));
+            });
+  }
+
+  public static class Main {
+
+    @NeverInline
+    public static void printOrThrow(String message) {
+      if (System.currentTimeMillis() > 0) {
+        throw new NullPointerException(message);
+      }
+      System.out.println(message);
+    }
+
+    public static void inlinee() {
+      printOrThrow("Hello from inlinee");
+    }
+
+    public static void inlinee2() {
+      printOrThrow("Hello from inlinee2");
+    }
+
+    @NeverInline
+    public static void shouldNotRemoveLineNumberForInline() {
+      inlinee();
+      inlinee2();
+    }
+
+    public static void main(String[] args) {
+      if (args.length == 0) {
+        shouldNotRemoveLineNumberForInline();
+      }
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/debuginfo/SingleLineInfoRemoveTest.java b/src/test/java/com/android/tools/r8/debuginfo/SingleLineInfoRemoveTest.java
new file mode 100644
index 0000000..652f401
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/debuginfo/SingleLineInfoRemoveTest.java
@@ -0,0 +1,94 @@
+// Copyright (c) 2021, 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.debuginfo;
+
+import static com.android.tools.r8.naming.retrace.StackTrace.isSame;
+import static com.android.tools.r8.utils.codeinspector.Matchers.hasLineNumberTable;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static com.android.tools.r8.utils.codeinspector.Matchers.notIf;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.TestRuntime.CfRuntime;
+import com.android.tools.r8.naming.retrace.StackTrace;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class SingleLineInfoRemoveTest extends TestBase {
+
+  private final TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  public SingleLineInfoRemoveTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  public StackTrace expectedStackTrace;
+
+  @Before
+  public void setup() throws Exception {
+    // Get the expected stack trace by running on the JVM.
+    expectedStackTrace =
+        testForJvm()
+            .addTestClasspath()
+            .run(CfRuntime.getSystemRuntime(), Main.class)
+            .assertFailure()
+            .map(StackTrace::extractFromJvm);
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    testForR8(parameters.getBackend())
+        .addInnerClasses(getClass())
+        .setMinApi(parameters.getApiLevel())
+        .addKeepMainRule(Main.class)
+        .addKeepAttributeSourceFile()
+        .addKeepAttributeLineNumberTable()
+        .enableInliningAnnotations()
+        .run(parameters.getRuntime(), Main.class)
+        .assertFailureWithErrorThatThrows(NullPointerException.class)
+        .inspectStackTrace(
+            (stackTrace, inspector) -> {
+              assertThat(stackTrace, isSame(expectedStackTrace));
+              ClassSubject mainSubject = inspector.clazz(Main.class);
+              assertThat(mainSubject, isPresent());
+              assertThat(
+                  mainSubject.uniqueMethodWithName("shouldRemoveLineNumber"),
+                  notIf(hasLineNumberTable(), parameters.isDexRuntime()));
+            });
+  }
+
+  public static class Main {
+
+    @NeverInline
+    public static void printOrThrow(String message) {
+      if (System.currentTimeMillis() > 0) {
+        throw new NullPointerException(message);
+      }
+      System.out.println(message);
+    }
+
+    @NeverInline
+    public static void shouldRemoveLineNumber() {
+      printOrThrow("Hello World");
+    }
+
+    public static void main(String[] args) {
+      shouldRemoveLineNumber();
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/naming/retrace/DesugarStaticInterfaceMethodsInlineIntoStaticRetraceTest.java b/src/test/java/com/android/tools/r8/naming/retrace/DesugarStaticInterfaceMethodsInlineIntoStaticRetraceTest.java
deleted file mode 100644
index 56f306c..0000000
--- a/src/test/java/com/android/tools/r8/naming/retrace/DesugarStaticInterfaceMethodsInlineIntoStaticRetraceTest.java
+++ /dev/null
@@ -1,86 +0,0 @@
-// Copyright (c) 2019, 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.naming.retrace;
-
-import static com.android.tools.r8.naming.retrace.StackTrace.isSameExceptForFileName;
-import static org.hamcrest.MatcherAssert.assertThat;
-
-import com.android.tools.r8.CompilationMode;
-import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.R8TestBuilder;
-import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.utils.BooleanUtils;
-import com.google.common.collect.ImmutableList;
-import java.util.Collection;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameters;
-
-@RunWith(Parameterized.class)
-public class DesugarStaticInterfaceMethodsInlineIntoStaticRetraceTest extends RetraceTestBase {
-
-  @Parameters(name = "{0}, mode: {1}, compat: {2}")
-  public static Collection<Object[]> data() {
-    return buildParameters(
-        getTestParameters().withAllRuntimesAndApiLevels().build(),
-        CompilationMode.values(),
-        BooleanUtils.values());
-  }
-
-  public DesugarStaticInterfaceMethodsInlineIntoStaticRetraceTest(
-      TestParameters parameters, CompilationMode mode, boolean compat) {
-    super(parameters, mode, compat);
-  }
-
-  @Override
-  public void configure(R8TestBuilder<?> builder) {
-    builder.enableInliningAnnotations();
-  }
-
-  @Override
-  public Collection<Class<?>> getClasses() {
-    return ImmutableList.of(
-        getMainClass(), InterfaceWithStaticMethod1.class, InterfaceWithStaticMethod2.class);
-  }
-
-  @Override
-  public Class<?> getMainClass() {
-    return MainDesugarStaticInterfaceMethodsRetraceTest.class;
-  }
-
-  @Test
-  public void testSourceFileAndLineNumberTable() throws Exception {
-    runTest(
-        ImmutableList.of("-keepattributes SourceFile,LineNumberTable"),
-        // Companion methods are treated as having inlined the interface method code.
-        // If compiling with synthetic marking support in the mapping file, the synthetic frames
-        // are removed and the trace will be equal to RI.
-        (StackTrace actualStackTrace, StackTrace retracedStackTrace) ->
-            assertThat(retracedStackTrace, isSameExceptForFileName(expectedStackTrace)));
-  }
-}
-
-interface InterfaceWithStaticMethod2 {
-
-  static void staticMethod2() {
-    throw null;
-  }
-}
-
-interface InterfaceWithStaticMethod1 {
-
-  @NeverInline
-  static void staticMethod1() {
-    InterfaceWithStaticMethod2.staticMethod2();
-  }
-}
-
-class MainDesugarStaticInterfaceMethodsRetraceTest {
-
-  public static void main(String[] args) {
-    InterfaceWithStaticMethod1.staticMethod1();
-  }
-}
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/Matchers.java b/src/test/java/com/android/tools/r8/utils/codeinspector/Matchers.java
index 7a78ed0..6e83620 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/Matchers.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/Matchers.java
@@ -567,6 +567,10 @@
     };
   }
 
+  public static Matcher<MethodSubject> hasLineNumberTable() {
+    return isMethodSatisfying("line number table", method -> method.getLineNumberTable() != null);
+  }
+
   public static Matcher<RetraceFrameResult> isInlineFrame() {
     return new TypeSafeMatcher<RetraceFrameResult>() {
       @Override