diff --git a/src/main/java/com/android/tools/r8/Version.java b/src/main/java/com/android/tools/r8/Version.java
index f244e33..14b53f4 100644
--- a/src/main/java/com/android/tools/r8/Version.java
+++ b/src/main/java/com/android/tools/r8/Version.java
@@ -11,7 +11,7 @@
 
   // This field is accessed from release scripts using simple pattern matching.
   // Therefore, changing this field could break our release scripts.
-  public static final String LABEL = "1.5.50";
+  public static final String LABEL = "1.5.51";
 
   private Version() {
   }
diff --git a/src/main/java/com/android/tools/r8/graph/JarCode.java b/src/main/java/com/android/tools/r8/graph/JarCode.java
index f1f3eca..38b5e1a 100644
--- a/src/main/java/com/android/tools/r8/graph/JarCode.java
+++ b/src/main/java/com/android/tools/r8/graph/JarCode.java
@@ -18,13 +18,17 @@
 import com.android.tools.r8.naming.ClassNameMapper;
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.android.tools.r8.shaking.ProguardConfiguration;
 import com.android.tools.r8.shaking.ProguardKeepAttributes;
 import com.android.tools.r8.utils.DescriptorUtils;
 import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.OffOrAuto;
+import it.unimi.dsi.fastutil.ints.Int2ReferenceArrayMap;
 import java.io.PrintWriter;
 import java.io.StringWriter;
+import java.util.BitSet;
 import java.util.Iterator;
+import java.util.Map;
 import java.util.function.BiFunction;
 import org.objectweb.asm.ClassReader;
 import org.objectweb.asm.ClassVisitor;
@@ -34,6 +38,7 @@
 import org.objectweb.asm.tree.AbstractInsnNode;
 import org.objectweb.asm.tree.LabelNode;
 import org.objectweb.asm.tree.LineNumberNode;
+import org.objectweb.asm.tree.LocalVariableNode;
 import org.objectweb.asm.tree.MethodNode;
 import org.objectweb.asm.tree.TryCatchBlockNode;
 import org.objectweb.asm.util.Textifier;
@@ -148,9 +153,15 @@
       Position callerPosition) {
     triggerDelayedParsingIfNeccessary();
     if (!keepLocals(encodedMethod, appView.options())) {
+      // If the locals are not kept, we might still need a bit of locals information to satisfy
+      // -keepparameternames for R8.
+      Map<Integer, DebugLocalInfo> parameterInfo = collectParameterInfo(encodedMethod, appView);
       // We strip locals here because we will not be able to recover from invalid info.
-      node.localVariables.clear();
-      return internalBuild(context, encodedMethod, appView, generator, callerPosition);
+      if (canStripLocals(encodedMethod, appView)) {
+        node.localVariables.clear();
+      }
+      return internalBuild(
+          context, encodedMethod, appView, generator, callerPosition, parameterInfo);
     } else {
       return internalBuildWithLocals(context, encodedMethod, appView, generator, callerPosition);
     }
@@ -163,11 +174,13 @@
       ValueNumberGenerator generator,
       Position callerPosition) {
     try {
-      return internalBuild(context, encodedMethod, appView, generator, callerPosition);
+      return internalBuild(
+          context, encodedMethod, appView, generator, callerPosition, IRCode.NO_PARAMETER_INFO);
     } catch (InvalidDebugInfoException e) {
       appView.options().warningInvalidDebugInfo(encodedMethod, origin, e);
       node.localVariables.clear();
-      return internalBuild(context, encodedMethod, appView, generator, callerPosition);
+      return internalBuild(
+          context, encodedMethod, appView, generator, callerPosition, IRCode.NO_PARAMETER_INFO);
     }
   }
 
@@ -181,13 +194,75 @@
     return false;
   }
 
