diff --git a/src/main/java/com/android/tools/r8/naming/ClassNamingForMapApplier.java b/src/main/java/com/android/tools/r8/naming/ClassNamingForMapApplier.java
index 5dcc7b8..ba7963b 100644
--- a/src/main/java/com/android/tools/r8/naming/ClassNamingForMapApplier.java
+++ b/src/main/java/com/android/tools/r8/naming/ClassNamingForMapApplier.java
@@ -151,8 +151,8 @@
   MemberNaming lookupByOriginalItem(DexField field) {
     for (Map.Entry<FieldSignature, MemberNaming> entry : fieldMembers.entrySet()) {
       FieldSignature signature = entry.getKey();
-      if (signature.name.equals(field.name.toString())
-          && signature.type.equals(field.type.getName())) {
+      if (signature.name.equals(field.name.toSourceString())
+          && signature.type.equals(field.type.toSourceString())) {
         return entry.getValue();
       }
     }
@@ -162,11 +162,11 @@
   protected MemberNaming lookupByOriginalItem(DexMethod method) {
     for (Map.Entry<MethodSignature, MemberNaming> entry : methodMembers.entrySet()) {
       MethodSignature signature = entry.getKey();
-      if (signature.name.equals(method.name.toString())
-          && signature.type.equals(method.proto.returnType.toString())
+      if (signature.name.equals(method.name.toSourceString())
+          && signature.type.equals(method.proto.returnType.toSourceString())
           && Arrays.equals(signature.parameters,
               Arrays.stream(method.proto.parameters.values)
-                  .map(DexType::toString).toArray(String[]::new))) {
+                  .map(DexType::toSourceString).toArray(String[]::new))) {
         return entry.getValue();
       }
     }
diff --git a/src/main/java/com/android/tools/r8/naming/ProguardMapApplier.java b/src/main/java/com/android/tools/r8/naming/ProguardMapApplier.java
index 25df058..bbf8259 100644
--- a/src/main/java/com/android/tools/r8/naming/ProguardMapApplier.java
+++ b/src/main/java/com/android/tools/r8/naming/ProguardMapApplier.java
@@ -22,8 +22,8 @@
 import com.android.tools.r8.utils.ArrayUtils;
 import com.android.tools.r8.utils.ThrowingConsumer;
 import com.android.tools.r8.utils.Timing;
-import com.google.common.collect.Sets;
 import it.unimi.dsi.fastutil.ints.Int2ObjectArrayMap;
+import java.util.HashSet;
 import java.util.IdentityHashMap;
 import java.util.Map;
 import java.util.Set;
@@ -128,42 +128,80 @@
 
     private void applyMemberMapping(DexType from, ChainedClassNaming classNaming) {
       DexClass clazz = appInfo.definitionFor(from);
-      if (clazz == null) return;
+      if (clazz == null) {
+        return;
+      }
 
-      final Set<MemberNaming> appliedMemberNaming = Sets.newIdentityHashSet();
+      // We regard mappings as _complete_ if they cover literally everything, but that's too ideal.
+      // When visiting members with member mappings, obviously, there are two incomplete cases:
+      // no matched member or no matched mapping.
+      //
+      // 1. No matched member
+      // class A { // : X
+      //   void foo(); // : a
+      // }
+      //
+      // class B extends A { // : Y
+      //   @Override void foo(); // no mapping
+      // }
+      //
+      // For this case, we have chained class naming and move upward to search for super class's
+      // member mapping. One corner case we should be careful here is to resolve on the correct
+      // mapping, e.g.,
+      //
+      // class B extends A { // : Y
+      //   private void foo(); // no mapping, should be not renamed to a
+      // }
+
+      final Set<MemberNaming.Signature> appliedMemberSignature = new HashSet<>();
       clazz.forEachField(encodedField -> {
         MemberNaming memberNaming = classNaming.lookupByOriginalItem(encodedField.field);
         if (memberNaming != null) {
-          appliedMemberNaming.add(memberNaming);
+          appliedMemberSignature.add(memberNaming.getOriginalSignature());
           applyFieldMapping(encodedField.field, memberNaming);
         }
       });
 
       clazz.forEachMethod(encodedMethod -> {
-        MemberNaming memberNaming = classNaming.lookupByOriginalItem(encodedMethod.method);
+        MemberNaming memberNaming =
+            classNaming.lookupByOriginalItem(encodedMethod.method, encodedMethod.isPrivateMethod());
         if (memberNaming != null) {
-          appliedMemberNaming.add(memberNaming);
+          appliedMemberSignature.add(memberNaming.getOriginalSignature());
           applyMethodMapping(encodedMethod.method, memberNaming);
         }
       });
 
+      // 2. No matched mapping
+      // class A { // : X
+      //   void foo(); // : a
+      // }
+      //
+      // class B extends A { // : Y
+      //   // no overriding, but has mapping: void foo() -> a
+      // }
+      //
       // We need to handle a class that extends another class where some members are not overridden,
       // resulting in absence of definitions. References to those members need to be redirected via
       // the lense as well.
+      // The caveat is, since such members don't exist, we pretend to see their definitions.
+      // We should ensure that they indeed don't exist. Otherwise, legitimately different members,
+      // e.g., private methods with same names, could be mapped to a wrong renamed name.
       classNaming.forAllFieldNaming(memberNaming -> {
-        if (!appliedMemberNaming.contains(memberNaming)) {
-          DexField pretendedOriginalField =
-              ((FieldSignature) memberNaming.getOriginalSignature())
-                  .toDexField(appInfo.dexItemFactory, from);
-          applyFieldMapping(pretendedOriginalField, memberNaming);
+        FieldSignature signature = (FieldSignature) memberNaming.getOriginalSignature();
+        if (!appliedMemberSignature.contains(signature)) {
+          DexField pretendedOriginalField = signature.toDexField(appInfo.dexItemFactory, from);
+          if (appInfo.definitionFor(pretendedOriginalField) == null) {
+            applyFieldMapping(pretendedOriginalField, memberNaming);
+          }
         }
       });
       classNaming.forAllMethodNaming(memberNaming -> {
-        if (!appliedMemberNaming.contains(memberNaming)) {
-          DexMethod pretendedOriginalMethod =
-              ((MethodSignature) memberNaming.getOriginalSignature())
-                  .toDexMethod(appInfo.dexItemFactory, from);
-          applyMethodMapping(pretendedOriginalMethod, memberNaming);
+        MethodSignature signature = (MethodSignature) memberNaming.getOriginalSignature();
+        if (!appliedMemberSignature.contains(signature)) {
+          DexMethod pretendedOriginalMethod = signature.toDexMethod(appInfo.dexItemFactory, from);
+          if (appInfo.definitionFor(pretendedOriginalMethod) == null) {
+            applyMethodMapping(pretendedOriginalMethod, memberNaming);
+          }
         }
       });
     }
@@ -229,6 +267,15 @@
       }
     }
 
+    protected MemberNaming lookupByOriginalItem(DexMethod method, boolean isPrivate) {
+      // If the current method is overridable, use chained mappings.
+      if (!isPrivate) {
+        return lookupByOriginalItem(method);
+      }
+      // Otherwise, just look up the current class's mappings only.
+      return super.lookupByOriginalItem(method);
+    }
+
     @Override
     protected MemberNaming lookupByOriginalItem(DexMethod method) {
       MemberNaming memberNaming = super.lookupByOriginalItem(method);
diff --git a/src/main/java/com/android/tools/r8/naming/ProguardMapError.java b/src/main/java/com/android/tools/r8/naming/ProguardMapError.java
index ce659e1..684c79b 100644
--- a/src/main/java/com/android/tools/r8/naming/ProguardMapError.java
+++ b/src/main/java/com/android/tools/r8/naming/ProguardMapError.java
@@ -19,20 +19,20 @@
 
   static ProguardMapError keptTypeWasRenamed(DexType type, String keptName, String rename) {
     return new ProguardMapError(
-        "Warning: " + type + createMessageForConflict(keptName, rename));
+        type + createMessageForConflict(keptName, rename));
   }
 
   static ProguardMapError keptMethodWasRenamed(DexMethod method, String keptName, String rename) {
     return new ProguardMapError(
-        "Warning: " + method.toSourceString() + createMessageForConflict(keptName, rename));
+        method.toSourceString() + createMessageForConflict(keptName, rename));
   }
 
   static ProguardMapError keptFieldWasRenamed(DexField field, String keptName, String rename) {
     return new ProguardMapError(
-        "Warning: " + field.toSourceString() + createMessageForConflict(keptName, rename));
+        field.toSourceString() + createMessageForConflict(keptName, rename));
   }
 
   private static String createMessageForConflict(String keptName, String rename) {
-    return " is not being kept as '" + keptName + "', but remapped to '" + rename + "'";
+    return " is not being kept as " + keptName + ", but remapped to " + rename;
   }
 }