+  private Map<Integer, DebugLocalInfo> collectParameterInfo(
+      DexEncodedMethod encodedMethod, AppView<?> appView) {
+    if (!appView.options().hasProguardConfiguration()
+        || !appView.options().getProguardConfiguration().isKeepParameterNames()) {
+      return IRCode.NO_PARAMETER_INFO;
+    }
+    // The enqueuer might build IR to trace reflective behaviour. At that point liveness is not
+    // known, so be conservative with collection parameter name information.
+    if (appView.appInfo().hasLiveness()
+        && !appView.appInfo().withLiveness().isPinned(encodedMethod.method)) {
+      return IRCode.NO_PARAMETER_INFO;
+    }
+    // Collect the local slots used for parameters.
+    BitSet localSlotsForParameters = new BitSet(0);
+    int nextLocalSlotsForParameters = 0;
+    if (!encodedMethod.isStatic()) {
+      localSlotsForParameters.set(nextLocalSlotsForParameters++);
+    }
+    for (DexType type : encodedMethod.method.proto.parameters.values) {
+      localSlotsForParameters.set(nextLocalSlotsForParameters);
+      nextLocalSlotsForParameters += type.isLongType() || type.isDoubleType() ? 2 : 1;
+    }
+    // Collect the first piece of local variable information for each argument local slot,
+    // assuming that that does actually describe the parameter (name, type and possibly
+    // signature).
+    DexItemFactory factory = appView.options().itemFactory;
+    Map<Integer, DebugLocalInfo> parameterInfo =
+        new Int2ReferenceArrayMap<>(localSlotsForParameters.cardinality());
+    for (Object o : node.localVariables) {
+      LocalVariableNode node = (LocalVariableNode) o;
+      if (node.index < nextLocalSlotsForParameters
+          && localSlotsForParameters.get(node.index)
+          && !parameterInfo.containsKey(node.index)) {
+        parameterInfo.put(
+            node.index,
+            new DebugLocalInfo(
+                factory.createString(node.name),
+                factory.createType(factory.createString(node.desc)),
+                node.signature == null ? null : factory.createString(node.signature)));
+      }
+    }
+    return parameterInfo;
+  }
+
+  private boolean canStripLocals(DexEncodedMethod encodedMethod, AppView<?> appView) {
+    // If not keeping parameter names the locals can always be stripped.
+    if (!appView.options().hasProguardConfiguration()
+        || !appView.options().getProguardConfiguration().isKeepParameterNames()) {
+      return true;
+    }
+    // The enqueuer might build IR to trace reflective behaviour. At that point liveness is not
+    // known, so locals cannot be stripped as IR will built again in the IR converter.
+    if (appView.appInfo().hasLiveness()
+        && !appView.appInfo().withLiveness().isPinned(encodedMethod.method)) {
+      return true;
+    }
+    return false;
+  }
+
   private IRCode internalBuild(
       DexEncodedMethod context,
       DexEncodedMethod encodedMethod,
       AppView<?> appView,
       ValueNumberGenerator generator,
-      Position callerPosition) {
-    assert node.localVariables.isEmpty() || keepLocals(encodedMethod, appView.options());
+      Position callerPosition,
+      Map<Integer, DebugLocalInfo> parameterInfo) {
+    assert node.localVariables.isEmpty()
+        || keepLocals(encodedMethod, appView.options())
+        || !canStripLocals(encodedMethod, appView);
     JarSourceCode source =
         new JarSourceCode(
             method.holder,
@@ -196,7 +271,7 @@
             appView.graphLense().getOriginalMethodSignature(encodedMethod.method),
             callerPosition);
     IRBuilder builder = new IRBuilder(encodedMethod, appView, source, origin, generator);
-    return builder.build(context);
+    return builder.build(context, parameterInfo);
   }
 
   @Override
@@ -286,17 +361,19 @@
   }
 
   private void parseCode(ReparseContext context, boolean useJsrInliner) {
-    // If the keep attributes do not specify keeping LocalVariableTable, LocalVariableTypeTable or
-    // LineNumberTable, then we can skip parsing all the debug related attributes during code read.
-    // If the method is reachability sensitive we have to include debug information in order
-    // to get locals information which we need to extend the live ranges of locals for their
-    // entire scope.
+    // If -keepparameternames is not specified and the keep attributes do not specify keeping
+    // either of LocalVariableTable, LocalVariableTypeTable or LineNumberTable, then we can skip
+    // parsing all the debug related attributes during code read. If the method is reachability
+    // sensitive we have to include debug information in order to get locals information which we
+    // need to extend the live ranges of locals for their entire scope.
     int parsingOptions = ClassReader.SKIP_FRAMES;
 
-    if (application.options.getProguardConfiguration() != null) {
+    ProguardConfiguration configuration = application.options.getProguardConfiguration();
+    if (configuration != null && !configuration.isKeepParameterNames()) {
       ProguardKeepAttributes keep =
           application.options.getProguardConfiguration().getKeepAttributes();
-      if (!keep.localVariableTable
+      if (!application.options.getProguardConfiguration().isKeepParameterNames()
+          && !keep.localVariableTable
           && !keep.localVariableTypeTable
           && !keep.lineNumberTable
           && !reachabilitySensitive) {
diff --git a/src/main/java/com/android/tools/r8/ir/code/IRCode.java b/src/main/java/com/android/tools/r8/ir/code/IRCode.java
index ea328b0..f427047 100644
--- a/src/main/java/com/android/tools/r8/ir/code/IRCode.java
+++ b/src/main/java/com/android/tools/r8/ir/code/IRCode.java
@@ -16,6 +16,7 @@
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Sets;
+import it.unimi.dsi.fastutil.ints.Int2ReferenceArrayMap;
 import java.util.ArrayDeque;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -84,6 +85,8 @@
   // When numbering instructions we number instructions only with even numbers. This allows us to
   // use odd instruction numbers for the insertion of moves during spilling.
   public static final int INSTRUCTION_NUMBER_DELTA = 2;
+  public static final Map<Integer, DebugLocalInfo> NO_PARAMETER_INFO =
+      new Int2ReferenceArrayMap<>(0);
 
   public final DexEncodedMethod method;
 
@@ -107,6 +110,8 @@
 
   public final Origin origin;
 
+  public final Map<Integer, DebugLocalInfo> parameterInfo;
+
   public IRCode(
       InternalOptions options,
       DexEncodedMethod method,
@@ -115,7 +120,8 @@
       boolean hasDebugPositions,
       boolean hasMonitorInstruction,
       boolean hasConstString,
-      Origin origin) {
+      Origin origin,
+      Map<Integer, DebugLocalInfo> parameterInfo) {
     assert options != null;
     this.options = options;
     this.method = method;
@@ -125,8 +131,10 @@
     this.hasMonitorInstruction = hasMonitorInstruction;
     this.hasConstString = hasConstString;
     this.origin = origin;
+    this.parameterInfo = parameterInfo;
     // TODO(zerny): Remove or update this property now that all instructions have positions.
     allThrowingInstructionsHavePositions = computeAllThrowingInstructionsHavePositions();
+    assert parameterInfo != null;
   }
 
   public void copyMetadataFromInlinee(IRCode inlinee) {
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/CfBuilder.java b/src/main/java/com/android/tools/r8/ir/conversion/CfBuilder.java
index bfc8352..ffe8806 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/CfBuilder.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/CfBuilder.java
@@ -268,6 +268,7 @@
     CatchHandlers<BasicBlock> tryCatchHandlers = CatchHandlers.EMPTY_BASIC_BLOCK;
     boolean previousFallthrough = false;
 
+    boolean firstBlock = true;
     do {
       CatchHandlers<BasicBlock> handlers = block.getCatchHandlers();
       if (!tryCatchHandlers.equals(handlers)) {
@@ -309,6 +310,11 @@
 
       assert !block.exit().isReturn() || stackHeightTracker.isEmpty();
 
+      if (firstBlock) {
+        addParameterNamesIfRequired(block, code.parameterInfo);
+        firstBlock = false;
+      }
+
       block = nextBlock;
       previousFallthrough = fallthrough;
     } while (block != null);
@@ -625,6 +631,24 @@
     }
   }
 
+  private void addParameterNamesIfRequired(
+      BasicBlock block, Map<Integer, DebugLocalInfo> parameterInfo) {
+    // Don't add this information if the code already have full debug information.
+    if (appView.options().debug) {
+      return;
+    }
+
+    if (code.parameterInfo != IRCode.NO_PARAMETER_INFO) {
+      for (Map.Entry<Integer, DebugLocalInfo> entries : parameterInfo.entrySet()) {
+        LocalVariableInfo localVariableInfo =
+            new LocalVariableInfo(entries.getKey(), entries.getValue(), getLabel(block));
+        CfLabel endLabel = ensureLabel();
+        localVariableInfo.setEnd(endLabel);
+        localVariablesTable.add(localVariableInfo);
+      }
+    }
+  }
+
   // Callbacks
 
   public CfLabel getLabel(BasicBlock target) {
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/IRBuilder.java b/src/main/java/com/android/tools/r8/ir/conversion/IRBuilder.java
index cbddf03..6d9aa3b 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/IRBuilder.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/IRBuilder.java
@@ -496,6 +496,19 @@
    * @return The list of basic blocks. First block is the main entry.
    */
   public IRCode build(DexEncodedMethod context) {
+    return build(context, IRCode.NO_PARAMETER_INFO);
+  }
+
+  /**
+   * Build the high-level IR in SSA form.
+   *
+   * @param context Under what context this IRCode is built. Either the current method or caller.
+   * @param parameterInfo Parameter information to include in the output. Pass <code>
+   *     IRCode.NO_PARAMETER_INFO</code> if this is not relevant. This information is only used if
+   *     the generated code does not contain any debug information.
+   * @return The list of basic blocks. First block is the main entry.
+   */
+  public IRCode build(DexEncodedMethod context, Map<Integer, DebugLocalInfo> parameterInfo) {
     assert source != null;
     source.setUp();
 
@@ -596,7 +609,8 @@
             hasDebugPositions,
             hasMonitorInstruction,
             hasConstString,
-            origin);
+            origin,
+            parameterInfo);
 
     // Verify critical edges are split so we have a place to insert phi moves if necessary.
     assert ir.verifySplitCriticalEdges();
diff --git a/src/main/java/com/android/tools/r8/utils/InternalOptions.java b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
index 2d3100c..7d3b26e 100644
--- a/src/main/java/com/android/tools/r8/utils/InternalOptions.java
+++ b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
@@ -62,6 +62,10 @@
 
   public final DexItemFactory itemFactory;
 
+  public boolean hasProguardConfiguration() {
+    return proguardConfiguration != null;
+  }
+
   public ProguardConfiguration getProguardConfiguration() {
     return proguardConfiguration;
   }
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/ConstantRemovalTest.java b/src/test/java/com/android/tools/r8/ir/optimize/ConstantRemovalTest.java
index 97cb2b2..cd8d101 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/ConstantRemovalTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/ConstantRemovalTest.java
@@ -141,7 +141,8 @@
             false,
             false,
             false,
-            Origin.unknown());
+            Origin.unknown(),
+            IRCode.NO_PARAMETER_INFO);
     PeepholeOptimizer.optimize(code, new MockLinearScanRegisterAllocator(appView, code));
 
     // Check that all four constant number instructions remain.
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/TrivialGotoEliminationTest.java b/src/test/java/com/android/tools/r8/ir/optimize/TrivialGotoEliminationTest.java
index 48a8246..413efce 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/TrivialGotoEliminationTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/TrivialGotoEliminationTest.java
@@ -82,7 +82,8 @@
             false,
             false,
             false,
-            Origin.unknown());
+            Origin.unknown(),
+            IRCode.NO_PARAMETER_INFO);
     CodeRewriter.collapseTrivialGotos(null, code);
     assertTrue(code.entryBlock().isTrivialGoto());
     assertTrue(blocks.contains(block0));
@@ -169,7 +170,8 @@
             false,
             false,
             false,
-            Origin.unknown());
+            Origin.unknown(),
+            IRCode.NO_PARAMETER_INFO);
     CodeRewriter.collapseTrivialGotos(null, code);
     assertTrue(block0.getInstructions().get(1).isIf());
     assertEquals(block1, block0.getInstructions().get(1).asIf().fallthroughBlock());