diff --git a/src/test/java/com/android/tools/r8/naming/applymapping/MemberResolutionAsmTest.java b/src/test/java/com/android/tools/r8/naming/applymapping/MemberResolutionAsmTest.java
new file mode 100644
index 0000000..86b0541
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/naming/applymapping/MemberResolutionAsmTest.java
@@ -0,0 +1,216 @@
+// 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.naming.applymapping;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isRenamed;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.not;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertThat;
+
+import com.android.tools.r8.AsmTestBase;
+import com.android.tools.r8.R8Command;
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.ToolHelper.ProcessResult;
+import com.android.tools.r8.origin.Origin;
+import com.android.tools.r8.utils.AndroidApp;
+import com.android.tools.r8.utils.FileUtils;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import com.google.common.collect.ImmutableList;
+import java.nio.file.Path;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class MemberResolutionAsmTest extends AsmTestBase {
+  private final Backend backend;
+
+  @Parameterized.Parameters(name = "backend: {0}")
+  public static Collection<Backend> data() {
+    return Arrays.asList(Backend.values());
+  }
+
+  public MemberResolutionAsmTest(Backend backend) {
+    this.backend = backend;
+  }
+
+  //  class HasMapping { // : X
+  //    HasMapping() {
+  //      foo();
+  //    }
+  //
+  //    void foo() { // : a
+  //      System.out.println("HasMapping#foo");
+  //    }
+  //  }
+  //
+  //  class NoMapping extends HasMapping { // : Y
+  //    NoMapping() {
+  //      super();
+  //      foo();
+  //    }
+  //
+  //    private void foo() { // no mapping
+  //      System.out.println("NoMapping#foo");
+  //    }
+  //  }
+  //
+  //  class NoMappingMain {
+  //    public static void main(String[] args) {
+  //      new NoMapping();
+  //    }
+  //  }
+  @Test
+  public void test_noMapping() throws Exception {
+    String main = "NoMappingMain";
+    AndroidApp input = buildAndroidApp(
+        HasMappingDump.dump(), NoMappingDump.dump(), NoMappingMainDump.dump());
+
+    Path mapPath = temp.newFile("test-mapping.txt").toPath();
+    List<String> pgMap = ImmutableList.of(
+        "HasMapping -> X:",
+        "  void foo() -> a",
+        "NoMapping -> Y:"
+        // Intentionally missing a mapping for `private` foo().
+    );
+    FileUtils.writeTextFile(mapPath, pgMap);
+
+    R8Command.Builder builder = ToolHelper.prepareR8CommandBuilder(input, emptyConsumer(backend));
+    builder
+        .addProguardConfiguration(
+            ImmutableList.of(
+                keepMainProguardConfiguration(main),
+                // Do not turn on -allowaccessmodification
+                "-applymapping " + mapPath,
+                "-dontobfuscate"), // to use the renamed names in test-mapping.txt
+            Origin.unknown())
+        .addLibraryFiles(runtimeJar(backend));
+    AndroidApp processedApp =
+        ToolHelper.runR8(
+            builder.build(),
+            options -> {
+              options.enableInlining = false;
+              options.enableVerticalClassMerging = false;
+            });
+
+    List<byte[]> classBytes = ImmutableList.of(
+        HasMappingDump.dump(), NoMappingDump.dump(), NoMappingMainDump.dump());
+    ProcessResult outputBefore = runOnJavaRaw(main, classBytes, ImmutableList.of());
+    assertEquals(0, outputBefore.exitCode);
+    String outputAfter = runOnVM(processedApp, main, backend);
+    assertEquals(outputBefore.stdout.trim(), outputAfter.trim());
+
+    CodeInspector codeInspector = new CodeInspector(processedApp, mapPath);
+    ClassSubject base = codeInspector.clazz("HasMapping");
+    assertThat(base, isPresent());
+    assertThat(base, isRenamed());
+    assertEquals("X", base.getFinalName());
+    MethodSubject x = base.method("void", "foo", ImmutableList.of());
+    assertThat(x, isPresent());
+    assertThat(x, isRenamed());
+    assertEquals("a", x.getFinalName());
+
+    ClassSubject sub = codeInspector.clazz("NoMapping");
+    assertThat(sub, isPresent());
+    assertThat(sub, isRenamed());
+    assertEquals("Y", sub.getFinalName());
+    MethodSubject y = sub.method("void", "foo", ImmutableList.of());
+    assertThat(y, isPresent());
+    assertThat(y, not(isRenamed()));
+    assertEquals("foo", y.getFinalName());
+  }
+
+  //  class A { // : X
+  //    A() {
+  //      x();
+  //      y();
+  //    }
+  //
+  //    private void x() { // : y
+  //      System.out.println("A#x");
+  //    }
+  //
+  //    public void y() { // : x
+  //      System.out.println("A#y");
+  //    }
+  //  }
+  //
+  //  class B extends A { // : Y
+  //  }
+  //
+  //  class Main {
+  //    public static void main(String[] args) {
+  //      new B().x(); // IllegalAccessError
+  //    }
+  //  }
+  @Test
+  public void test_swapping() throws Exception {
+    String main = "Main";
+    AndroidApp input = buildAndroidApp(
+        ADump.dump(), BDump.dump(), MainDump.dump());
+
+    Path mapPath = temp.newFile("test-mapping.txt").toPath();
+    List<String> pgMap = ImmutableList.of(
+        "A -> X:",
+        "  void x() -> y",
+        "  void y() -> x",
+        "B -> Y:"
+        // Intentionally missing mappings for non-overridden members
+    );
+    FileUtils.writeTextFile(mapPath, pgMap);
+
+    R8Command.Builder builder = ToolHelper.prepareR8CommandBuilder(input, emptyConsumer(backend));
+    builder
+        .addProguardConfiguration(
+            ImmutableList.of(
+                keepMainProguardConfiguration(main),
+                // Do not turn on -allowaccessmodification
+                "-applymapping " + mapPath,
+                "-dontobfuscate"), // to use the renamed names in test-mapping.txt
+            Origin.unknown())
+        .addLibraryFiles(runtimeJar(backend));
+    AndroidApp processedApp =
+        ToolHelper.runR8(
+            builder.build(),
+            options -> {
+              options.enableInlining = false;
+              options.enableVerticalClassMerging = false;
+            });
+
+    List<byte[]> classBytes = ImmutableList.of(ADump.dump(), BDump.dump(), MainDump.dump());
+    ProcessResult outputBefore = runOnJavaRaw(main, classBytes, ImmutableList.of());
+    assertNotEquals(0, outputBefore.exitCode);
+    assertThat(outputBefore.stderr, containsString("IllegalAccessError"));
+    assertThat(outputBefore.stderr, containsString("A.x()"));
+    ProcessResult outputAfter = runOnVMRaw(processedApp, main, backend);
+    assertNotEquals(0, outputAfter.exitCode);
+    assertThat(outputAfter.stderr, containsString("IllegalAccessError"));
+    assertThat(outputAfter.stderr, containsString("X.y()"));
+
+    CodeInspector codeInspector = new CodeInspector(processedApp, mapPath);
+    ClassSubject base = codeInspector.clazz("A");
+    assertThat(base, isPresent());
+    assertThat(base, isRenamed());
+    assertEquals("X", base.getFinalName());
+    MethodSubject x = base.method("void", "x", ImmutableList.of());
+    assertThat(x, isPresent());
+    assertThat(x, isRenamed());
+    assertEquals("y", x.getFinalName());
+
+    ClassSubject sub = codeInspector.clazz("B");
+    assertThat(sub, isPresent());
+    assertThat(sub, isRenamed());
+    assertEquals("Y", sub.getFinalName());
+    MethodSubject subX = sub.method("void", "x", ImmutableList.of());
+    assertThat(subX, not(isPresent()));
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/naming/applymapping/MemberResolutionTest.java b/src/test/java/com/android/tools/r8/naming/applymapping/MemberResolutionTest.java
new file mode 100644
index 0000000..61e51be
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/naming/applymapping/MemberResolutionTest.java
@@ -0,0 +1,155 @@
+// 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.naming.applymapping;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isRenamed;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThat;
+
+import com.android.tools.r8.R8Command;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.origin.Origin;
+import com.android.tools.r8.utils.AndroidApp;
+import com.android.tools.r8.utils.FileUtils;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.FieldSubject;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import com.google.common.collect.ImmutableList;
+import java.nio.file.Path;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+// AbstractChecker -> X:
+abstract class AbstractChecker {
+  // String tag -> p
+  private String tag = "PrivateInitialTag_AbstractChecker";
+
+  // check() -> x
+  private void check() {
+    System.out.println("AbstractChecker#check:" + tag);
+  }
+
+  // foo() -> a
+  protected void foo() {
+    check();
+  }
+}
+
+// ConcreteChecker -> Y:
+class ConcreteChecker extends AbstractChecker {
+  // This should not be conflict with AbstractChecker#tag due to the access control.
+  // String tag -> q
+  private String tag = "PrivateInitialTag_ConcreteChecker";
+
+  ConcreteChecker(String tag){
+    this.tag = tag;
+  }
+
+  // This should not be conflict with AbstractChecker#check due to the access control.
+  // check() -> y
+  private void check() {
+    System.out.println("ConcreteChecker#check:" + tag);
+  }
+
+  // foo() -> a
+  @Override
+  protected void foo() {
+    super.foo();
+    check();
+  }
+}
+
+class MemberResolutionTestMain {
+  public static void main(String[] args) {
+    ConcreteChecker c = new ConcreteChecker("NewTag");
+    c.foo();
+  }
+}
+
+@RunWith(Parameterized.class)
+public class MemberResolutionTest extends TestBase {
+  private final static List<Class> CLASSES = ImmutableList.of(
+      AbstractChecker.class, ConcreteChecker.class, MemberResolutionTestMain.class);
+
+  private Backend backend;
+
+  @Parameterized.Parameters(name = "Backend: {0}")
+  public static Collection<Backend> data() {
+    return Arrays.asList(Backend.values());
+  }
+
+  public MemberResolutionTest(Backend backend) {
+    this.backend = backend;
+  }
+
+  @Test
+  public void testPrivateMethodsWithSameName() throws Exception {
+    String pkg = this.getClass().getPackage().getName();
+    Path mapPath = temp.newFile("test-mapping.txt").toPath();
+    List<String> pgMap = ImmutableList.of(
+        pkg + ".AbstractChecker -> " + pkg + ".X:",
+        "  java.lang.String tag -> p",
+        "  void check() -> x",
+        "  void foo() -> a",
+        pkg + ".ConcreteChecker -> " + pkg + ".Y:",
+        "  java.lang.String tag -> q",
+        "  void check() -> y",
+        "  void foo() -> a"
+    );
+    FileUtils.writeTextFile(mapPath, pgMap);
+
+    AndroidApp app = readClasses(CLASSES);
+    R8Command.Builder builder = ToolHelper.prepareR8CommandBuilder(app, emptyConsumer(backend));
+    builder
+        .addProguardConfiguration(
+            ImmutableList.of(
+                keepMainProguardConfiguration(MemberResolutionTestMain.class),
+                // Do not turn on -allowaccessmodification
+                "-applymapping " + mapPath,
+                "-dontobfuscate"), // to use the renamed names in test-mapping.txt
+            Origin.unknown())
+        .addLibraryFiles(runtimeJar(backend));
+    AndroidApp processedApp =
+        ToolHelper.runR8(
+            builder.build(),
+            options -> {
+              options.enableInlining = false;
+              options.enableVerticalClassMerging = false;
+            });
+
+    String outputBefore = runOnJava(MemberResolutionTestMain.class);
+    String outputAfter = runOnVM(processedApp, MemberResolutionTestMain.class, backend);
+    assertEquals(outputBefore, outputAfter);
+
+    CodeInspector codeInspector = new CodeInspector(processedApp, mapPath);
+    ClassSubject base = codeInspector.clazz(AbstractChecker.class);
+    assertThat(base, isPresent());
+    FieldSubject p = base.field("java.lang.String", "tag");
+    assertThat(p, isPresent());
+    assertThat(p, isRenamed());
+    assertEquals("p", p.getFinalName());
+    MethodSubject x = base.method("void", "check", ImmutableList.of());
+    assertThat(x, isPresent());
+    assertThat(x, isRenamed());
+    assertEquals("x", x.getFinalName());
+
+    ClassSubject sub = codeInspector.clazz(ConcreteChecker.class);
+    assertThat(sub, isPresent());
+    FieldSubject q = sub.field("java.lang.String", "tag");
+    assertThat(q, isPresent());
+    assertThat(q, isRenamed());
+    assertEquals("q", q.getFinalName());
+    MethodSubject y = sub.method("void", "check", ImmutableList.of());
+    assertThat(y, isPresent());
+    assertThat(y, isRenamed());
+    assertEquals("y", y.getFinalName());
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/naming/applymapping/NoMappingDump.java b/src/test/java/com/android/tools/r8/naming/applymapping/NoMappingDump.java
new file mode 100644
index 0000000..ae46c2a
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/naming/applymapping/NoMappingDump.java
@@ -0,0 +1,197 @@
+// 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.naming.applymapping;
+
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.Label;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+// Generated by running tools/asmifier.py on the following code snippet:
+//
+//  class HasMapping {
+//    HasMapping() {
+//      foo();
+//    }
+//
+//    void foo() {
+//      System.out.println("HasMapping#foo");
+//    }
+//  }
+class HasMappingDump implements Opcodes {
+
+  public static byte[] dump () throws Exception {
+
+    ClassWriter classWriter = new ClassWriter(0);
+    MethodVisitor methodVisitor;
+
+    classWriter.visit(V1_8, ACC_SUPER, "HasMapping", null, "java/lang/Object", null);
+
+    classWriter.visitSource("HasMapping.java", null);
+
+    {
+      methodVisitor = classWriter.visitMethod(0, "<init>", "()V", null, null);
+      methodVisitor.visitCode();
+      Label label0 = new Label();
+      methodVisitor.visitLabel(label0);
+      methodVisitor.visitLineNumber(2, label0);
+      methodVisitor.visitVarInsn(ALOAD, 0);
+      methodVisitor.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
+      Label label1 = new Label();
+      methodVisitor.visitLabel(label1);
+      methodVisitor.visitLineNumber(3, label1);
+      methodVisitor.visitVarInsn(ALOAD, 0);
+      methodVisitor.visitMethodInsn(INVOKEVIRTUAL, "HasMapping", "foo", "()V", false);
+      Label label2 = new Label();
+      methodVisitor.visitLabel(label2);
+      methodVisitor.visitLineNumber(4, label2);
+      methodVisitor.visitInsn(RETURN);
+      methodVisitor.visitMaxs(1, 1);
+      methodVisitor.visitEnd();
+    }
+    {
+      methodVisitor = classWriter.visitMethod(0, "foo", "()V", null, null);
+      methodVisitor.visitCode();
+      Label label0 = new Label();
+      methodVisitor.visitLabel(label0);
+      methodVisitor.visitLineNumber(3, label0);
+      methodVisitor.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
+      methodVisitor.visitLdcInsn("HasMapping#foo");
+      methodVisitor.visitMethodInsn(
+          INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
+      Label label1 = new Label();
+      methodVisitor.visitLabel(label1);
+      methodVisitor.visitLineNumber(4, label1);
+      methodVisitor.visitInsn(RETURN);
+      methodVisitor.visitMaxs(2, 1);
+      methodVisitor.visitEnd();
+    }
+    classWriter.visitEnd();
+
+    return classWriter.toByteArray();
+  }
+}
+
+// Generated by running tools/asmifier.py on the following code snippet:
+//
+//  class NoMapping extends HasMapping {
+//    NoMapping() {
+//      super();
+//      bar();
+//    }
+//
+//    private void bar() {
+//      System.out.println("NoMapping#foo");
+//    }
+//  }
+//
+// then renamed bar() to foo() to introduce name clash.
+class NoMappingDump implements Opcodes {
+
+  public static byte[] dump () throws Exception {
+
+    ClassWriter classWriter = new ClassWriter(0);
+    MethodVisitor methodVisitor;
+
+    classWriter.visit(V1_8, ACC_SUPER, "NoMapping", null, "HasMapping", null);
+
+    classWriter.visitSource("NoMapping.java", null);
+
+    {
+      methodVisitor = classWriter.visitMethod(0, "<init>", "()V", null, null);
+      methodVisitor.visitCode();
+      Label label0 = new Label();
+      methodVisitor.visitLabel(label0);
+      methodVisitor.visitLineNumber(12, label0);
+      methodVisitor.visitVarInsn(ALOAD, 0);
+      methodVisitor.visitMethodInsn(INVOKESPECIAL, "HasMapping", "<init>", "()V", false);
+      Label label1 = new Label();
+      methodVisitor.visitLabel(label1);
+      methodVisitor.visitLineNumber(13, label1);
+      methodVisitor.visitVarInsn(ALOAD, 0);
+      methodVisitor.visitMethodInsn(INVOKESPECIAL, "NoMapping", "foo", "()V", false);
+      Label label2 = new Label();
+      methodVisitor.visitLabel(label2);
+      methodVisitor.visitLineNumber(14, label2);
+      methodVisitor.visitInsn(RETURN);
+      methodVisitor.visitMaxs(1, 1);
+      methodVisitor.visitEnd();
+    }
+    {
+      methodVisitor = classWriter.visitMethod(ACC_PRIVATE, "foo", "()V", null, null);
+      methodVisitor.visitCode();
+      Label label0 = new Label();
+      methodVisitor.visitLabel(label0);
+      methodVisitor.visitLineNumber(9, label0);
+      methodVisitor.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
+      methodVisitor.visitLdcInsn("NoMapping#foo");
+      methodVisitor.visitMethodInsn(
+          INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
+      Label label1 = new Label();
+      methodVisitor.visitLabel(label1);
+      methodVisitor.visitLineNumber(10, label1);
+      methodVisitor.visitInsn(RETURN);
+      methodVisitor.visitMaxs(2, 1);
+      methodVisitor.visitEnd();
+    }
+    classWriter.visitEnd();
+
+    return classWriter.toByteArray();
+  }
+}
+
+// Generated by running tools/asmifier.py on the following code snippet:
+//
+//  public class NoMappingMain {
+//    public static void main(String[] args) {
+//      new NoMapping();
+//    }
+//  }
+class NoMappingMainDump implements Opcodes {
+
+  public static byte[] dump () throws Exception {
+
+    ClassWriter classWriter = new ClassWriter(0);
+    MethodVisitor methodVisitor;
+
+    classWriter.visit(
+        V1_8, ACC_PUBLIC | ACC_SUPER, "NoMappingMain", null, "java/lang/Object", null);
+
+    classWriter.visitSource("NoMappingMain.java", null);
+
+    {
+      methodVisitor = classWriter.visitMethod(0, "<init>", "()V", null, null);
+      methodVisitor.visitCode();
+      Label label0 = new Label();
+      methodVisitor.visitLabel(label0);
+      methodVisitor.visitLineNumber(19, label0);
+      methodVisitor.visitVarInsn(ALOAD, 0);
+      methodVisitor.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
+      methodVisitor.visitInsn(RETURN);
+      methodVisitor.visitMaxs(1, 1);
+      methodVisitor.visitEnd();
+    }
+    {
+      methodVisitor = classWriter.visitMethod(
+          ACC_PUBLIC | ACC_STATIC, "main", "([Ljava/lang/String;)V", null, null);
+      methodVisitor.visitCode();
+      Label label0 = new Label();
+      methodVisitor.visitLabel(label0);
+      methodVisitor.visitLineNumber(22, label0);
+      methodVisitor.visitTypeInsn(NEW, "NoMapping");
+      methodVisitor.visitInsn(DUP);
+      methodVisitor.visitMethodInsn(INVOKESPECIAL, "NoMapping", "<init>", "()V", false);
+      methodVisitor.visitInsn(POP);
+      Label label1 = new Label();
+      methodVisitor.visitLabel(label1);
+      methodVisitor.visitLineNumber(23, label1);
+      methodVisitor.visitInsn(RETURN);
+      methodVisitor.visitMaxs(2, 1);
+      methodVisitor.visitEnd();
+    }
+    classWriter.visitEnd();
+
+    return classWriter.toByteArray();
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/naming/applymapping/SwappingDump.java b/src/test/java/com/android/tools/r8/naming/applymapping/SwappingDump.java
new file mode 100644
index 0000000..0dea699
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/naming/applymapping/SwappingDump.java
@@ -0,0 +1,191 @@
+// 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.naming.applymapping;
+
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.Label;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+// Generated by running tools/asmifier.py on the following code snippet:
+//
+//  class A {
+//    A() {
+//      x();
+//      y();
+//    }
+//
+//    private void x() {
+//      System.out.println("A#x");
+//    }
+//
+//    public void y() {
+//      System.out.println("A#y");
+//    }
+//  }
+class ADump implements Opcodes {
+
+  public static byte[] dump () throws Exception {
+
+    ClassWriter classWriter = new ClassWriter(0);
+    MethodVisitor methodVisitor;
+
+    classWriter.visit(V1_8, ACC_SUPER, "A", null, "java/lang/Object", null);
+
+    classWriter.visitSource("Test.java", null);
+
+    {
+      methodVisitor = classWriter.visitMethod(0, "<init>", "()V", null, null);
+      methodVisitor.visitCode();
+      Label label0 = new Label();
+      methodVisitor.visitLabel(label0);
+      methodVisitor.visitLineNumber(2, label0);
+      methodVisitor.visitVarInsn(ALOAD, 0);
+      methodVisitor.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
+      Label label1 = new Label();
+      methodVisitor.visitLabel(label1);
+      methodVisitor.visitLineNumber(3, label1);
+      methodVisitor.visitVarInsn(ALOAD, 0);
+      methodVisitor.visitMethodInsn(INVOKESPECIAL, "A", "x", "()V", false);
+      Label label2 = new Label();
+      methodVisitor.visitLabel(label2);
+      methodVisitor.visitLineNumber(4, label2);
+      methodVisitor.visitVarInsn(ALOAD, 0);
+      methodVisitor.visitMethodInsn(INVOKEVIRTUAL, "A", "y", "()V", false);
+      Label label3 = new Label();
+      methodVisitor.visitLabel(label3);
+      methodVisitor.visitLineNumber(5, label3);
+      methodVisitor.visitInsn(RETURN);
+      methodVisitor.visitMaxs(1, 1);
+      methodVisitor.visitEnd();
+    }
+    {
+      methodVisitor = classWriter.visitMethod(ACC_PRIVATE, "x", "()V", null, null);
+      methodVisitor.visitCode();
+      Label label0 = new Label();
+      methodVisitor.visitLabel(label0);
+      methodVisitor.visitLineNumber(7, label0);
+      methodVisitor.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
+      methodVisitor.visitLdcInsn("A#x");
+      methodVisitor.visitMethodInsn(
+          INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
+      Label label1 = new Label();
+      methodVisitor.visitLabel(label1);
+      methodVisitor.visitLineNumber(8, label1);
+      methodVisitor.visitInsn(RETURN);
+      methodVisitor.visitMaxs(2, 1);
+      methodVisitor.visitEnd();
+    }
+    {
+      methodVisitor = classWriter.visitMethod(ACC_PUBLIC, "y", "()V", null, null);
+      methodVisitor.visitCode();
+      Label label0 = new Label();
+      methodVisitor.visitLabel(label0);
+      methodVisitor.visitLineNumber(11, label0);
+      methodVisitor.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
+      methodVisitor.visitLdcInsn("A#y");
+      methodVisitor.visitMethodInsn(
+          INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
+      Label label1 = new Label();
+      methodVisitor.visitLabel(label1);
+      methodVisitor.visitLineNumber(12, label1);
+      methodVisitor.visitInsn(RETURN);
+      methodVisitor.visitMaxs(2, 1);
+      methodVisitor.visitEnd();
+    }
+    classWriter.visitEnd();
+
+    return classWriter.toByteArray();
+  }
+}
+
+// Generated by running tools/asmifier.py on the following code snippet:
+//
+//  class B extends A {
+//  }
+class BDump implements Opcodes {
+
+  public static byte[] dump () throws Exception {
+
+    ClassWriter classWriter = new ClassWriter(0);
+    MethodVisitor methodVisitor;
+
+    classWriter.visit(V1_8, ACC_SUPER, "B", null, "A", null);
+
+    classWriter.visitSource("Test.java", null);
+
+    {
+      methodVisitor = classWriter.visitMethod(0, "<init>", "()V", null, null);
+      methodVisitor.visitCode();
+      Label label0 = new Label();
+      methodVisitor.visitLabel(label0);
+      methodVisitor.visitLineNumber(15, label0);
+      methodVisitor.visitVarInsn(ALOAD, 0);
+      methodVisitor.visitMethodInsn(INVOKESPECIAL, "A", "<init>", "()V", false);
+      methodVisitor.visitInsn(RETURN);
+      methodVisitor.visitMaxs(1, 1);
+      methodVisitor.visitEnd();
+    }
+    classWriter.visitEnd();
+
+    return classWriter.toByteArray();
+  }
+}
+
+// Generated by running tools/asmifier.py on the following code snippet:
+//
+//  public class Main {
+//    public static void main(String[] args) {
+//      new B().y();
+//    }
+//  }
+//
+// then replaced use of y() with x() to introduce IllegalAccessError.
+class MainDump implements Opcodes {
+
+  public static byte[] dump () throws Exception {
+
+    ClassWriter classWriter = new ClassWriter(0);
+    MethodVisitor methodVisitor;
+
+    classWriter.visit(V1_8, ACC_PUBLIC | ACC_SUPER, "Main", null, "java/lang/Object", null);
+
+    classWriter.visitSource("Test.java", null);
+
+    {
+      methodVisitor = classWriter.visitMethod(0, "<init>", "()V", null, null);
+      methodVisitor.visitCode();
+      Label label0 = new Label();
+      methodVisitor.visitLabel(label0);
+      methodVisitor.visitLineNumber(18, label0);
+      methodVisitor.visitVarInsn(ALOAD, 0);
+      methodVisitor.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
+      methodVisitor.visitInsn(RETURN);
+      methodVisitor.visitMaxs(1, 1);
+      methodVisitor.visitEnd();
+    }
+    {
+      methodVisitor = classWriter.visitMethod(
+          ACC_PUBLIC | ACC_STATIC, "main", "([Ljava/lang/String;)V", null, null);
+      methodVisitor.visitCode();
+      Label label0 = new Label();
+      methodVisitor.visitLabel(label0);
+      methodVisitor.visitLineNumber(20, label0);
+      methodVisitor.visitTypeInsn(NEW, "B");
+      methodVisitor.visitInsn(DUP);
+      methodVisitor.visitMethodInsn(INVOKESPECIAL, "B", "<init>", "()V", false);
+      methodVisitor.visitMethodInsn(INVOKEVIRTUAL, "B", "x", "()V", false);
+      Label label1 = new Label();
+      methodVisitor.visitLabel(label1);
+      methodVisitor.visitLineNumber(21, label1);
+      methodVisitor.visitInsn(RETURN);
+      methodVisitor.visitMaxs(2, 1);
+      methodVisitor.visitEnd();
+    }
+    classWriter.visitEnd();
+
+    return classWriter.toByteArray();
+  }
+}
+