diff --git a/src/test/java/com/android/tools/r8/shaking/keepparameternames/KeepParameterNamesTest.java b/src/test/java/com/android/tools/r8/shaking/keepparameternames/KeepParameterNamesTest.java
new file mode 100644
index 0000000..ea203f1
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/shaking/keepparameternames/KeepParameterNamesTest.java
@@ -0,0 +1,273 @@
+// 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.shaking.keepparameternames;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.KeepUnusedArguments;
+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.TestShrinkerBuilder;
+import com.android.tools.r8.utils.BooleanUtils;
+import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.LocalVariableTable;
+import com.android.tools.r8.utils.codeinspector.LocalVariableTable.LocalVariableTableEntry;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import com.android.tools.r8.utils.codeinspector.TypeSubject;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class KeepParameterNamesTest extends TestBase {
+
+  private final TestParameters parameters;
+  private final boolean keepParameterNames;
+  private final boolean enableMinification;
+
+  @Parameterized.Parameters(name = "{0}, keepparameternames {1}, minification {2}")
+  public static Collection<Object[]> data() {
+    return buildParameters(
+        getTestParameters().withCfRuntimes().build(), BooleanUtils.values(), BooleanUtils.values());
+  }
+
+  public KeepParameterNamesTest(
+      TestParameters parameters, boolean keepParameterNames, boolean enableMinification) {
+    this.parameters = parameters;
+    this.keepParameterNames = keepParameterNames;
+    this.enableMinification = enableMinification;
+  }
+
+  private void checkLocalVariable(
+      LocalVariableTableEntry localVariable,
+      int index,
+      String name,
+      TypeSubject type,
+      String signature) {
+    assertEquals(index, localVariable.index);
+    assertEquals(name, localVariable.name);
+    assertEquals(type, localVariable.type);
+    assertEquals(signature, localVariable.signature);
+  }
+
+  private void checkLocalVariableTable(CodeInspector inspector) {
+    ClassSubject classSubject = inspector.clazz(Api.class);
+    assertThat(classSubject, isPresent());
+
+    MethodSubject method;
+    method = classSubject.uniqueMethodWithName("apiNoArgs");
+    assertThat(method, isPresent());
+    assertEquals(keepParameterNames, method.hasLocalVariableTable());
+    if (keepParameterNames) {
+      LocalVariableTable localVariableTable = method.getLocalVariableTable();
+      assertEquals(1, localVariableTable.size());
+      assertEquals("this", localVariableTable.get(0).name);
+      assertTrue(localVariableTable.get(0).type.is(classSubject));
+    } else {
+      assertTrue(method.getLocalVariableTable().isEmpty());
+    }
+
+    method = classSubject.uniqueMethodWithName("apiNoArgsStatic");
+    assertThat(method, isPresent());
+    assertFalse(method.hasLocalVariableTable());
+    assertTrue(method.getLocalVariableTable().isEmpty());
+
+    method = classSubject.uniqueMethodWithName("api1");
+    assertThat(method, isPresent());
+    assertEquals(keepParameterNames, method.hasLocalVariableTable());
+    if (keepParameterNames) {
+      LocalVariableTable localVariableTable = method.getLocalVariableTable();
+      assertEquals(3, localVariableTable.size());
+      checkLocalVariable(
+          localVariableTable.get(0),
+          0,
+          "this",
+          classSubject.asFoundClassSubject().asTypeSybject(),
+          null);
+      checkLocalVariable(
+          localVariableTable.get(1), 1, "parameter1", inspector.getTypeSubject("int"), null);
+      checkLocalVariable(
+          localVariableTable.get(2),
+          2,
+          "parameter2",
+          inspector.getTypeSubject("java.lang.String"),
+          null);
+    } else {
+      assertTrue(method.getLocalVariableTable().isEmpty());
+    }
+
+    method = classSubject.uniqueMethodWithName("api2");
+    assertThat(method, isPresent());
+    assertEquals(keepParameterNames, method.hasLocalVariableTable());
+    if (keepParameterNames) {
+      LocalVariableTable localVariableTable = method.getLocalVariableTable();
+      assertEquals(3, localVariableTable.size());
+      checkLocalVariable(
+          localVariableTable.get(0),
+          0,
+          "this",
+          classSubject.asFoundClassSubject().asTypeSybject(),
+          null);
+      checkLocalVariable(
+          localVariableTable.get(1), 1, "parameter1", inspector.getTypeSubject("long"), null);
+      checkLocalVariable(
+          localVariableTable.get(2), 3, "parameter2", inspector.getTypeSubject("double"), null);
+    } else {
+      assertTrue(method.getLocalVariableTable().isEmpty());
+    }
+
+    method = classSubject.uniqueMethodWithName("api3");
+    assertThat(method, isPresent());
+    assertEquals(keepParameterNames, method.hasLocalVariableTable());
+    if (keepParameterNames) {
+      LocalVariableTable localVariableTable = method.getLocalVariableTable();
+      assertEquals(3, localVariableTable.size());
+      checkLocalVariable(
+          localVariableTable.get(0),
+          0,
+          "this",
+          classSubject.asFoundClassSubject().asTypeSybject(),
+          null);
+      checkLocalVariable(
+          localVariableTable.get(1),
+          1,
+          "parameter1",
+          inspector.getTypeSubject("java.util.List"),
+          "Ljava/util/List<Ljava/lang/String;>;");
+      checkLocalVariable(
+          localVariableTable.get(2),
+          2,
+          "parameter2",
+          inspector.getTypeSubject("java.util.Map"),
+          "Ljava/util/Map<Ljava/lang/String;Ljava/lang/Object;>;");
+    } else {
+      assertTrue(method.getLocalVariableTable().isEmpty());
+    }
+  }
+
+  @Test
+  public void testApiKept() throws Exception {
+    String expectedOutput =
+        StringUtils.lines(
+            "In Api.apiNoArgs",
+            "In Api.apiNoArgsStatic",
+            "In Api.api1",
+            "In Api.api2",
+            "In Api.api3");
+    testForR8(parameters.getBackend())
+        .addInnerClasses(KeepParameterNamesTest.class)
+        .addKeepMainRule(TestClass.class)
+        .addKeepRules("-keep class " + Api.class.getTypeName() + "{ api*(...); }")
+        .minification(enableMinification)
+        .apply(this::configureKeepParameterNames)
+        .compile()
+        .inspect(this::checkLocalVariableTable)
+        .run(parameters.getRuntime(), TestClass.class)
+        .assertSuccessWithOutput(expectedOutput);
+  }
+
+  private void checkLocalVariableTableNotKept(CodeInspector inspector) {
+    ClassSubject classSubject = inspector.clazz(Api.class);
+    assertThat(classSubject, isPresent());
+    assertEquals(enableMinification, classSubject.isRenamed());
+
+    MethodSubject method;
+    for (String name : new String[] {"apiNoArgs", "apiNoArgsStatic", "api1", "api2", "api3"}) {
+      method = classSubject.uniqueMethodWithName(name);
+      assertThat(method, isPresent());
+      assertEquals(enableMinification, method.isRenamed());
+      assertFalse(method.hasLocalVariableTable());
+      assertTrue(method.getLocalVariableTable().isEmpty());
+    }
+  }
+
+  @Test
+  public void testApiNotKept() throws Exception {
+    String expectedOutput =
+        StringUtils.lines(
+            "In Api.apiNoArgs",
+            "In Api.apiNoArgsStatic",
+            "In Api.api1",
+            "In Api.api2",
+            "In Api.api3");
+    testForR8(parameters.getBackend())
+        .enableClassInliningAnnotations()
+        .enableInliningAnnotations()
+        .enableUnusedArgumentAnnotations()
+        .addInnerClasses(KeepParameterNamesTest.class)
+        .addKeepMainRule(TestClass.class)
+        .minification(enableMinification)
+        .apply(this::configureKeepParameterNames)
+        .compile()
+        .inspect(this::checkLocalVariableTableNotKept)
+        .run(parameters.getRuntime(), TestClass.class)
+        .assertSuccessWithOutput(expectedOutput);
+  }
+
+  private void configureKeepParameterNames(TestShrinkerBuilder builder) {
+    if (keepParameterNames) {
+      builder.addKeepRules("-keepparameternames");
+    }
+  }
+
+  static class TestClass {
+
+    public static void main(String[] args) {
+      Api api = new Api();
+      api.apiNoArgs();
+      Api.apiNoArgsStatic();
+      api.api1(0, "Hello, world!");
+      api.api2(0, 0.0d);
+      api.api3(null, null);
+    }
+  }
+
+  @NeverClassInline
+  static class Api {
+    @NeverInline
+    void apiNoArgs() {
+      System.out.println("In Api.apiNoArgs");
+    }
+
+    @NeverInline
+    static void apiNoArgsStatic() {
+      System.out.println("In Api.apiNoArgsStatic");
+    }
+
+    @NeverInline
+    @KeepUnusedArguments
+    void api1(int parameter1, String parameter2) {
+      try {
+        // Reflective behaviour to trigger IR building in the enqueuer.
+        Class.forName("NotFound");
+      } catch (Exception e) {
+      }
+      System.out.println("In Api.api1");
+    }
+
+    @NeverInline
+    @KeepUnusedArguments
+    void api2(long parameter1, double parameter2) {
+      System.out.println("In Api.api2");
+    }
+
+    @NeverInline
+    @KeepUnusedArguments
+    void api3(List<String> parameter1, Map<String, Object> parameter2) {
+      System.out.println("In Api.api3");
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/AbsentMethodSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/AbsentMethodSubject.java
index fdde9c2..860c36f 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/AbsentMethodSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/AbsentMethodSubject.java
@@ -119,6 +119,11 @@
   }
 
   @Override
+  public LocalVariableTable getLocalVariableTable() {
+    return null;
+  }
+
+  @Override
   public boolean hasLocalVariableTable() {
     throw new Unreachable("Cannot determine if an absent method has a local variable table");
   }
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/CodeInspector.java b/src/test/java/com/android/tools/r8/utils/codeinspector/CodeInspector.java
index 2d30f24..258fb43 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/CodeInspector.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/CodeInspector.java
@@ -163,6 +163,11 @@
     return dexItemFactory.createType(DescriptorUtils.javaTypeToDescriptorIgnorePrimitives(string));
   }
 
+  public TypeSubject getTypeSubject(String string) {
+    return new TypeSubject(
+        this, dexItemFactory.createType(DescriptorUtils.javaTypeToDescriptor(string)));
+  }
+
   String mapType(Map<String, String> mapping, String typeName) {
     final String ARRAY_POSTFIX = "[]";
     int arrayCount = 0;
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/FoundClassSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/FoundClassSubject.java
index 6b3cf1e..74ba390 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/FoundClassSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/FoundClassSubject.java
@@ -20,7 +20,6 @@
 import com.android.tools.r8.naming.signature.GenericSignatureParser;
 import com.android.tools.r8.utils.DescriptorUtils;
 import com.android.tools.r8.utils.StringUtils;
-import java.util.Arrays;
 import java.util.List;
 import java.util.function.Consumer;
 
@@ -293,4 +292,8 @@
   public String toString() {
     return dexClass.toSourceString();
   }
+
+  public TypeSubject asTypeSybject() {
+    return new TypeSubject(codeInspector, getDexClass().type);
+  }
 }
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/FoundMethodSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/FoundMethodSubject.java
index 7770bd5..6b47139 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/FoundMethodSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/FoundMethodSubject.java
@@ -13,6 +13,7 @@
 import com.android.tools.r8.graph.AppInfo;
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.CfCode;
+import com.android.tools.r8.graph.CfCode.LocalVariableInfo;
 import com.android.tools.r8.graph.Code;
 import com.android.tools.r8.graph.DexAnnotation;
 import com.android.tools.r8.graph.DexCode;
@@ -30,6 +31,8 @@
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.Reporter;
+import com.android.tools.r8.utils.codeinspector.LocalVariableTable.LocalVariableTableEntry;
+import com.google.common.collect.ImmutableList;
 import it.unimi.dsi.fastutil.objects.Reference2IntMap;
 import it.unimi.dsi.fastutil.objects.Reference2IntOpenHashMap;
 import java.util.Arrays;
@@ -286,6 +289,46 @@
   }
 
   @Override
+  public LocalVariableTable getLocalVariableTable() {
+    Code code = getMethod().getCode();
+    if (code.isDexCode()) {
+      return getDexLocalVariableTable(code.asDexCode());
+    }
+    if (code.isCfCode()) {
+      return getCfLocalVariableTable(code.asCfCode());
+    }
+    if (code.isJarCode()) {
+      return getJarLocalVariableTable(code.asJarCode());
+    }
+    throw new Unreachable("Unexpected code type: " + code.getClass().getSimpleName());
+  }
+
+  private LocalVariableTable getJarLocalVariableTable(JarCode code) {
+    throw new Unimplemented("No support for inspecting the line number table for JarCode");
+  }
+
+  private LocalVariableTable getCfLocalVariableTable(CfCode code) {
+    ImmutableList.Builder<LocalVariableTableEntry> builder = ImmutableList.builder();
+    for (LocalVariableInfo localVariable : code.getLocalVariables()) {
+      builder.add(
+          new LocalVariableTableEntry(
+              localVariable.getIndex(),
+              localVariable.getLocal().name.toString(),
+              new TypeSubject(codeInspector, localVariable.getLocal().type),
+              localVariable.getLocal().signature == null
+                  ? null
+                  : localVariable.getLocal().signature.toString(),
+              new CfInstructionSubject(localVariable.getStart()),
+              new CfInstructionSubject(localVariable.getEnd())));
+    }
+    return new LocalVariableTable(builder.build());
+  }
+
+  private LocalVariableTable getDexLocalVariableTable(DexCode code) {
+    throw new Unimplemented("No support for inspecting the line number table for DexCode");
+  }
+
+  @Override
   public String toString() {
     return dexMethod.toSourceString();
   }
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/LocalVariableTable.java b/src/test/java/com/android/tools/r8/utils/codeinspector/LocalVariableTable.java
new file mode 100644
index 0000000..fefc4c6
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/LocalVariableTable.java
@@ -0,0 +1,54 @@
+// Copyright (c) 2018, 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.utils.codeinspector;
+
+import java.util.List;
+
+public class LocalVariableTable {
+  public static class LocalVariableTableEntry {
+    public final int index;
+    public final String name;
+    public final TypeSubject type;
+    public final String signature;
+    public final InstructionSubject start;
+    public final InstructionSubject end;
+
+    LocalVariableTableEntry(
+        int index,
+        String name,
+        TypeSubject type,
+        String signature,
+        InstructionSubject start,
+        InstructionSubject end) {
+      this.index = index;
+      this.name = name;
+      this.type = type;
+      this.signature = signature;
+      this.start = start;
+      this.end = end;
+    }
+  }
+
+  private final List<LocalVariableTableEntry> localVariableTable;
+
+  public LocalVariableTable(List<LocalVariableTableEntry> localVariableTable) {
+    this.localVariableTable = localVariableTable;
+  }
+
+  public int size() {
+    return localVariableTable.size();
+  }
+
+  public boolean isEmpty() {
+    return localVariableTable.isEmpty();
+  }
+
+  public LocalVariableTableEntry get(int i) {
+    return localVariableTable.get(i);
+  }
+
+  public List<LocalVariableTableEntry> getEntries() {
+    return localVariableTable;
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/MethodSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/MethodSubject.java
index 0edb4e9..0dc81f1 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/MethodSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/MethodSubject.java
@@ -68,6 +68,8 @@
 
   public abstract LineNumberTable getLineNumberTable();
 
+  public abstract LocalVariableTable getLocalVariableTable();
+
   public abstract boolean hasLocalVariableTable();
 
   public Stream<InstructionSubject> streamInstructions() {
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/TypeSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/TypeSubject.java
index 717c98d..ae59c47 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/TypeSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/TypeSubject.java
@@ -44,6 +44,24 @@
     return dexType == type.getDexClass().type;
   }
 
+  @Override
+  public boolean equals(Object other) {
+    if (this == other) {
+      return true;
+    }
+    if (other instanceof TypeSubject) {
+      TypeSubject o = (TypeSubject) other;
+      assert codeInspector == o.codeInspector;
+      return codeInspector == o.codeInspector && dexType == o.dexType;
+    }
+    return false;
+  }
+
+  @Override
+  public int hashCode() {
+    return dexType.hashCode();
+  }
+
   public String toString() {
     return dexType.toSourceString();
   }