diff --git a/src/main/java/com/android/tools/r8/Version.java b/src/main/java/com/android/tools/r8/Version.java
index 2c3a634..944cc82 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 = "2.1.67";
+  public static final String LABEL = "2.1.68";
 
   private Version() {
   }
diff --git a/src/main/java/com/android/tools/r8/naming/ClassNameMapper.java b/src/main/java/com/android/tools/r8/naming/ClassNameMapper.java
index e98d9b9..43a0511 100644
--- a/src/main/java/com/android/tools/r8/naming/ClassNameMapper.java
+++ b/src/main/java/com/android/tools/r8/naming/ClassNameMapper.java
@@ -6,6 +6,7 @@
 import static com.android.tools.r8.naming.ClassNameMapper.MissingFileAction.MISSING_FILE_IS_ERROR;
 import static com.android.tools.r8.utils.DescriptorUtils.descriptorToJavaType;
 
+import com.android.tools.r8.DiagnosticsHandler;
 import com.android.tools.r8.graph.DexField;
 import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.DexType;
@@ -16,6 +17,7 @@
 import com.android.tools.r8.position.Position;
 import com.android.tools.r8.utils.BiMapContainer;
 import com.android.tools.r8.utils.ChainableStringConsumer;
+import com.android.tools.r8.utils.Reporter;
 import com.google.common.collect.BiMap;
 import com.google.common.collect.ImmutableBiMap;
 import com.google.common.collect.ImmutableMap;
@@ -68,7 +70,7 @@
 
   public static ClassNameMapper mapperFromInputStream(InputStream in) throws IOException {
     return mapperFromBufferedReader(
-        new BufferedReader(new InputStreamReader(in, StandardCharsets.UTF_8)));
+        new BufferedReader(new InputStreamReader(in, StandardCharsets.UTF_8)), null);
   }
 
   public static ClassNameMapper mapperFromFile(Path path) throws IOException {
@@ -87,12 +89,20 @@
   }
 
   public static ClassNameMapper mapperFromString(String contents) throws IOException {
-    return mapperFromBufferedReader(CharSource.wrap(contents).openBufferedStream());
+    return mapperFromBufferedReader(CharSource.wrap(contents).openBufferedStream(), null);
   }
 
-  private static ClassNameMapper mapperFromBufferedReader(BufferedReader reader)
-      throws IOException {
-    try (ProguardMapReader proguardReader = new ProguardMapReader(reader)) {
+  public static ClassNameMapper mapperFromString(
+      String contents, DiagnosticsHandler diagnosticsHandler) throws IOException {
+    return mapperFromBufferedReader(
+        CharSource.wrap(contents).openBufferedStream(), diagnosticsHandler);
+  }
+
+  private static ClassNameMapper mapperFromBufferedReader(
+      BufferedReader reader, DiagnosticsHandler diagnosticsHandler) throws IOException {
+    try (ProguardMapReader proguardReader =
+        new ProguardMapReader(
+            reader, diagnosticsHandler != null ? diagnosticsHandler : new Reporter())) {
       ClassNameMapper.Builder builder = ClassNameMapper.builder();
       proguardReader.parse(builder);
       return builder.build();
diff --git a/src/main/java/com/android/tools/r8/naming/ClassNaming.java b/src/main/java/com/android/tools/r8/naming/ClassNaming.java
index 1404387..5a282d0 100644
--- a/src/main/java/com/android/tools/r8/naming/ClassNaming.java
+++ b/src/main/java/com/android/tools/r8/naming/ClassNaming.java
@@ -3,7 +3,9 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.naming;
 
+import com.android.tools.r8.DiagnosticsHandler;
 import com.android.tools.r8.naming.MemberNaming.Signature;
+import com.android.tools.r8.naming.mappinginformation.MappingInformation;
 import com.android.tools.r8.utils.ThrowingConsumer;
 
 /**
@@ -14,8 +16,16 @@
 public interface ClassNaming {
 
   abstract class Builder {
+
     public abstract Builder addMemberEntry(MemberNaming entry);
 
+    public abstract Builder addMappingInformation(MappingInformation mappingInformation);
+
+    public abstract Builder addMappingInformation(
+        MappingInformation mappingInformation,
+        DiagnosticsHandler diagnosticsHandler,
+        int lineNumber);
+
     public abstract ClassNaming build();
 
     /** This is an optional method, may be implemented as no-op */
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 65bc602..acbb577 100644
--- a/src/main/java/com/android/tools/r8/naming/ClassNamingForMapApplier.java
+++ b/src/main/java/com/android/tools/r8/naming/ClassNamingForMapApplier.java
@@ -3,6 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.naming;
 
+import com.android.tools.r8.DiagnosticsHandler;
 import com.android.tools.r8.graph.DexField;
 import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.DexType;
@@ -10,6 +11,7 @@
 import com.android.tools.r8.naming.MemberNaming.MethodSignature;
 import com.android.tools.r8.naming.MemberNaming.Signature;
 import com.android.tools.r8.naming.MemberNaming.Signature.SignatureKind;
+import com.android.tools.r8.naming.mappinginformation.MappingInformation;
 import com.android.tools.r8.position.Position;
 import com.android.tools.r8.utils.Reporter;
 import com.android.tools.r8.utils.ThrowingConsumer;
@@ -35,6 +37,7 @@
 public class ClassNamingForMapApplier implements ClassNaming {
 
   public static class Builder extends ClassNaming.Builder {
+
     private final String originalName;
     private final String renamedName;
     private final Position position;
@@ -75,6 +78,21 @@
     }
 
     @Override
+    public ClassNaming.Builder addMappingInformation(MappingInformation mappingInformation) {
+      // Intentionally kept empty until we support additional information with -applymapping.
+      return this;
+    }
+
+    @Override
+    public ClassNaming.Builder addMappingInformation(
+        MappingInformation mappingInformation,
+        DiagnosticsHandler diagnosticsHandler,
+        int lineNumber) {
+      // Intentionally kept empty until we support additional information with -applymapping.
+      return this;
+    }
+
+    @Override
     public ClassNamingForMapApplier build() {
       return new ClassNamingForMapApplier(
           renamedName, originalName, position, qualifiedMethodMembers, methodMembers, fieldMembers);
diff --git a/src/main/java/com/android/tools/r8/naming/ClassNamingForNameMapper.java b/src/main/java/com/android/tools/r8/naming/ClassNamingForNameMapper.java
index 5a00fcb..98293ab 100644
--- a/src/main/java/com/android/tools/r8/naming/ClassNamingForNameMapper.java
+++ b/src/main/java/com/android/tools/r8/naming/ClassNamingForNameMapper.java
@@ -3,10 +3,15 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.naming;
 
+import static com.android.tools.r8.naming.MemberNaming.NoSignature.NO_SIGNATURE;
+
+import com.android.tools.r8.DiagnosticsHandler;
 import com.android.tools.r8.naming.MemberNaming.FieldSignature;
 import com.android.tools.r8.naming.MemberNaming.MethodSignature;
 import com.android.tools.r8.naming.MemberNaming.Signature;
 import com.android.tools.r8.naming.MemberNaming.Signature.SignatureKind;
+import com.android.tools.r8.naming.mappinginformation.MappingInformation;
+import com.android.tools.r8.naming.mappinginformation.MappingInformationDiagnostics;
 import com.android.tools.r8.utils.ChainableStringConsumer;
 import com.android.tools.r8.utils.ThrowingConsumer;
 import com.google.common.collect.ImmutableMap;
@@ -19,6 +24,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
+import java.util.function.Consumer;
 
 /**
  * Stores name information for a class.
@@ -28,12 +34,14 @@
 public class ClassNamingForNameMapper implements ClassNaming {
 
   public static class Builder extends ClassNaming.Builder {
+
     private final String originalName;
     private final String renamedName;
     private final Map<MethodSignature, MemberNaming> methodMembers = Maps.newHashMap();
     private final Map<FieldSignature, MemberNaming> fieldMembers = Maps.newHashMap();
     private final Map<String, List<MappedRange>> mappedRangesByName = Maps.newHashMap();
     private final Map<String, List<MemberNaming>> mappedNamingsByName = Maps.newHashMap();
+    private final Map<Signature, List<MappingInformation>> additionalMappings = Maps.newHashMap();
 
     private Builder(String renamedName, String originalName) {
       this.originalName = originalName;
@@ -43,9 +51,9 @@
     @Override
     public ClassNaming.Builder addMemberEntry(MemberNaming entry) {
       if (entry.isMethodNaming()) {
-        methodMembers.put((MethodSignature) entry.getRenamedSignature(), entry);
+        methodMembers.put(entry.getRenamedSignature().asMethodSignature(), entry);
       } else {
-        fieldMembers.put((FieldSignature) entry.getRenamedSignature(), entry);
+        fieldMembers.put(entry.getRenamedSignature().asFieldSignature(), entry);
       }
       mappedNamingsByName
           .computeIfAbsent(entry.getRenamedName(), m -> new ArrayList<>())
@@ -54,6 +62,45 @@
     }
 
     @Override
+    public ClassNaming.Builder addMappingInformation(MappingInformation mappingInformation) {
+      return addMappingInformation(
+          mappingInformation,
+          other -> {
+            assert false;
+          });
+    }
+
+    @Override
+    public ClassNaming.Builder addMappingInformation(
+        MappingInformation mappingInformation,
+        DiagnosticsHandler diagnosticsHandler,
+        int lineNumber) {
+      return addMappingInformation(
+          mappingInformation,
+          other ->
+              diagnosticsHandler.warning(
+                  MappingInformationDiagnostics.notAllowedCombination(
+                      originalName, renamedName, mappingInformation, other, lineNumber)));
+    }
+
+    private ClassNaming.Builder addMappingInformation(
+        MappingInformation mappingInformation, Consumer<MappingInformation> notAllowedCombination) {
+      Signature signature =
+          mappingInformation.isSignatureMappingInformation()
+              ? mappingInformation.asSignatureMappingInformation().getSignature()
+              : NO_SIGNATURE;
+      List<MappingInformation> additionalMappingForSignature =
+          additionalMappings.computeIfAbsent(signature, ignored -> new ArrayList<>());
+      for (MappingInformation information : additionalMappingForSignature) {
+        if (!information.allowOther(mappingInformation)) {
+          notAllowedCombination.accept(information);
+        }
+      }
+      additionalMappingForSignature.add(mappingInformation);
+      return this;
+    }
+
+    @Override
     public ClassNamingForNameMapper build() {
       Map<String, MappedRangesOfName> map;
 
@@ -67,7 +114,13 @@
       }
 
       return new ClassNamingForNameMapper(
-          renamedName, originalName, methodMembers, fieldMembers, map, mappedNamingsByName);
+          renamedName,
+          originalName,
+          methodMembers,
+          fieldMembers,
+          map,
+          mappedNamingsByName,
+          additionalMappings);
     }
 
     /** The parameters are forwarded to MappedRange constructor, see explanation there. */
@@ -198,19 +251,23 @@
 
   public final Map<String, List<MemberNaming>> mappedNamingsByName;
 
+  private final Map<Signature, List<MappingInformation>> additionalMappings;
+
   private ClassNamingForNameMapper(
       String renamedName,
       String originalName,
       Map<MethodSignature, MemberNaming> methodMembers,
       Map<FieldSignature, MemberNaming> fieldMembers,
       Map<String, MappedRangesOfName> mappedRangesByRenamedName,
-      Map<String, List<MemberNaming>> mappedNamingsByName) {
+      Map<String, List<MemberNaming>> mappedNamingsByName,
+      Map<Signature, List<MappingInformation>> additionalMappings) {
     this.renamedName = renamedName;
     this.originalName = originalName;
     this.methodMembers = ImmutableMap.copyOf(methodMembers);
     this.fieldMembers = ImmutableMap.copyOf(fieldMembers);
     this.mappedRangesByRenamedName = mappedRangesByRenamedName;
     this.mappedNamingsByName = mappedNamingsByName;
+    this.additionalMappings = additionalMappings;
   }
 
   public MappedRangesOfName getMappedRangesForRenamedName(String renamedName) {
@@ -298,7 +355,16 @@
   void write(ChainableStringConsumer consumer) {
     consumer.accept(originalName).accept(" -> ").accept(renamedName).accept(":\n");
 
-    // First print field member namings.
+    // Print all additional mapping information.
+    additionalMappings.forEach(
+        (signature, mappingInformations) -> {
+          assert !mappingInformations.isEmpty();
+          for (MappingInformation mappingInformation : mappingInformations) {
+            consumer.accept("# " + mappingInformation.serialize()).accept("\n");
+          }
+        });
+
+    // Print field member namings.
     forAllFieldNaming(m -> consumer.accept("    ").accept(m.toString()).accept("\n"));
 
     // Sort MappedRanges by sequence number to restore construction order (original Proguard-map
@@ -313,6 +379,10 @@
     }
   }
 
+  public Map<Signature, List<MappingInformation>> getAdditionalMappings() {
+    return additionalMappings;
+  }
+
   @Override
   public String toString() {
     StringBuilder builder = new StringBuilder();
diff --git a/src/main/java/com/android/tools/r8/naming/MemberNaming.java b/src/main/java/com/android/tools/r8/naming/MemberNaming.java
index 84f726d..51c3272 100644
--- a/src/main/java/com/android/tools/r8/naming/MemberNaming.java
+++ b/src/main/java/com/android/tools/r8/naming/MemberNaming.java
@@ -58,12 +58,12 @@
   final Position position;
 
   public MemberNaming(Signature signature, String renamedName) {
-    this(signature, renamedName, Position.UNKNOWN);
+    this(signature, signature.asRenamed(renamedName), Position.UNKNOWN);
   }
 
-  public MemberNaming(Signature signature, String renamedName, Position position) {
+  public MemberNaming(Signature signature, Signature renamedSignature, Position position) {
     this.signature = signature;
-    this.renamedSignature = signature.asRenamed(renamedName);
+    this.renamedSignature = renamedSignature;
     this.position = position;
   }
 
@@ -168,6 +168,40 @@
     }
   }
 
+  public static class NoSignature extends Signature {
+
+    public static final NoSignature NO_SIGNATURE = new NoSignature();
+
+    public NoSignature() {
+      super("NO SIGNATURE");
+    }
+
+    @Override
+    Signature asRenamed(String renamedName) {
+      throw new Unreachable("Should not be called on NoSignature");
+    }
+
+    @Override
+    public SignatureKind kind() {
+      throw new Unreachable("Should not be called on NoSignature");
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      return o == this;
+    }
+
+    @Override
+    public int hashCode() {
+      return 7;
+    }
+
+    @Override
+    void write(Writer builder) throws IOException {
+      throw new Unreachable("Should not be called on NoSignature");
+    }
+  }
+
   public static class FieldSignature extends Signature {
 
     public final String type;
diff --git a/src/main/java/com/android/tools/r8/naming/ProguardMapReader.java b/src/main/java/com/android/tools/r8/naming/ProguardMapReader.java
index 747423f..23a9a06 100644
--- a/src/main/java/com/android/tools/r8/naming/ProguardMapReader.java
+++ b/src/main/java/com/android/tools/r8/naming/ProguardMapReader.java
@@ -3,17 +3,24 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.naming;
 
+import com.android.tools.r8.DiagnosticsHandler;
 import com.android.tools.r8.naming.MemberNaming.FieldSignature;
 import com.android.tools.r8.naming.MemberNaming.MethodSignature;
 import com.android.tools.r8.naming.MemberNaming.Signature;
+import com.android.tools.r8.naming.mappinginformation.MappingInformation;
+import com.android.tools.r8.naming.mappinginformation.SignatureMappingInformation;
 import com.android.tools.r8.position.TextPosition;
 import com.android.tools.r8.utils.IdentifierUtils;
 import com.android.tools.r8.utils.StringUtils;
+import com.google.common.collect.Maps;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
 import java.io.BufferedReader;
 import java.io.IOException;
 import java.util.HashMap;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Map;
 import java.util.Objects;
 
 /**
@@ -54,16 +61,19 @@
 public class ProguardMapReader implements AutoCloseable {
 
   private final BufferedReader reader;
+  private final JsonParser jsonParser = new JsonParser();
+  private final DiagnosticsHandler diagnosticsHandler;
 
   @Override
   public void close() throws IOException {
-    if (reader != null) {
-      reader.close();
-    }
+    reader.close();
   }
 
-  ProguardMapReader(BufferedReader reader) {
+  ProguardMapReader(BufferedReader reader, DiagnosticsHandler diagnosticsHandler) {
     this.reader = reader;
+    this.diagnosticsHandler = diagnosticsHandler;
+    assert reader != null;
+    assert diagnosticsHandler != null;
   }
 
   // Internal parser state
@@ -118,7 +128,7 @@
     for (int i = 0; i < line.length(); ++i) {
       char c = line.charAt(i);
       if (c == '#') {
-        return true;
+        return !hasFirstCharJsonBrace(line, i);
       } else if (!StringUtils.isWhitespace(c)) {
         return false;
       }
@@ -126,6 +136,33 @@
     return true;
   }
 
+  private boolean isCommentLineWithJsonBrace() {
+    if (line == null) {
+      return false;
+    }
+    for (int i = 0; i < line.length(); ++i) {
+      char c = line.charAt(i);
+      if (c == '#') {
+        return hasFirstCharJsonBrace(line, i);
+      } else if (!Character.isWhitespace(c)) {
+        return false;
+      }
+    }
+    return false;
+  }
+
+  private static boolean hasFirstCharJsonBrace(String line, int commentCharIndex) {
+    for (int i = commentCharIndex + 1; i < line.length(); i++) {
+      char c = line.charAt(i);
+      if (c == '{') {
+        return true;
+      } else if (!Character.isWhitespace(c)) {
+        return false;
+      }
+    }
+    return false;
+  }
+
   private boolean skipLine() throws IOException {
     lineOffset = 0;
     do {
@@ -213,10 +250,26 @@
     MemberNaming lastAddedNaming = null;
     MemberNaming activeMemberNaming = null;
     Range previousMappedRange = null;
+    Map<Signature, SignatureMappingInformation> mappingInformation = Maps.newHashMap();
     do {
       Object originalRange = null;
       Range mappedRange = null;
-
+      // Try to parse any information added in comments above member namings
+      if (isCommentLineWithJsonBrace()) {
+        MappingInformation mappingInfo =
+            MappingInformation.fromJsonObject(parseJsonInComment(), diagnosticsHandler, lineNo);
+        if (mappingInfo != null) {
+          if (mappingInfo.isSignatureMappingInformation()) {
+            SignatureMappingInformation sigMapInfo = mappingInfo.asSignatureMappingInformation();
+            mappingInformation.put(sigMapInfo.getSignature(), sigMapInfo);
+          } else {
+            classNamingBuilder.addMappingInformation(mappingInfo, diagnosticsHandler, lineNo);
+          }
+        }
+        // Skip reading the rest of the line.
+        lineOffset = line.length();
+        continue;
+      }
       // Parse the member line '  x:y:name:z:q -> renamedName'.
       if (!StringUtils.isWhitespace(peekCodePoint())) {
         break;
@@ -274,7 +327,16 @@
           }
         }
       }
-      activeMemberNaming = new MemberNaming(signature, renamedName, getPosition());
+      if (mappingInformation.containsKey(signature)) {
+        activeMemberNaming =
+            new MemberNaming(
+                signature,
+                mappingInformation.get(signature).apply(signature, renamedName, diagnosticsHandler),
+                getPosition());
+      } else {
+        activeMemberNaming =
+            new MemberNaming(signature, signature.asRenamed(renamedName), getPosition());
+      }
       previousMappedRange = mappedRange;
     } while (nextLine());
 
@@ -451,6 +513,20 @@
     return result;
   }
 
+  private JsonObject parseJsonInComment() {
+    assert isCommentLineWithJsonBrace();
+    try {
+      int firstIndex = 0;
+      while (line.charAt(firstIndex) != '{') {
+        firstIndex++;
+      }
+      return jsonParser.parse(line.substring(firstIndex)).getAsJsonObject();
+    } catch (com.google.gson.JsonSyntaxException ex) {
+      // An info message is reported in MappingInformation.
+      return null;
+    }
+  }
+
   private class ParseException extends RuntimeException {
 
     private final int lineNo;
diff --git a/src/main/java/com/android/tools/r8/naming/SeedMapper.java b/src/main/java/com/android/tools/r8/naming/SeedMapper.java
index be69416..5c50c06 100644
--- a/src/main/java/com/android/tools/r8/naming/SeedMapper.java
+++ b/src/main/java/com/android/tools/r8/naming/SeedMapper.java
@@ -74,7 +74,7 @@
   private static SeedMapper seedMapperFromInputStream(Reporter reporter, InputStream in)
       throws IOException {
     BufferedReader reader = new BufferedReader(new InputStreamReader(in, StandardCharsets.UTF_8));
-    try (ProguardMapReader proguardReader = new ProguardMapReader(reader)) {
+    try (ProguardMapReader proguardReader = new ProguardMapReader(reader, reporter)) {
       SeedMapper.Builder builder = SeedMapper.builder(reporter);
       proguardReader.parse(builder);
       return builder.build();
diff --git a/src/main/java/com/android/tools/r8/naming/mappinginformation/FileNameInformation.java b/src/main/java/com/android/tools/r8/naming/mappinginformation/FileNameInformation.java
new file mode 100644
index 0000000..87b3e7b
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/naming/mappinginformation/FileNameInformation.java
@@ -0,0 +1,70 @@
+// Copyright (c) 2020, 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.mappinginformation;
+
+import com.android.tools.r8.DiagnosticsHandler;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonPrimitive;
+
+public class FileNameInformation extends MappingInformation {
+
+  private final String fileName;
+
+  public static final String ID = "sourceFile";
+  static final String FILE_NAME_KEY = "fileName";
+
+  private FileNameInformation(String fileName) {
+    super(NO_LINE_NUMBER);
+    this.fileName = fileName;
+  }
+
+  public String getFileName() {
+    return fileName;
+  }
+
+  @Override
+  public String serialize() {
+    JsonObject result = new JsonObject();
+    result.add(MAPPING_ID_KEY, new JsonPrimitive(ID));
+    result.add(FILE_NAME_KEY, new JsonPrimitive(fileName));
+    return result.toString();
+  }
+
+  @Override
+  public boolean isFileNameInformation() {
+    return true;
+  }
+
+  @Override
+  public FileNameInformation asFileNameInformation() {
+    return this;
+  }
+
+  @Override
+  public boolean allowOther(MappingInformation information) {
+    return !information.isFileNameInformation();
+  }
+
+  public static FileNameInformation build(String fileName) {
+    return new FileNameInformation(fileName);
+  }
+
+  public static FileNameInformation build(
+      JsonObject object, DiagnosticsHandler diagnosticsHandler, int lineNumber) {
+    try {
+      JsonElement fileName =
+          getJsonElementFromObject(object, diagnosticsHandler, lineNumber, FILE_NAME_KEY, ID);
+      if (fileName == null) {
+        return null;
+      }
+      return new FileNameInformation(fileName.getAsString());
+    } catch (UnsupportedOperationException | IllegalStateException ignored) {
+      diagnosticsHandler.info(
+          MappingInformationDiagnostics.invalidValueForObjectWithId(lineNumber, FILE_NAME_KEY, ID));
+      return null;
+    }
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/naming/mappinginformation/MappingInformation.java b/src/main/java/com/android/tools/r8/naming/mappinginformation/MappingInformation.java
new file mode 100644
index 0000000..c1c5105
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/naming/mappinginformation/MappingInformation.java
@@ -0,0 +1,97 @@
+// 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.mappinginformation;
+
+import com.android.tools.r8.DiagnosticsHandler;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+
+public abstract class MappingInformation {
+
+  static final int NO_LINE_NUMBER = -1;
+
+  public static final String MAPPING_ID_KEY = "id";
+
+  private final int lineNumber;
+
+  MappingInformation(int lineNumber) {
+    this.lineNumber = lineNumber;
+  }
+
+  public int getLineNumber() {
+    return lineNumber;
+  }
+
+  public abstract String serialize();
+
+  public boolean isSignatureMappingInformation() {
+    return false;
+  }
+
+  public SignatureMappingInformation asSignatureMappingInformation() {
+    return null;
+  }
+
+  public boolean isFileNameInformation() {
+    return false;
+  }
+
+  public FileNameInformation asFileNameInformation() {
+    return null;
+  }
+
+  public boolean isMethodSignatureChangedInformation() {
+    return false;
+  }
+
+  public MethodSignatureChangedInformation asMethodSignatureChangedInformation() {
+    return null;
+  }
+
+  public abstract boolean allowOther(MappingInformation information);
+
+  public static MappingInformation fromJsonObject(
+      JsonObject object, DiagnosticsHandler diagnosticsHandler, int lineNumber) {
+    if (object == null) {
+      diagnosticsHandler.info(MappingInformationDiagnostics.notValidJson(lineNumber));
+      return null;
+    }
+    JsonElement id = object.get(MAPPING_ID_KEY);
+    if (id == null) {
+      diagnosticsHandler.info(
+          MappingInformationDiagnostics.noKeyInJson(lineNumber, MAPPING_ID_KEY));
+      return null;
+    }
+    String idString = id.getAsString();
+    if (idString == null) {
+      diagnosticsHandler.info(
+          MappingInformationDiagnostics.notValidString(lineNumber, MAPPING_ID_KEY));
+      return null;
+    }
+    switch (idString) {
+      case MethodSignatureChangedInformation.ID:
+        return MethodSignatureChangedInformation.build(object, diagnosticsHandler, lineNumber);
+      case FileNameInformation.ID:
+        return FileNameInformation.build(object, diagnosticsHandler, lineNumber);
+      default:
+        diagnosticsHandler.info(MappingInformationDiagnostics.noHandlerFor(lineNumber, idString));
+        return null;
+    }
+  }
+
+  static JsonElement getJsonElementFromObject(
+      JsonObject object,
+      DiagnosticsHandler diagnosticsHandler,
+      int lineNumber,
+      String key,
+      String id) {
+    JsonElement element = object.get(key);
+    if (element == null) {
+      diagnosticsHandler.info(
+          MappingInformationDiagnostics.noKeyForObjectWithId(lineNumber, key, MAPPING_ID_KEY, id));
+    }
+    return element;
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/naming/mappinginformation/MappingInformationDiagnostics.java b/src/main/java/com/android/tools/r8/naming/mappinginformation/MappingInformationDiagnostics.java
new file mode 100644
index 0000000..6cc0b28
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/naming/mappinginformation/MappingInformationDiagnostics.java
@@ -0,0 +1,113 @@
+// 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.mappinginformation;
+
+import com.android.tools.r8.Diagnostic;
+import com.android.tools.r8.Keep;
+import com.android.tools.r8.origin.Origin;
+import com.android.tools.r8.position.Position;
+import com.android.tools.r8.position.TextPosition;
+
+@Keep
+public class MappingInformationDiagnostics implements Diagnostic {
+
+  private final String message;
+  private final Position position;
+
+  @Override
+  public Origin getOrigin() {
+    return Origin.unknown();
+  }
+
+  @Override
+  public Position getPosition() {
+    return position;
+  }
+
+  @Override
+  public String getDiagnosticMessage() {
+    return message;
+  }
+
+  private MappingInformationDiagnostics(String message, Position position) {
+    this.message = message;
+    this.position = position;
+  }
+
+  static MappingInformationDiagnostics noHandlerFor(int lineNumber, String value) {
+    return new MappingInformationDiagnostics(
+        String.format("Could not find a handler for %s", value),
+        new TextPosition(1, lineNumber, TextPosition.UNKNOWN_COLUMN));
+  }
+
+  static MappingInformationDiagnostics noKeyInJson(int lineNumber, String key) {
+    return new MappingInformationDiagnostics(
+        String.format("Could not locate '%s' in the JSON object", key),
+        new TextPosition(1, lineNumber, TextPosition.UNKNOWN_COLUMN));
+  }
+
+  static MappingInformationDiagnostics notValidJson(int lineNumber) {
+    return new MappingInformationDiagnostics(
+        "Not valid JSON", new TextPosition(1, lineNumber, TextPosition.UNKNOWN_COLUMN));
+  }
+
+  static MappingInformationDiagnostics notValidString(int lineNumber, String key) {
+    return new MappingInformationDiagnostics(
+        String.format("The value of '%s' is not a valid string in the JSON object", key),
+        new TextPosition(1, lineNumber, TextPosition.UNKNOWN_COLUMN));
+  }
+
+  static MappingInformationDiagnostics tooManyInformationalParameters(int lineNumber) {
+    return new MappingInformationDiagnostics(
+        "More informational parameters than actual parameters for method signature",
+        new TextPosition(1, lineNumber, TextPosition.UNKNOWN_COLUMN));
+  }
+
+  static MappingInformationDiagnostics noKeyForObjectWithId(
+      int lineNumber, String key, String mappingKey, String mappingValue) {
+    return new MappingInformationDiagnostics(
+        String.format("Could not find '%s' for object with %s '%s'", key, mappingKey, mappingValue),
+        new TextPosition(1, lineNumber, TextPosition.UNKNOWN_COLUMN));
+  }
+
+  static MappingInformationDiagnostics invalidValueForObjectWithId(
+      int lineNumber, String mappingKey, String mappingValue) {
+    return new MappingInformationDiagnostics(
+        String.format(
+            "Could not decode the information for the object with %s '%s'",
+            mappingKey, mappingValue),
+        new TextPosition(1, lineNumber, TextPosition.UNKNOWN_COLUMN));
+  }
+
+  static MappingInformationDiagnostics tooManyEntriesForParameterInformation(int lineNumber) {
+    return new MappingInformationDiagnostics(
+        "Parameter information do not have 1 or 2 entries",
+        new TextPosition(1, lineNumber, TextPosition.UNKNOWN_COLUMN));
+  }
+
+  static MappingInformationDiagnostics invalidParameterInformationObject(int lineNumber) {
+    return new MappingInformationDiagnostics(
+        "Parameter information is not an index and a string representation of a type",
+        new TextPosition(1, lineNumber, TextPosition.UNKNOWN_COLUMN));
+  }
+
+  public static MappingInformationDiagnostics notAllowedCombination(
+      String className,
+      String renamedClassName,
+      MappingInformation one,
+      MappingInformation other,
+      int lineNumber) {
+    return new MappingInformationDiagnostics(
+        "The mapping '"
+            + one.serialize()
+            + "' is not allowed in combination with '"
+            + other.serialize()
+            + "' in the mapping for "
+            + className
+            + " -> "
+            + renamedClassName,
+        new TextPosition(1, lineNumber, TextPosition.UNKNOWN_COLUMN));
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/naming/mappinginformation/MethodSignatureChangedInformation.java b/src/main/java/com/android/tools/r8/naming/mappinginformation/MethodSignatureChangedInformation.java
new file mode 100644
index 0000000..8bb023d
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/naming/mappinginformation/MethodSignatureChangedInformation.java
@@ -0,0 +1,258 @@
+// 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.mappinginformation;
+
+import static com.android.tools.r8.naming.mappinginformation.MappingInformationDiagnostics.invalidParameterInformationObject;
+import static com.android.tools.r8.naming.mappinginformation.MappingInformationDiagnostics.invalidValueForObjectWithId;
+import static com.android.tools.r8.naming.mappinginformation.MappingInformationDiagnostics.tooManyEntriesForParameterInformation;
+import static com.android.tools.r8.naming.mappinginformation.MappingInformationDiagnostics.tooManyInformationalParameters;
+
+import com.android.tools.r8.DiagnosticsHandler;
+import com.android.tools.r8.naming.MemberNaming.MethodSignature;
+import com.android.tools.r8.naming.MemberNaming.Signature;
+import com.google.gson.JsonArray;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonPrimitive;
+
+/**
+ * The MethodSignatureChangedInformation structure adds extra information regarding the mapped
+ * method signature that is otherwise not available in the existing proguard mapping format. The
+ * JSON-structure is as follows:
+ *
+ * <pre>
+ *   {
+ *     "id": "argumentsChanged",
+ *     "signature": { methodSignature },
+ *     "returnType": "java.lang.String",
+ *     "receiver": false,
+ *     "params": [
+ *       [1], // <-- parameter with original index 1 (starting index based on receiver) is removed.
+ *       [2, Foo] // <-- parameter with index 2 has type Foo
+ *     ]
+ *   }
+ * </pre>
+ */
+public class MethodSignatureChangedInformation extends SignatureMappingInformation {
+
+  private ParameterInformation[] argumentInfos;
+  private final boolean receiver;
+  private final String returnType;
+  private final MethodSignature signature;
+
+  public static final String ID = "methodSignatureChanged";
+  private static final String RETURN_TYPE_KEY = "returnType";
+  private static final String PARAMS_KEY = "params";
+  private static final String RECEIVER_KEY = "receiver";
+
+  @Override
+  public String serialize() {
+    JsonObject result = new JsonObject();
+    serializeMethodSignature(result, signature);
+    result.add(MAPPING_ID_KEY, new JsonPrimitive(ID));
+    result.add(RECEIVER_KEY, new JsonPrimitive(receiver));
+    result.add(RETURN_TYPE_KEY, new JsonPrimitive(returnType));
+    JsonArray arguments = new JsonArray();
+    for (ParameterInformation argInfo : argumentInfos) {
+      arguments.add(argInfo.serialize());
+    }
+    result.add(PARAMS_KEY, arguments);
+    return result.toString();
+  }
+
+  @Override
+  public boolean allowOther(MappingInformation information) {
+    return !information.isMethodSignatureChangedInformation();
+  }
+
+  @Override
+  public Signature getSignature() {
+    return signature;
+  }
+
+  @Override
+  public Signature apply(
+      Signature originalSignature, String renamedName, DiagnosticsHandler diagnosticsHandler) {
+    if (originalSignature == null || !originalSignature.isMethodSignature()) {
+      assert false : "Should only call apply for method signature";
+      return originalSignature;
+    }
+    MethodSignature signature = originalSignature.asMethodSignature();
+    String type = signature.type;
+    String[] parameters = signature.parameters;
+    int numberOfArgumentsRemoved = getNumberOfArgumentsRemoved();
+    if (numberOfArgumentsRemoved > parameters.length) {
+      // The mapping information is not up to date with the current signature.
+      diagnosticsHandler.warning(tooManyInformationalParameters(getLineNumber()));
+      return new MethodSignature(renamedName, type, parameters);
+    }
+    String[] newParameters = new String[parameters.length - numberOfArgumentsRemoved];
+    int insertIndex = 0;
+    for (int i = 0; i < parameters.length; i++) {
+      ParameterInformation argInfo = getParameterInformation(i);
+      if (argInfo != null && argInfo.getType() == null) {
+        // Argument has been removed.
+      } else {
+        if (insertIndex >= newParameters.length) {
+          // The mapping information is not up to date with the current signature.
+          diagnosticsHandler.warning(tooManyInformationalParameters(getLineNumber()));
+          return new MethodSignature(renamedName, type, parameters);
+        } else if (argInfo == null) {
+          // Unchanged, take current parameter.
+          newParameters[insertIndex++] = parameters[i];
+        } else {
+          newParameters[insertIndex++] = argInfo.getType();
+        }
+      }
+    }
+    assert insertIndex == newParameters.length;
+    return new MethodSignature(renamedName, getReturnType(), newParameters);
+  }
+
+  @Override
+  public boolean isMethodSignatureChangedInformation() {
+    return true;
+  }
+
+  public int getNumberOfArgumentsRemoved() {
+    int removedCount = 0;
+    for (ParameterInformation argInfo : argumentInfos) {
+      if (argInfo.type == null) {
+        removedCount++;
+      }
+    }
+    return removedCount;
+  }
+
+  public boolean hasReceiver() {
+    return receiver;
+  }
+
+  public String getReturnType() {
+    return returnType;
+  }
+
+  public ParameterInformation getParameterInformation(int index) {
+    int subtractIndex = receiver ? 1 : 0;
+    for (int i = 0; i < argumentInfos.length; i++) {
+      if (argumentInfos[i].index - subtractIndex == index) {
+        return argumentInfos[i];
+      }
+    }
+    return null;
+  }
+
+  @Override
+  public MethodSignatureChangedInformation asMethodSignatureChangedInformation() {
+    return this;
+  }
+
+  private MethodSignatureChangedInformation(
+      MethodSignature signature,
+      String returnType,
+      boolean hasReceiver,
+      ParameterInformation[] argumentInfos,
+      int lineNumber) {
+    super(lineNumber);
+    this.signature = signature;
+    this.argumentInfos = argumentInfos;
+    this.returnType = returnType;
+    this.receiver = hasReceiver;
+  }
+
+  public static MappingInformation build(
+      JsonObject object, DiagnosticsHandler diagnosticsHandler, int lineNumber) {
+    try {
+      JsonElement returnTypeElement =
+          getJsonElementFromObject(object, diagnosticsHandler, lineNumber, RETURN_TYPE_KEY, ID);
+      JsonElement receiverElement =
+          getJsonElementFromObject(object, diagnosticsHandler, lineNumber, RECEIVER_KEY, ID);
+      JsonElement argsElement =
+          getJsonElementFromObject(object, diagnosticsHandler, lineNumber, PARAMS_KEY, ID);
+      MethodSignature signature = getMethodSignature(object, ID, diagnosticsHandler, lineNumber);
+      if (signature == null
+          || returnTypeElement == null
+          || receiverElement == null
+          || argsElement == null) {
+        return null;
+      }
+      JsonArray argumentsArray = argsElement.getAsJsonArray();
+      if (argumentsArray == null) {
+        return null;
+      }
+      ParameterInformation[] args = new ParameterInformation[argumentsArray.size()];
+      for (int i = 0; i < argumentsArray.size(); i++) {
+        args[i] =
+            ParameterInformation.fromJsonArray(
+                argumentsArray.get(i).getAsJsonArray(), diagnosticsHandler, lineNumber);
+      }
+      return new MethodSignatureChangedInformation(
+          signature,
+          returnTypeElement.getAsString(),
+          receiverElement.getAsBoolean(),
+          args,
+          lineNumber);
+    } catch (UnsupportedOperationException | IllegalStateException ignored) {
+      diagnosticsHandler.info(invalidValueForObjectWithId(lineNumber, MAPPING_ID_KEY, ID));
+      return null;
+    }
+  }
+
+  public static class ParameterInformation {
+    private final int index;
+    private final String type;
+
+    public int getIndex() {
+      return index;
+    }
+
+    public String getType() {
+      return type;
+    }
+
+    private ParameterInformation(int index, String type) {
+      this.index = index;
+      this.type = type;
+    }
+
+    static ParameterInformation fromJsonArray(
+        JsonArray argumentInfo, DiagnosticsHandler diagnosticsHandler, int lineNumber) {
+      assert argumentInfo != null;
+      try {
+        if (argumentInfo.size() > 2) {
+          diagnosticsHandler.info(tooManyEntriesForParameterInformation(lineNumber));
+          return null;
+        }
+        int index = argumentInfo.get(0).getAsInt();
+        if (argumentInfo.size() == 1) {
+          // This is a removed argument - no type information
+          return new ParameterInformation(index, null);
+        } else {
+          return new ParameterInformation(index, argumentInfo.get(1).getAsString());
+        }
+      } catch (UnsupportedOperationException | IllegalStateException ignored) {
+        diagnosticsHandler.info(invalidParameterInformationObject(lineNumber));
+        return null;
+      }
+    }
+
+    public static ParameterInformation buildRemovedParameterInformation(int index) {
+      return new ParameterInformation(index, null);
+    }
+
+    public static ParameterInformation buildChangedParameterInformation(int index, String type) {
+      return new ParameterInformation(index, type);
+    }
+
+    JsonArray serialize() {
+      JsonArray serializedArray = new JsonArray();
+      serializedArray.add(index);
+      if (type != null) {
+        serializedArray.add(type);
+      }
+      return serializedArray;
+    }
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/naming/mappinginformation/SignatureMappingInformation.java b/src/main/java/com/android/tools/r8/naming/mappinginformation/SignatureMappingInformation.java
new file mode 100644
index 0000000..aba33bb
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/naming/mappinginformation/SignatureMappingInformation.java
@@ -0,0 +1,64 @@
+// Copyright (c) 2020, 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.mappinginformation;
+
+import com.android.tools.r8.DiagnosticsHandler;
+import com.android.tools.r8.naming.MemberNaming.MethodSignature;
+import com.android.tools.r8.naming.MemberNaming.Signature;
+import com.google.gson.JsonArray;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+
+public abstract class SignatureMappingInformation extends MappingInformation {
+
+  private static final String SIGNATURE_KEY = "signature";
+
+  SignatureMappingInformation(int lineNumber) {
+    super(lineNumber);
+  }
+
+  @Override
+  public boolean isSignatureMappingInformation() {
+    return true;
+  }
+
+  @Override
+  public SignatureMappingInformation asSignatureMappingInformation() {
+    return this;
+  }
+
+  public abstract Signature getSignature();
+
+  public abstract Signature apply(
+      Signature originalSignature, String renamedName, DiagnosticsHandler diagnosticsHandler);
+
+  JsonObject serializeMethodSignature(JsonObject object, MethodSignature signature) {
+    JsonArray signatureArr = new JsonArray();
+    signatureArr.add(signature.type);
+    signatureArr.add(signature.name);
+    for (String parameter : signature.parameters) {
+      signatureArr.add(parameter);
+    }
+    object.add(SIGNATURE_KEY, signatureArr);
+    return object;
+  }
+
+  static MethodSignature getMethodSignature(
+      JsonObject object, String id, DiagnosticsHandler diagnosticsHandler, int lineNumber) {
+    JsonElement signatureElement =
+        getJsonElementFromObject(object, diagnosticsHandler, lineNumber, SIGNATURE_KEY, id);
+    if (signatureElement == null || !signatureElement.isJsonArray()) {
+      return null;
+    }
+    // Signature will be [returnType, name, param1, param2, ...].
+    JsonArray signature = signatureElement.getAsJsonArray();
+    String[] parameters = new String[signature.size() - 2];
+    for (int i = 2; i < signature.size(); i++) {
+      parameters[i - 2] = signature.get(i).getAsString();
+    }
+    return new MethodSignature(
+        signature.get(1).getAsString(), signature.get(0).getAsString(), parameters);
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/retrace/Retrace.java b/src/main/java/com/android/tools/r8/retrace/Retrace.java
index 0edcea8..f34a5aa 100644
--- a/src/main/java/com/android/tools/r8/retrace/Retrace.java
+++ b/src/main/java/com/android/tools/r8/retrace/Retrace.java
@@ -9,6 +9,7 @@
 import com.android.tools.r8.Diagnostic;
 import com.android.tools.r8.DiagnosticsHandler;
 import com.android.tools.r8.Keep;
+import com.android.tools.r8.Version;
 import com.android.tools.r8.naming.ClassNameMapper;
 import com.android.tools.r8.retrace.RetraceCommand.Builder;
 import com.android.tools.r8.retrace.RetraceCommand.ProguardMapProducer;
@@ -17,7 +18,11 @@
 import com.android.tools.r8.utils.StringDiagnostic;
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.Timing;
+import com.google.common.base.Charsets;
 import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintStream;
+import java.io.UnsupportedEncodingException;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
@@ -35,9 +40,16 @@
 @Keep
 public class Retrace {
 
+  // This is a slight modification of the default regular expression shown for proguard retrace
+  // that allow for retracing classes in the form <class>: lorem ipsum...
+  // Seems like Proguard retrace is expecting the form "Caused by: <class>".
+  public static final String DEFAULT_REGULAR_EXPRESSION =
+      "(?:.*?\\bat\\s+%c\\.%m\\s*\\(%s(?::%l)?\\)\\s*(?:~\\[.*\\])?)"
+          + "|(?:(?:(?:%c|.*)?[:\"]\\s+)?%c(?::.*)?)";
+
   public static final String USAGE_MESSAGE =
       StringUtils.lines(
-          "Usage: retrace <proguard-map> <stacktrace-file> [--regex <regexp>, --verbose, --info]",
+          "Usage: retrace <proguard-map> [stack-trace-file] [--regex <regexp>, --verbose, --info]",
           "  where <proguard-map> is an r8 generated mapping file.");
 
   private static Builder parseArguments(String[] args, DiagnosticsHandler diagnosticsHandler) {
@@ -45,11 +57,16 @@
     Builder builder = RetraceCommand.builder(diagnosticsHandler);
     boolean hasSetProguardMap = false;
     boolean hasSetStackTrace = false;
+    boolean hasSetRegularExpression = false;
     while (context.head() != null) {
       Boolean help = OptionsParsing.tryParseBoolean(context, "--help");
       if (help != null) {
         return null;
       }
+      Boolean version = OptionsParsing.tryParseBoolean(context, "--version");
+      if (version != null) {
+        return null;
+      }
       Boolean info = OptionsParsing.tryParseBoolean(context, "--info");
       if (info != null) {
         // This is already set in the diagnostics handler.
@@ -63,6 +80,7 @@
       String regex = OptionsParsing.tryParseSingle(context, "--regex", "r");
       if (regex != null && !regex.isEmpty()) {
         builder.setRegularExpression(regex);
+        hasSetRegularExpression = true;
         continue;
       }
       if (!hasSetProguardMap) {
@@ -88,6 +106,9 @@
     if (!hasSetStackTrace) {
       builder.setStackTrace(getStackTraceFromStandardInput());
     }
+    if (!hasSetRegularExpression) {
+      builder.setRegularExpression(DEFAULT_REGULAR_EXPRESSION);
+    }
     return builder;
   }
 
@@ -105,7 +126,7 @@
   private static List<String> getStackTraceFromFile(
       String stackTracePath, DiagnosticsHandler diagnostics) {
     try {
-      return Files.readAllLines(Paths.get(stackTracePath));
+      return Files.readAllLines(Paths.get(stackTracePath), Charsets.UTF_8);
     } catch (IOException e) {
       diagnostics.error(new StringDiagnostic("Could not find stack trace file: " + stackTracePath));
       throw new RetraceAbortException();
@@ -122,23 +143,25 @@
       Timing timing = Timing.create("R8 retrace", command.printMemory());
       timing.begin("Read proguard map");
       ClassNameMapper classNameMapper =
-          ClassNameMapper.mapperFromString(command.proguardMapProducer.get());
+          ClassNameMapper.mapperFromString(
+              command.proguardMapProducer.get(), command.diagnosticsHandler);
       timing.end();
-      RetraceBase retraceBase = RetraceBaseImpl.create(classNameMapper);
+      RetraceApi retracer = Retracer.create(classNameMapper);
       RetraceCommandLineResult result;
       timing.begin("Parse and Retrace");
       if (command.regularExpression != null) {
         result =
             new RetraceRegularExpression(
-                    retraceBase,
+                    retracer,
                     command.stackTrace,
                     command.diagnosticsHandler,
-                    command.regularExpression)
+                    command.regularExpression,
+                    command.isVerbose)
                 .retrace();
       } else {
         result =
             new RetraceStackTrace(
-                    retraceBase, command.stackTrace, command.diagnosticsHandler, command.isVerbose)
+                    retracer, command.stackTrace, command.diagnosticsHandler, command.isVerbose)
                 .retrace();
       }
       timing.end();
@@ -156,18 +179,47 @@
   }
 
   public static void run(String[] args) {
+    // To be compatible with standard retrace and remapper, we translate -arg into --arg.
+    String[] mappedArgs = new String[args.length];
+    boolean printInfo = false;
+    for (int i = 0; i < args.length; i++) {
+      String arg = args[i];
+      if (arg == null || arg.length() < 2) {
+        mappedArgs[i] = arg;
+        continue;
+      }
+      if (arg.charAt(0) == '-' && arg.charAt(1) != '-') {
+        mappedArgs[i] = "-" + arg;
+      } else {
+        mappedArgs[i] = arg;
+      }
+      if (mappedArgs[i].equals("--info")) {
+        printInfo = true;
+      }
+    }
     RetraceDiagnosticsHandler retraceDiagnosticsHandler =
-        new RetraceDiagnosticsHandler(
-            new DiagnosticsHandler() {}, Arrays.asList(args).contains("--info"));
-    Builder builder = parseArguments(args, retraceDiagnosticsHandler);
+        new RetraceDiagnosticsHandler(new DiagnosticsHandler() {}, printInfo);
+    Builder builder = parseArguments(mappedArgs, retraceDiagnosticsHandler);
     if (builder == null) {
-      // --help was an argument to list
-      assert Arrays.asList(args).contains("--help");
+      // --help or --version was an argument to list
+      if (Arrays.asList(mappedArgs).contains("--version")) {
+        System.out.println("Retrace " + Version.getVersionString());
+        return;
+      }
+      assert Arrays.asList(mappedArgs).contains("--help");
       System.out.print(USAGE_MESSAGE);
       return;
     }
     builder.setRetracedStackTraceConsumer(
-        retraced -> System.out.print(StringUtils.lines(retraced)));
+        retraced -> {
+          try (PrintStream printStream = new PrintStream(System.out, true, Charsets.UTF_8.name())) {
+            for (String line : retraced) {
+              printStream.println(line);
+            }
+          } catch (UnsupportedEncodingException e) {
+            retraceDiagnosticsHandler.error(new StringDiagnostic(e.getMessage()));
+          }
+        });
     run(builder.build());
   }
 
@@ -181,7 +233,7 @@
   }
 
   private static List<String> getStackTraceFromStandardInput() {
-    Scanner sc = new Scanner(System.in);
+    Scanner sc = new Scanner(new InputStreamReader(System.in, Charsets.UTF_8));
     List<String> readLines = new ArrayList<>();
     while (sc.hasNext()) {
       readLines.add(sc.nextLine());
diff --git a/src/main/java/com/android/tools/r8/retrace/RetraceBase.java b/src/main/java/com/android/tools/r8/retrace/RetraceApi.java
similarity index 72%
rename from src/main/java/com/android/tools/r8/retrace/RetraceBase.java
rename to src/main/java/com/android/tools/r8/retrace/RetraceApi.java
index 2874fc8..7bb9232 100644
--- a/src/main/java/com/android/tools/r8/retrace/RetraceBase.java
+++ b/src/main/java/com/android/tools/r8/retrace/RetraceApi.java
@@ -4,12 +4,15 @@
 
 package com.android.tools.r8.retrace;
 
+import com.android.tools.r8.Keep;
 import com.android.tools.r8.references.ClassReference;
 import com.android.tools.r8.references.FieldReference;
 import com.android.tools.r8.references.MethodReference;
 import com.android.tools.r8.references.TypeReference;
 
-public interface RetraceBase {
+/** This is the main api interface for retrace. */
+@Keep
+public interface RetraceApi {
 
   RetraceMethodResult retrace(MethodReference methodReference);
 
@@ -18,12 +21,4 @@
   RetraceClassResult retrace(ClassReference classReference);
 
   RetraceTypeResult retrace(TypeReference typeReference);
-
-  String retraceSourceFile(ClassReference classReference, String sourceFile);
-
-  String retraceSourceFile(
-      ClassReference classReference,
-      String sourceFile,
-      ClassReference retracedClassReference,
-      boolean hasRetraceResult);
 }
diff --git a/src/main/java/com/android/tools/r8/retrace/RetraceBaseImpl.java b/src/main/java/com/android/tools/r8/retrace/RetraceBaseImpl.java
deleted file mode 100644
index 9a68706..0000000
--- a/src/main/java/com/android/tools/r8/retrace/RetraceBaseImpl.java
+++ /dev/null
@@ -1,98 +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.retrace;
-
-import com.android.tools.r8.naming.ClassNameMapper;
-import com.android.tools.r8.references.ClassReference;
-import com.android.tools.r8.references.FieldReference;
-import com.android.tools.r8.references.MethodReference;
-import com.android.tools.r8.references.TypeReference;
-import com.android.tools.r8.utils.Box;
-import com.google.common.collect.Sets;
-import com.google.common.io.Files;
-import java.util.Set;
-
-public class RetraceBaseImpl implements RetraceBase {
-
-  private static final Set<String> UNKNOWN_SOURCEFILE_NAMES =
-      Sets.newHashSet("", "SourceFile", "Unknown", "Unknown Source");
-
-  private final ClassNameMapper classNameMapper;
-
-  private RetraceBaseImpl(ClassNameMapper classNameMapper) {
-    this.classNameMapper = classNameMapper;
-  }
-
-  public static RetraceBase create(ClassNameMapper classNameMapper) {
-    return new RetraceBaseImpl(classNameMapper);
-  }
-
-  @Override
-  public RetraceMethodResult retrace(MethodReference methodReference) {
-    return retrace(methodReference.getHolderClass()).lookupMethod(methodReference.getMethodName());
-  }
-
-  @Override
-  public RetraceFieldResult retrace(FieldReference fieldReference) {
-    return retrace(fieldReference.getHolderClass()).lookupField(fieldReference.getFieldName());
-  }
-
-  @Override
-  public RetraceClassResult retrace(ClassReference classReference) {
-    return RetraceClassResult.create(
-        classReference, classNameMapper.getClassNaming(classReference.getTypeName()));
-  }
-
-  @Override
-  public String retraceSourceFile(ClassReference classReference, String sourceFile) {
-    Box<String> retracedSourceFile = new Box<>();
-    retrace(classReference)
-        .forEach(element -> retracedSourceFile.set(element.retraceSourceFile(sourceFile, this)));
-    return retracedSourceFile.get();
-  }
-
-  @Override
-  public RetraceTypeResult retrace(TypeReference typeReference) {
-    return new RetraceTypeResult(typeReference, this);
-  }
-
-  @Override
-  public String retraceSourceFile(
-      ClassReference obfuscatedClass,
-      String sourceFile,
-      ClassReference retracedClassReference,
-      boolean hasRetraceResult) {
-    boolean fileNameProbablyChanged =
-        hasRetraceResult
-            && !retracedClassReference.getTypeName().startsWith(obfuscatedClass.getTypeName());
-    if (!UNKNOWN_SOURCEFILE_NAMES.contains(sourceFile) && !fileNameProbablyChanged) {
-      // We have no new information, only rewrite filename if it is unknown.
-      // PG-retrace will always rewrite the filename, but that seems a bit to harsh to do.
-      return sourceFile;
-    }
-    if (!hasRetraceResult) {
-      // We have no mapping but but the file name is unknown, so the best we can do is take the
-      // name of the obfuscated clazz.
-      assert obfuscatedClass.getTypeName().equals(retracedClassReference.getTypeName());
-      return getClassSimpleName(obfuscatedClass.getTypeName()) + ".java";
-    }
-    String newFileName = getClassSimpleName(retracedClassReference.getTypeName());
-    String extension = Files.getFileExtension(sourceFile);
-    if (extension.isEmpty()) {
-      extension = "java";
-    }
-    return newFileName + "." + extension;
-  }
-
-  private static String getClassSimpleName(String clazz) {
-    int lastIndexOfPeriod = clazz.lastIndexOf('.');
-    // Check if we can find a subclass separator.
-    int endIndex = clazz.lastIndexOf('$');
-    if (lastIndexOfPeriod > endIndex || endIndex < 0) {
-      endIndex = clazz.length();
-    }
-    return clazz.substring(lastIndexOfPeriod + 1, endIndex);
-  }
-}
diff --git a/src/main/java/com/android/tools/r8/retrace/RetraceClassResult.java b/src/main/java/com/android/tools/r8/retrace/RetraceClassResult.java
index 25505fe..e13c832 100644
--- a/src/main/java/com/android/tools/r8/retrace/RetraceClassResult.java
+++ b/src/main/java/com/android/tools/r8/retrace/RetraceClassResult.java
@@ -4,10 +4,14 @@
 
 package com.android.tools.r8.retrace;
 
+import static com.android.tools.r8.naming.MemberNaming.NoSignature.NO_SIGNATURE;
+import static com.android.tools.r8.retrace.RetraceUtils.synthesizeFileName;
+
 import com.android.tools.r8.Keep;
 import com.android.tools.r8.naming.ClassNamingForNameMapper;
 import com.android.tools.r8.naming.ClassNamingForNameMapper.MappedRangesOfName;
 import com.android.tools.r8.naming.MemberNaming;
+import com.android.tools.r8.naming.mappinginformation.MappingInformation;
 import com.android.tools.r8.references.ClassReference;
 import com.android.tools.r8.references.Reference;
 import com.android.tools.r8.retrace.RetraceClassResult.Element;
@@ -22,15 +26,18 @@
 
   private final ClassReference obfuscatedReference;
   private final ClassNamingForNameMapper mapper;
+  private final RetraceApi retracer;
 
-  private RetraceClassResult(ClassReference obfuscatedReference, ClassNamingForNameMapper mapper) {
+  private RetraceClassResult(
+      ClassReference obfuscatedReference, ClassNamingForNameMapper mapper, RetraceApi retracer) {
     this.obfuscatedReference = obfuscatedReference;
     this.mapper = mapper;
+    this.retracer = retracer;
   }
 
   static RetraceClassResult create(
-      ClassReference obfuscatedReference, ClassNamingForNameMapper mapper) {
-    return new RetraceClassResult(obfuscatedReference, mapper);
+      ClassReference obfuscatedReference, ClassNamingForNameMapper mapper, RetraceApi retracer) {
+    return new RetraceClassResult(obfuscatedReference, mapper, retracer);
   }
 
   public RetraceFieldResult lookupField(String fieldName) {
@@ -71,12 +78,12 @@
           if (element.mapper != null) {
             mappedRangesForT = lookupFunction.apply(element.mapper, name);
           }
-          elementBox.set(constructor.create(element, mappedRangesForT, name));
+          elementBox.set(constructor.create(element, mappedRangesForT, name, retracer));
         });
     return elementBox.get();
   }
 
-  private boolean hasRetraceResult() {
+  boolean hasRetraceResult() {
     return mapper != null;
   }
 
@@ -86,7 +93,8 @@
         new Element(
             this,
             mapper == null ? obfuscatedReference : Reference.classFromTypeName(mapper.originalName),
-            mapper));
+            mapper,
+            false));
   }
 
   @Override
@@ -96,7 +104,12 @@
   }
 
   private interface ResultConstructor<T, R> {
-    R create(Element element, T mappings, String obfuscatedName);
+    R create(Element element, T mappings, String obfuscatedName, RetraceApi retraceApi);
+  }
+
+  public boolean isAmbiguous() {
+    // Currently we have no way of producing ambiguous class results.
+    return false;
   }
 
   public static class Element {
@@ -108,7 +121,8 @@
     public Element(
         RetraceClassResult classResult,
         ClassReference classReference,
-        ClassNamingForNameMapper mapper) {
+        ClassNamingForNameMapper mapper,
+        boolean isAmbiguous) {
       this.classResult = classResult;
       this.classReference = classReference;
       this.mapper = mapper;
@@ -122,9 +136,26 @@
       return classResult;
     }
 
-    public String retraceSourceFile(String fileName, RetraceBase retraceBase) {
-      return retraceBase.retraceSourceFile(
-          classResult.obfuscatedReference, fileName, classReference, mapper != null);
+    public RetraceSourceFileResult retraceSourceFile(String sourceFile) {
+      if (mapper != null && mapper.getAdditionalMappings().size() > 0) {
+        List<MappingInformation> mappingInformations =
+            mapper.getAdditionalMappings().get(NO_SIGNATURE);
+        if (mappingInformations != null) {
+          for (MappingInformation mappingInformation : mappingInformations) {
+            if (mappingInformation.isFileNameInformation()) {
+              return new RetraceSourceFileResult(
+                  mappingInformation.asFileNameInformation().getFileName(), false);
+            }
+          }
+        }
+      }
+      return new RetraceSourceFileResult(
+          synthesizeFileName(
+              classReference.getTypeName(),
+              classResult.obfuscatedReference.getTypeName(),
+              sourceFile,
+              mapper != null),
+          true);
     }
 
     public RetraceFieldResult lookupField(String fieldName) {
@@ -158,7 +189,10 @@
         BiFunction<ClassNamingForNameMapper, String, T> lookupFunction,
         ResultConstructor<T, R> constructor) {
       return constructor.create(
-          this, mapper != null ? lookupFunction.apply(mapper, name) : null, name);
+          this,
+          mapper != null ? lookupFunction.apply(mapper, name) : null,
+          name,
+          classResult.retracer);
     }
   }
 }
diff --git a/src/main/java/com/android/tools/r8/retrace/RetraceFieldResult.java b/src/main/java/com/android/tools/r8/retrace/RetraceFieldResult.java
index d02913e..5477eaa 100644
--- a/src/main/java/com/android/tools/r8/retrace/RetraceFieldResult.java
+++ b/src/main/java/com/android/tools/r8/retrace/RetraceFieldResult.java
@@ -23,14 +23,17 @@
   private final RetraceClassResult.Element classElement;
   private final List<MemberNaming> memberNamings;
   private final String obfuscatedName;
+  private final RetraceApi retracer;
 
   RetraceFieldResult(
       RetraceClassResult.Element classElement,
       List<MemberNaming> memberNamings,
-      String obfuscatedName) {
+      String obfuscatedName,
+      RetraceApi retracer) {
     this.classElement = classElement;
     this.memberNamings = memberNamings;
     this.obfuscatedName = obfuscatedName;
+    this.retracer = retracer;
     assert classElement != null;
     assert memberNamings == null
         || (!memberNamings.isEmpty() && memberNamings.stream().allMatch(Objects::nonNull));
@@ -40,7 +43,7 @@
     return memberNamings != null;
   }
 
-  private boolean isAmbiguous() {
+  public boolean isAmbiguous() {
     if (!hasRetraceResult()) {
       return false;
     }
diff --git a/src/main/java/com/android/tools/r8/retrace/RetraceMethodResult.java b/src/main/java/com/android/tools/r8/retrace/RetraceMethodResult.java
index f0719ea..7977858 100644
--- a/src/main/java/com/android/tools/r8/retrace/RetraceMethodResult.java
+++ b/src/main/java/com/android/tools/r8/retrace/RetraceMethodResult.java
@@ -26,15 +26,18 @@
   private final String obfuscatedName;
   private final RetraceClassResult.Element classElement;
   private final MappedRangesOfName mappedRanges;
+  private final RetraceApi retracer;
   private Boolean isAmbiguousCached = null;
 
   RetraceMethodResult(
       RetraceClassResult.Element classElement,
       MappedRangesOfName mappedRanges,
-      String obfuscatedName) {
+      String obfuscatedName,
+      RetraceApi retracer) {
     this.classElement = classElement;
     this.mappedRanges = mappedRanges;
     this.obfuscatedName = obfuscatedName;
+    this.retracer = retracer;
     assert classElement != null;
   }
 
@@ -87,7 +90,7 @@
       }
     }
     return new RetraceMethodResult(
-        classElement, new MappedRangesOfName(narrowedRanges), obfuscatedName);
+        classElement, new MappedRangesOfName(narrowedRanges), obfuscatedName, retracer);
   }
 
   @Override
@@ -180,5 +183,10 @@
       }
       return mappedRange.getFirstLineNumberOfOriginalRange();
     }
+
+    public RetraceSourceFileResult retraceSourceFile(String sourceFile) {
+      return RetraceUtils.getSourceFile(
+          classElement, methodReference.getHolderClass(), sourceFile, retraceMethodResult.retracer);
+    }
   }
 }
diff --git a/src/main/java/com/android/tools/r8/retrace/RetraceRegularExpression.java b/src/main/java/com/android/tools/r8/retrace/RetraceRegularExpression.java
index b561305..40b3f41 100644
--- a/src/main/java/com/android/tools/r8/retrace/RetraceRegularExpression.java
+++ b/src/main/java/com/android/tools/r8/retrace/RetraceRegularExpression.java
@@ -5,100 +5,120 @@
 package com.android.tools.r8.retrace;
 
 import com.android.tools.r8.DiagnosticsHandler;
+import com.android.tools.r8.errors.Unreachable;
 import com.android.tools.r8.references.ClassReference;
-import com.android.tools.r8.references.MethodReference;
+import com.android.tools.r8.references.FieldReference;
 import com.android.tools.r8.references.Reference;
 import com.android.tools.r8.references.TypeReference;
 import com.android.tools.r8.retrace.RetraceClassResult.Element;
-import com.android.tools.r8.retrace.RetraceRegularExpression.RetraceString.RetraceStringBuilder;
+import com.android.tools.r8.retrace.RetraceRegularExpression.ClassNameGroup.ClassNameGroupHandler;
+import com.android.tools.r8.utils.Box;
 import com.android.tools.r8.utils.DescriptorUtils;
 import com.android.tools.r8.utils.StringDiagnostic;
 import com.android.tools.r8.utils.StringUtils;
 import com.google.common.collect.Lists;
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.LinkedHashSet;
 import java.util.List;
-import java.util.Set;
+import java.util.Objects;
+import java.util.function.BiConsumer;
+import java.util.function.Function;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 
 public class RetraceRegularExpression {
 
-  private final RetraceBase retraceBase;
+  private final RetraceApi retracer;
   private final List<String> stackTrace;
   private final DiagnosticsHandler diagnosticsHandler;
   private final String regularExpression;
 
   private static final int NO_MATCH = -1;
 
-  private final RegularExpressionGroup[] groups =
-      new RegularExpressionGroup[] {
-        new TypeNameGroup(),
-        new BinaryNameGroup(),
-        new MethodNameGroup(),
-        new FieldNameGroup(),
-        new SourceFileGroup(),
-        new LineNumberGroup(),
-        new FieldOrReturnTypeGroup(),
-        new MethodArgumentsGroup()
-      };
+  private final SourceFileLineNumberGroup sourceFileLineNumberGroup =
+      new SourceFileLineNumberGroup();
+  private final TypeNameGroup typeNameGroup = new TypeNameGroup();
+  private final BinaryNameGroup binaryNameGroup = new BinaryNameGroup();
+  private final SourceFileGroup sourceFileGroup = new SourceFileGroup();
+  private final LineNumberGroup lineNumberGroup = new LineNumberGroup();
+  private final FieldOrReturnTypeGroup fieldOrReturnTypeGroup = new FieldOrReturnTypeGroup();
+  private final MethodArgumentsGroup methodArgumentsGroup = new MethodArgumentsGroup();
+
+  private final MethodNameGroup methodNameGroup;
+  private final FieldNameGroup fieldNameGroup;
 
   private static final String CAPTURE_GROUP_PREFIX = "captureGroup";
+  private static final int FIRST_CAPTURE_GROUP_INDEX = 0;
 
   RetraceRegularExpression(
-      RetraceBase retraceBase,
+      RetraceApi retracer,
       List<String> stackTrace,
       DiagnosticsHandler diagnosticsHandler,
-      String regularExpression) {
-    this.retraceBase = retraceBase;
+      String regularExpression,
+      boolean isVerbose) {
+    this.retracer = retracer;
     this.stackTrace = stackTrace;
     this.diagnosticsHandler = diagnosticsHandler;
     this.regularExpression = regularExpression;
+    methodNameGroup = new MethodNameGroup(isVerbose);
+    fieldNameGroup = new FieldNameGroup(isVerbose);
   }
 
   public RetraceCommandLineResult retrace() {
     List<RegularExpressionGroupHandler> handlers = new ArrayList<>();
-    String regularExpression = registerGroups(this.regularExpression, handlers);
-    Pattern compiledPattern = Pattern.compile(regularExpression);
+    StringBuilder refinedRegularExpressionBuilder = new StringBuilder();
+    registerGroups(
+        this.regularExpression,
+        refinedRegularExpressionBuilder,
+        handlers,
+        FIRST_CAPTURE_GROUP_INDEX);
+    String refinedRegularExpression = refinedRegularExpressionBuilder.toString();
+    Pattern compiledPattern = Pattern.compile(refinedRegularExpression);
     List<String> result = new ArrayList<>();
     for (String string : stackTrace) {
       Matcher matcher = compiledPattern.matcher(string);
-      List<RetraceString> retracedStrings =
-          Lists.newArrayList(RetraceStringBuilder.create(string).build());
-      if (matcher.matches()) {
-        for (RegularExpressionGroupHandler handler : handlers) {
-          retracedStrings = handler.handleMatch(retracedStrings, matcher, retraceBase);
-        }
+      if (!matcher.matches()) {
+        result.add(string);
+        continue;
+      }
+      // Iterate through handlers to set contexts. That will allow us to process all handlers from
+      // left to right.
+      RetraceStringContext initialContext = RetraceStringContext.empty();
+      for (RegularExpressionGroupHandler handler : handlers) {
+        initialContext = handler.buildInitial(initialContext, matcher, retracer);
+      }
+      final RetraceString initialRetraceString = RetraceString.start(initialContext);
+      List<RetraceString> retracedStrings = Lists.newArrayList(initialRetraceString);
+      for (RegularExpressionGroupHandler handler : handlers) {
+        retracedStrings = handler.handleMatch(string, retracedStrings, matcher, retracer);
       }
       if (retracedStrings.isEmpty()) {
         // We could not find a match. Output the identity.
         result.add(string);
-      } else {
-        boolean isAmbiguous = retracedStrings.size() > 1 && retracedStrings.get(0).isAmbiguous;
-        if (isAmbiguous) {
-          retracedStrings.sort(new RetraceLineComparator());
-        }
-        ClassReference previousContext = null;
-        for (RetraceString retracedString : retracedStrings) {
-          String finalString = retracedString.getRetracedString();
-          if (!isAmbiguous) {
-            result.add(finalString);
-            continue;
-          }
-          assert retracedString.getClassContext() != null;
-          ClassReference currentContext = retracedString.getClassContext().getClassReference();
-          if (currentContext.equals(previousContext)) {
-            int firstNonWhitespaceCharacter = StringUtils.firstNonWhitespaceCharacter(finalString);
-            finalString =
-                finalString.substring(0, firstNonWhitespaceCharacter)
-                    + "<OR> "
-                    + finalString.substring(firstNonWhitespaceCharacter);
-          }
-          previousContext = currentContext;
+      }
+      boolean isAmbiguous = retracedStrings.size() > 1 && retracedStrings.get(0).isAmbiguous();
+      if (isAmbiguous) {
+        retracedStrings.sort(new RetraceLineComparator());
+      }
+      ClassReference previousContext = null;
+      for (RetraceString retracedString : retracedStrings) {
+        String finalString = retracedString.builder.build(string);
+        if (!isAmbiguous) {
           result.add(finalString);
+          continue;
         }
+        assert retracedString.getClassContext() != null;
+        ClassReference currentContext = retracedString.getClassContext().getClassReference();
+        if (currentContext.equals(previousContext)) {
+          int firstNonWhitespaceCharacter = StringUtils.firstNonWhitespaceCharacter(finalString);
+          finalString =
+              finalString.substring(0, firstNonWhitespaceCharacter)
+                  + "<OR> "
+                  + finalString.substring(firstNonWhitespaceCharacter);
+        }
+        previousContext = currentContext;
+        result.add(finalString);
       }
     }
     return new RetraceCommandLineResult(result);
@@ -126,273 +146,344 @@
     }
   }
 
-  private String registerGroups(
-      String regularExpression, List<RegularExpressionGroupHandler> handlers) {
-    int currentIndex = 0;
-    int captureGroupIndex = 0;
-    while (currentIndex < regularExpression.length()) {
-      RegularExpressionGroup firstGroup = null;
-      int firstIndexFromCurrent = regularExpression.length();
-      for (RegularExpressionGroup group : groups) {
-        int nextIndexOf = regularExpression.indexOf(group.shortName(), currentIndex);
-        if (nextIndexOf > NO_MATCH && nextIndexOf < firstIndexFromCurrent) {
-          // Check if previous character in the regular expression is not \\ to ensure not
-          // overriding a matching on shortName.
-          if (nextIndexOf > 0 && regularExpression.charAt(nextIndexOf - 1) == '\\') {
-            continue;
+  private int registerGroups(
+      String regularExpression,
+      StringBuilder refinedRegularExpression,
+      List<RegularExpressionGroupHandler> handlers,
+      int captureGroupIndex) {
+    int lastCommittedIndex = 0;
+    RegularExpressionGroupHandler lastHandler = null;
+    boolean seenPercentage = false;
+    boolean escaped = false;
+    for (int i = 0; i < regularExpression.length(); i++) {
+      if (seenPercentage) {
+        assert !escaped;
+        final RegularExpressionGroup group = getGroupFromVariable(regularExpression.charAt(i));
+        refinedRegularExpression.append(regularExpression, lastCommittedIndex, i - 1);
+        if (group.isSynthetic()) {
+          captureGroupIndex =
+              registerGroups(
+                  group.subExpression(), refinedRegularExpression, handlers, captureGroupIndex);
+        } else {
+          String captureGroupName = CAPTURE_GROUP_PREFIX + (captureGroupIndex++);
+          refinedRegularExpression
+              .append("(?<")
+              .append(captureGroupName)
+              .append(">")
+              .append(group.subExpression())
+              .append(")");
+          final RegularExpressionGroupHandler handler = group.createHandler(captureGroupName);
+          // If we see a pattern as %c.%m or %C/%m, then register the groups to allow delaying
+          // writing of the class string until we have the fully qualified member.
+          if (lastHandler != null
+              && handler.isQualifiedHandler()
+              && lastHandler.isClassNameGroupHandler()
+              && lastCommittedIndex == i - 3
+              && isTypeOrBinarySeparator(regularExpression, lastCommittedIndex, i - 2)) {
+            final ClassNameGroupHandler classNameGroupHandler =
+                lastHandler.asClassNameGroupHandler();
+            final QualifiedRegularExpressionGroupHandler qualifiedHandler =
+                handler.asQualifiedHandler();
+            classNameGroupHandler.setQualifiedHandler(qualifiedHandler);
+            qualifiedHandler.setClassNameGroupHandler(classNameGroupHandler);
           }
-          firstGroup = group;
-          firstIndexFromCurrent = nextIndexOf;
+          lastHandler = handler;
+          handlers.add(handler);
         }
+        lastCommittedIndex = i + 1;
+        seenPercentage = false;
+      } else {
+        seenPercentage = !escaped && regularExpression.charAt(i) == '%';
+        escaped = !escaped && regularExpression.charAt(i) == '\\';
       }
-      if (firstGroup != null) {
-        String captureGroupName = CAPTURE_GROUP_PREFIX + (captureGroupIndex++);
-        String patternToInsert = "(?<" + captureGroupName + ">" + firstGroup.subExpression() + ")";
-        regularExpression =
-            regularExpression.substring(0, firstIndexFromCurrent)
-                + patternToInsert
-                + regularExpression.substring(
-                    firstIndexFromCurrent + firstGroup.shortName().length());
-        handlers.add(firstGroup.createHandler(captureGroupName));
-        firstIndexFromCurrent += patternToInsert.length();
-      }
-      currentIndex = firstIndexFromCurrent;
     }
-    return regularExpression;
+    refinedRegularExpression.append(
+        regularExpression, lastCommittedIndex, regularExpression.length());
+    return captureGroupIndex;
   }
 
-  static class RetraceString {
+  private boolean isTypeOrBinarySeparator(String regularExpression, int startIndex, int endIndex) {
+    assert endIndex < regularExpression.length();
+    if (startIndex + 1 != endIndex) {
+      return false;
+    }
+    if (regularExpression.charAt(startIndex) != '\\') {
+      return false;
+    }
+    return regularExpression.charAt(startIndex + 1) == '.'
+        || regularExpression.charAt(startIndex + 1) == '/';
+  }
 
+  private RegularExpressionGroup getGroupFromVariable(char variable) {
+    switch (variable) {
+      case 'c':
+        return typeNameGroup;
+      case 'C':
+        return binaryNameGroup;
+      case 'm':
+        return methodNameGroup;
+      case 'f':
+        return fieldNameGroup;
+      case 's':
+        return sourceFileGroup;
+      case 'l':
+        return lineNumberGroup;
+      case 'S':
+        return sourceFileLineNumberGroup;
+      case 't':
+        return fieldOrReturnTypeGroup;
+      case 'a':
+        return methodArgumentsGroup;
+      default:
+        throw new Unreachable("Unexpected variable: " + variable);
+    }
+  }
+
+  static class RetraceStringContext {
     private final Element classContext;
-    private final ClassNameGroup classNameGroup;
     private final ClassReference qualifiedContext;
+    private final String methodName;
     private final RetraceMethodResult.Element methodContext;
-    private final TypeReference typeOrReturnTypeContext;
-    private final boolean hasTypeOrReturnTypeContext;
-    private final String retracedString;
-    private final int adjustedIndex;
-    private final boolean isAmbiguous;
-    private final int lineNumber;
+    private final int minifiedLineNumber;
+    private final int originalLineNumber;
     private final String source;
+    private final boolean isAmbiguous;
 
-    private RetraceString(
+    private RetraceStringContext(
         Element classContext,
-        ClassNameGroup classNameGroup,
         ClassReference qualifiedContext,
+        String methodName,
         RetraceMethodResult.Element methodContext,
-        TypeReference typeOrReturnTypeContext,
-        boolean hasTypeOrReturnTypeContext,
-        String retracedString,
-        int adjustedIndex,
-        boolean isAmbiguous,
-        int lineNumber,
-        String source) {
+        int minifiedLineNumber,
+        int originalLineNumber,
+        String source,
+        boolean isAmbiguous) {
       this.classContext = classContext;
-      this.classNameGroup = classNameGroup;
       this.qualifiedContext = qualifiedContext;
+      this.methodName = methodName;
       this.methodContext = methodContext;
-      this.typeOrReturnTypeContext = typeOrReturnTypeContext;
-      this.hasTypeOrReturnTypeContext = hasTypeOrReturnTypeContext;
-      this.retracedString = retracedString;
-      this.adjustedIndex = adjustedIndex;
-      this.isAmbiguous = isAmbiguous;
-      this.lineNumber = lineNumber;
+      this.minifiedLineNumber = minifiedLineNumber;
+      this.originalLineNumber = originalLineNumber;
       this.source = source;
+      this.isAmbiguous = isAmbiguous;
     }
 
-    String getRetracedString() {
-      return retracedString;
+    private static RetraceStringContext empty() {
+      return new RetraceStringContext(null, null, null, null, NO_MATCH, NO_MATCH, null, false);
     }
 
-    boolean hasTypeOrReturnTypeContext() {
-      return hasTypeOrReturnTypeContext;
+    private RetraceStringContext withClassContext(
+        Element classContext, ClassReference qualifiedContext) {
+      return new RetraceStringContext(
+          classContext,
+          qualifiedContext,
+          methodName,
+          methodContext,
+          minifiedLineNumber,
+          originalLineNumber,
+          source,
+          isAmbiguous);
     }
 
-    Element getClassContext() {
-      return classContext;
+    private RetraceStringContext withMethodName(String methodName) {
+      return new RetraceStringContext(
+          classContext,
+          qualifiedContext,
+          methodName,
+          methodContext,
+          minifiedLineNumber,
+          originalLineNumber,
+          source,
+          isAmbiguous);
     }
 
-    RetraceMethodResult.Element getMethodContext() {
-      return methodContext;
+    private RetraceStringContext withMethodContext(
+        RetraceMethodResult.Element methodContext,
+        ClassReference qualifiedContext,
+        boolean isAmbiguous) {
+      return new RetraceStringContext(
+          classContext,
+          qualifiedContext,
+          methodName,
+          methodContext,
+          minifiedLineNumber,
+          originalLineNumber,
+          source,
+          isAmbiguous);
     }
 
-    TypeReference getTypeOrReturnTypeContext() {
-      return typeOrReturnTypeContext;
+    private RetraceStringContext withQualifiedContext(ClassReference qualifiedContext) {
+      return new RetraceStringContext(
+          classContext,
+          qualifiedContext,
+          methodName,
+          methodContext,
+          minifiedLineNumber,
+          originalLineNumber,
+          source,
+          isAmbiguous);
     }
 
-    public ClassReference getQualifiedContext() {
-      return qualifiedContext;
+    public RetraceStringContext withSource(String source) {
+      return new RetraceStringContext(
+          classContext,
+          qualifiedContext,
+          methodName,
+          methodContext,
+          minifiedLineNumber,
+          originalLineNumber,
+          source,
+          isAmbiguous);
     }
 
-    RetraceStringBuilder transform() {
-      return RetraceStringBuilder.create(this);
+    public RetraceStringContext withLineNumbers(int minifiedLineNumber, int originalLineNumber) {
+      return new RetraceStringContext(
+          classContext,
+          qualifiedContext,
+          methodName,
+          methodContext,
+          minifiedLineNumber,
+          originalLineNumber,
+          source,
+          isAmbiguous);
+    }
+  }
+
+  static class RetraceStringBuilder {
+
+    private final StringBuilder retracedString;
+    private int lastCommittedIndex;
+
+    private RetraceStringBuilder(String retracedString, int lastCommittedIndex) {
+      this.retracedString = new StringBuilder(retracedString);
+      this.lastCommittedIndex = lastCommittedIndex;
     }
 
-    public int getLineNumber() {
-      return lineNumber;
+    private void appendRetracedString(
+        String source, String stringToAppend, int originalFromIndex, int originalToIndex) {
+      retracedString.append(source, lastCommittedIndex, originalFromIndex);
+      retracedString.append(stringToAppend);
+      lastCommittedIndex = originalToIndex;
     }
 
-    public String getSource() {
-      return source;
+    private String build(String source) {
+      return retracedString.append(source, lastCommittedIndex, source.length()).toString();
+    }
+  }
+
+  private static class RetraceString {
+
+    private final RetraceStringBuilder builder;
+    private final RetraceStringContext context;
+
+    private RetraceString(RetraceStringBuilder builder, RetraceStringContext context) {
+      this.builder = builder;
+      this.context = context;
     }
 
-    static class RetraceStringBuilder {
+    private Element getClassContext() {
+      return context.classContext;
+    }
 
-      private Element classContext;
-      private ClassNameGroup classNameGroup;
-      private ClassReference qualifiedContext;
-      private RetraceMethodResult.Element methodContext;
-      private TypeReference typeOrReturnTypeContext;
-      private boolean hasTypeOrReturnTypeContext;
-      private String retracedString;
-      private int adjustedIndex;
-      private boolean isAmbiguous;
-      private int lineNumber;
-      private String source;
+    private RetraceMethodResult.Element getMethodContext() {
+      return context.methodContext;
+    }
 
-      private int maxReplaceStringIndex = NO_MATCH;
+    private String getSource() {
+      return context.source;
+    }
 
-      private RetraceStringBuilder(
-          Element classContext,
-          ClassNameGroup classNameGroup,
-          ClassReference qualifiedContext,
-          RetraceMethodResult.Element methodContext,
-          TypeReference typeOrReturnTypeContext,
-          boolean hasTypeOrReturnTypeContext,
-          String retracedString,
-          int adjustedIndex,
-          boolean isAmbiguous,
-          int lineNumber,
-          String source) {
-        this.classContext = classContext;
-        this.classNameGroup = classNameGroup;
-        this.qualifiedContext = qualifiedContext;
-        this.methodContext = methodContext;
-        this.typeOrReturnTypeContext = typeOrReturnTypeContext;
-        this.hasTypeOrReturnTypeContext = hasTypeOrReturnTypeContext;
-        this.retracedString = retracedString;
-        this.adjustedIndex = adjustedIndex;
-        this.isAmbiguous = isAmbiguous;
-        this.lineNumber = lineNumber;
-        this.source = source;
-      }
+    private int getLineNumber() {
+      return context.originalLineNumber;
+    }
 
-      static RetraceStringBuilder create(String string) {
-        return new RetraceStringBuilder(
-            null, null, null, null, null, false, string, 0, false, 0, "");
-      }
+    private boolean isAmbiguous() {
+      return context.isAmbiguous;
+    }
 
-      static RetraceStringBuilder create(RetraceString string) {
-        return new RetraceStringBuilder(
-            string.classContext,
-            string.classNameGroup,
-            string.qualifiedContext,
-            string.methodContext,
-            string.typeOrReturnTypeContext,
-            string.hasTypeOrReturnTypeContext,
-            string.retracedString,
-            string.adjustedIndex,
-            string.isAmbiguous,
-            string.lineNumber,
-            string.source);
-      }
+    private static RetraceString start(RetraceStringContext initialContext) {
+      return new RetraceString(new RetraceStringBuilder("", 0), initialContext);
+    }
 
-      RetraceStringBuilder setClassContext(Element classContext, ClassNameGroup classNameGroup) {
-        this.classContext = classContext;
-        this.classNameGroup = classNameGroup;
-        return this;
-      }
+    private RetraceString updateContext(
+        Function<RetraceStringContext, RetraceStringContext> update) {
+      return new RetraceString(builder, update.apply(context));
+    }
 
-      RetraceStringBuilder setMethodContext(RetraceMethodResult.Element methodContext) {
-        this.methodContext = methodContext;
-        return this;
-      }
+    private RetraceString duplicate(RetraceStringContext newContext) {
+      return new RetraceString(
+          new RetraceStringBuilder(builder.retracedString.toString(), builder.lastCommittedIndex),
+          newContext);
+    }
 
-      RetraceStringBuilder setTypeOrReturnTypeContext(TypeReference typeOrReturnTypeContext) {
-        hasTypeOrReturnTypeContext = true;
-        this.typeOrReturnTypeContext = typeOrReturnTypeContext;
-        return this;
-      }
-
-      RetraceStringBuilder setQualifiedContext(ClassReference qualifiedContext) {
-        this.qualifiedContext = qualifiedContext;
-        return this;
-      }
-
-      RetraceStringBuilder setAmbiguous(boolean isAmbiguous) {
-        this.isAmbiguous = isAmbiguous;
-        return this;
-      }
-
-      RetraceStringBuilder setLineNumber(int lineNumber) {
-        this.lineNumber = lineNumber;
-        return this;
-      }
-
-      RetraceStringBuilder setSource(String source) {
-        this.source = source;
-        return this;
-      }
-
-      RetraceStringBuilder replaceInString(String oldString, String newString) {
-        int oldStringStartIndex = retracedString.indexOf(oldString);
-        assert oldStringStartIndex > NO_MATCH;
-        int oldStringEndIndex = oldStringStartIndex + oldString.length();
-        return replaceInStringRaw(newString, oldStringStartIndex, oldStringEndIndex);
-      }
-
-      RetraceStringBuilder replaceInString(String newString, int originalFrom, int originalTo) {
-        return replaceInStringRaw(
-            newString, originalFrom + adjustedIndex, originalTo + adjustedIndex);
-      }
-
-      RetraceStringBuilder replaceInStringRaw(String newString, int from, int to) {
-        assert from <= to;
-        assert from > maxReplaceStringIndex;
-        String prefix = retracedString.substring(0, from);
-        String postFix = retracedString.substring(to);
-        this.retracedString = prefix + newString + postFix;
-        this.adjustedIndex = adjustedIndex + newString.length() - (to - from);
-        maxReplaceStringIndex = prefix.length() + newString.length();
-        return this;
-      }
-
-      RetraceString build() {
-        return new RetraceString(
-            classContext,
-            classNameGroup,
-            qualifiedContext,
-            methodContext,
-            typeOrReturnTypeContext,
-            hasTypeOrReturnTypeContext,
-            retracedString,
-            adjustedIndex,
-            isAmbiguous,
-            lineNumber,
-            source);
-      }
+    private RetraceString appendRetracedString(
+        String source, String stringToAppend, int originalFromIndex, int originalToIndex) {
+      builder.appendRetracedString(source, stringToAppend, originalFromIndex, originalToIndex);
+      return this;
     }
   }
 
   private interface RegularExpressionGroupHandler {
 
     List<RetraceString> handleMatch(
-        List<RetraceString> strings, Matcher matcher, RetraceBase retraceBase);
+        String original, List<RetraceString> strings, Matcher matcher, RetraceApi retracer);
+
+    default RetraceStringContext buildInitial(
+        RetraceStringContext context, Matcher matcher, RetraceApi retracer) {
+      return context;
+    }
+
+    default boolean isClassNameGroupHandler() {
+      return false;
+    }
+
+    default ClassNameGroupHandler asClassNameGroupHandler() {
+      return null;
+    }
+
+    default boolean isQualifiedHandler() {
+      return false;
+    }
+
+    default QualifiedRegularExpressionGroupHandler asQualifiedHandler() {
+      return null;
+    }
+  }
+
+  private interface QualifiedRegularExpressionGroupHandler extends RegularExpressionGroupHandler {
+
+    @Override
+    default boolean isQualifiedHandler() {
+      return true;
+    }
+
+    @Override
+    default QualifiedRegularExpressionGroupHandler asQualifiedHandler() {
+      return this;
+    }
+
+    void setClassNameGroupHandler(ClassNameGroupHandler handler);
   }
 
   private abstract static class RegularExpressionGroup {
 
-    abstract String shortName();
-
     abstract String subExpression();
 
     abstract RegularExpressionGroupHandler createHandler(String captureGroup);
+
+    boolean isSynthetic() {
+      return false;
+    }
   }
 
   // TODO(b/145731185): Extend support for identifiers with strings inside back ticks.
-  private static final String javaIdentifierSegment = "[\\p{L}\\p{N}_\\p{Sc}]+";
+  private static final String javaIdentifierSegment =
+      "\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*";
 
-  private abstract static class ClassNameGroup extends RegularExpressionGroup {
+  private static final String METHOD_NAME_REGULAR_EXPRESSION =
+      "(?:(" + javaIdentifierSegment + "|\\<init\\>|\\<clinit\\>))";
+
+  abstract static class ClassNameGroup extends RegularExpressionGroup {
 
     abstract String getClassName(ClassReference classReference);
 
@@ -400,41 +491,107 @@
 
     @Override
     RegularExpressionGroupHandler createHandler(String captureGroup) {
-      return (strings, matcher, retraceBase) -> {
-        if (matcher.start(captureGroup) == NO_MATCH) {
+      return new ClassNameGroupHandler(this, captureGroup);
+    }
+
+    static class ClassNameGroupHandler implements RegularExpressionGroupHandler {
+
+      private RetraceClassResult retraceClassResult = null;
+      private final ClassNameGroup classNameGroup;
+      private final String captureGroup;
+      private RegularExpressionGroupHandler qualifiedHandler;
+
+      public ClassNameGroupHandler(ClassNameGroup classNameGroup, String captureGroup) {
+        this.classNameGroup = classNameGroup;
+        this.captureGroup = captureGroup;
+      }
+
+      @Override
+      public List<RetraceString> handleMatch(
+          String original, List<RetraceString> strings, Matcher matcher, RetraceApi retracer) {
+        final int startOfGroup = matcher.start(captureGroup);
+        if (startOfGroup == NO_MATCH) {
           return strings;
         }
         String typeName = matcher.group(captureGroup);
-        RetraceClassResult retraceResult = retraceBase.retrace(classFromMatch(typeName));
-        List<RetraceString> retracedStrings = new ArrayList<>();
+        RetraceClassResult retraceResult =
+            retraceClassResult == null
+                ? retracer.retrace(classNameGroup.classFromMatch(typeName))
+                : retraceClassResult;
+        assert !retraceResult.isAmbiguous();
+        List<RetraceString> retraceStrings = new ArrayList<>(strings.size());
         for (RetraceString retraceString : strings) {
           retraceResult.forEach(
               element -> {
-                retracedStrings.add(
-                    retraceString
-                        .transform()
-                        .setClassContext(element, this)
-                        .setMethodContext(null)
-                        .replaceInString(
-                            getClassName(element.getClassReference()),
-                            matcher.start(captureGroup),
-                            matcher.end(captureGroup))
-                        .build());
+                final RetraceString newRetraceString =
+                    retraceString.updateContext(
+                        context -> context.withClassContext(element, element.getClassReference()));
+                retraceStrings.add(newRetraceString);
+                if (qualifiedHandler == null) {
+                  // If there is no qualified handler, commit right away.
+                  newRetraceString.builder.appendRetracedString(
+                      original,
+                      classNameGroup.getClassName(element.getClassReference()),
+                      startOfGroup,
+                      matcher.end(captureGroup));
+                }
               });
         }
-        return retracedStrings;
-      };
+        return retraceStrings;
+      }
+
+      void commitClassName(
+          String original,
+          RetraceString retraceString,
+          ClassReference qualifiedContext,
+          Matcher matcher) {
+        if (matcher.start(captureGroup) == NO_MATCH) {
+          return;
+        }
+        retraceString.builder.appendRetracedString(
+            original,
+            classNameGroup.getClassName(qualifiedContext),
+            matcher.start(captureGroup),
+            matcher.end(captureGroup));
+      }
+
+      @Override
+      public RetraceStringContext buildInitial(
+          RetraceStringContext context, Matcher matcher, RetraceApi retracer) {
+        // Reset the local class context since this the same handler is used for multiple lines.
+        retraceClassResult = null;
+        if (matcher.start(captureGroup) == NO_MATCH || context.classContext != null) {
+          return context;
+        }
+        String typeName = matcher.group(captureGroup);
+        retraceClassResult = retracer.retrace(classNameGroup.classFromMatch(typeName));
+        assert !retraceClassResult.isAmbiguous();
+        Box<RetraceStringContext> box = new Box<>();
+        retraceClassResult.forEach(
+            element -> box.set(context.withClassContext(element, element.getClassReference())));
+        return box.get();
+      }
+
+      public void setQualifiedHandler(RegularExpressionGroupHandler handler) {
+        assert handler.isQualifiedHandler();
+        this.qualifiedHandler = handler;
+      }
+
+      @Override
+      public boolean isClassNameGroupHandler() {
+        return true;
+      }
+
+      @Override
+      public ClassNameGroupHandler asClassNameGroupHandler() {
+        return this;
+      }
     }
   }
 
   private static class TypeNameGroup extends ClassNameGroup {
 
     @Override
-    String shortName() {
-      return "%c";
-    }
-
-    @Override
     String subExpression() {
       return "(" + javaIdentifierSegment + "\\.)*" + javaIdentifierSegment;
     }
@@ -453,11 +610,6 @@
   private static class BinaryNameGroup extends ClassNameGroup {
 
     @Override
-    String shortName() {
-      return "%C";
-    }
-
-    @Override
     String subExpression() {
       return "(?:" + javaIdentifierSegment + "\\/)*" + javaIdentifierSegment;
     }
@@ -475,78 +627,112 @@
 
   private static class MethodNameGroup extends RegularExpressionGroup {
 
-    @Override
-    String shortName() {
-      return "%m";
+    private final boolean printVerbose;
+
+    public MethodNameGroup(boolean printVerbose) {
+      this.printVerbose = printVerbose;
     }
 
     @Override
     String subExpression() {
-      return "(?:(" + javaIdentifierSegment + "|\\<init\\>|\\<clinit\\>))";
+      return METHOD_NAME_REGULAR_EXPRESSION;
     }
 
     @Override
     RegularExpressionGroupHandler createHandler(String captureGroup) {
-      return (strings, matcher, retraceBase) -> {
-        if (matcher.start(captureGroup) == NO_MATCH) {
-          return strings;
+      return new QualifiedRegularExpressionGroupHandler() {
+
+        private ClassNameGroupHandler classNameGroupHandler;
+
+        @Override
+        public void setClassNameGroupHandler(ClassNameGroupHandler handler) {
+          classNameGroupHandler = handler;
         }
-        String methodName = matcher.group(captureGroup);
-        List<RetraceString> retracedStrings = new ArrayList<>();
-        for (RetraceString retraceString : strings) {
-          if (retraceString.classContext == null) {
-            retracedStrings.add(retraceString);
-            continue;
+
+        @Override
+        public List<RetraceString> handleMatch(
+            String original, List<RetraceString> strings, Matcher matcher, RetraceApi retracer) {
+          final int startOfGroup = matcher.start(captureGroup);
+          if (startOfGroup == NO_MATCH) {
+            if (classNameGroupHandler != null) {
+              for (RetraceString string : strings) {
+                classNameGroupHandler.commitClassName(
+                    original, string, string.context.qualifiedContext, matcher);
+              }
+            }
+            return strings;
           }
-          retraceString
-              .getClassContext()
-              .lookupMethod(methodName)
-              .forEach(
-                  element -> {
-                    MethodReference methodReference = element.getMethodReference();
-                    if (retraceString.hasTypeOrReturnTypeContext()) {
-                      if (methodReference.getReturnType() == null
-                          && retraceString.getTypeOrReturnTypeContext() != null) {
-                        return;
-                      } else if (methodReference.getReturnType() != null
-                          && !methodReference
-                              .getReturnType()
-                              .equals(retraceString.getTypeOrReturnTypeContext())) {
-                        return;
-                      }
-                    }
-                    RetraceStringBuilder newRetraceString = retraceString.transform();
-                    ClassReference existingClass =
-                        retraceString.getClassContext().getClassReference();
-                    ClassReference holder = methodReference.getHolderClass();
-                    if (holder != existingClass) {
-                      // The element is defined on another holder.
-                      newRetraceString
-                          .replaceInString(
-                              newRetraceString.classNameGroup.getClassName(existingClass),
-                              newRetraceString.classNameGroup.getClassName(holder))
-                          .setQualifiedContext(holder);
-                    }
-                    newRetraceString
-                        .setMethodContext(element)
-                        .setAmbiguous(element.getRetraceMethodResult().isAmbiguous())
-                        .replaceInString(
-                            methodReference.getMethodName(),
-                            matcher.start(captureGroup),
-                            matcher.end(captureGroup));
-                    retracedStrings.add(newRetraceString.build());
-                  });
+          String methodName = matcher.group(captureGroup);
+          List<RetraceString> retracedStrings = new ArrayList<>();
+          for (RetraceString retraceString : strings) {
+            retraceMethodForString(
+                retraceString,
+                methodName,
+                (element, newContext) -> {
+                  final RetraceString newRetraceString = retraceString.duplicate(newContext);
+                  if (classNameGroupHandler != null) {
+                    classNameGroupHandler.commitClassName(
+                        original,
+                        newRetraceString,
+                        element.getMethodReference().getHolderClass(),
+                        matcher);
+                  }
+                  retracedStrings.add(
+                      newRetraceString.appendRetracedString(
+                          original,
+                          printVerbose
+                              ? RetraceUtils.methodDescriptionFromMethodReference(
+                                  element.getMethodReference(), false, true)
+                              : element.getMethodReference().getMethodName(),
+                          startOfGroup,
+                          matcher.end(captureGroup)));
+                });
+          }
+          return retracedStrings;
         }
-        return retracedStrings;
+
+        @Override
+        public RetraceStringContext buildInitial(
+            RetraceStringContext context, Matcher matcher, RetraceApi retracer) {
+          final int startOfGroup = matcher.start(captureGroup);
+          if (startOfGroup == NO_MATCH || context.methodName != null) {
+            return context;
+          }
+          return context.withMethodName(matcher.group(captureGroup));
+        }
       };
     }
+
+    private static void retraceMethodForString(
+        RetraceString retraceString,
+        String methodName,
+        BiConsumer<RetraceMethodResult.Element, RetraceStringContext> process) {
+      if (retraceString.context.classContext == null) {
+        return;
+      }
+      RetraceMethodResult retraceMethodResult =
+          retraceString.getClassContext().lookupMethod(methodName);
+      if (retraceString.context.minifiedLineNumber > NO_MATCH) {
+        retraceMethodResult =
+            retraceMethodResult.narrowByLine(retraceString.context.minifiedLineNumber);
+      }
+      retraceMethodResult.forEach(
+          element ->
+              process.accept(
+                  element,
+                  retraceString.context.withMethodContext(
+                      element,
+                      element.getMethodReference().getHolderClass(),
+                      element.getRetraceMethodResult().isAmbiguous())));
+    }
   }
 
   private static class FieldNameGroup extends RegularExpressionGroup {
 
-    @Override
-    String shortName() {
-      return "%f";
+    private final boolean printVerbose;
+
+    public FieldNameGroup(boolean printVerbose) {
+      this.printVerbose = printVerbose;
     }
 
     @Override
@@ -556,86 +742,112 @@
 
     @Override
     RegularExpressionGroupHandler createHandler(String captureGroup) {
-      return (strings, matcher, retraceBase) -> {
-        if (matcher.start(captureGroup) == NO_MATCH) {
-          return strings;
+      return new QualifiedRegularExpressionGroupHandler() {
+
+        private ClassNameGroupHandler classNameGroupHandler;
+
+        @Override
+        public void setClassNameGroupHandler(ClassNameGroupHandler handler) {
+          classNameGroupHandler = handler;
         }
-        String methodName = matcher.group(captureGroup);
-        List<RetraceString> retracedStrings = new ArrayList<>();
-        for (RetraceString retraceString : strings) {
-          if (retraceString.getClassContext() == null) {
-            retracedStrings.add(retraceString);
-            continue;
+
+        @Override
+        public List<RetraceString> handleMatch(
+            String original, List<RetraceString> strings, Matcher matcher, RetraceApi retracer) {
+          final int startOfGroup = matcher.start(captureGroup);
+          if (startOfGroup == NO_MATCH) {
+            if (classNameGroupHandler != null) {
+              for (RetraceString string : strings) {
+                classNameGroupHandler.commitClassName(
+                    original, string, string.context.qualifiedContext, matcher);
+              }
+            }
+            return strings;
           }
-          retraceString
-              .getClassContext()
-              .lookupField(methodName)
-              .forEach(
-                  element -> {
-                    RetraceStringBuilder newRetraceString = retraceString.transform();
-                    ClassReference existingClass =
-                        retraceString.getClassContext().getClassReference();
-                    ClassReference holder = element.getFieldReference().getHolderClass();
-                    if (holder != existingClass) {
-                      // The element is defined on another holder.
-                      newRetraceString
-                          .replaceInString(
-                              newRetraceString.classNameGroup.getClassName(existingClass),
-                              newRetraceString.classNameGroup.getClassName(holder))
-                          .setQualifiedContext(holder);
-                    }
-                    newRetraceString.replaceInString(
-                        element.getFieldReference().getFieldName(),
-                        matcher.start(captureGroup),
-                        matcher.end(captureGroup));
-                    retracedStrings.add(newRetraceString.build());
-                  });
+          String methodName = matcher.group(captureGroup);
+          List<RetraceString> retracedStrings = new ArrayList<>();
+          for (RetraceString retraceString : strings) {
+            if (retraceString.getClassContext() == null) {
+              assert classNameGroupHandler == null;
+              return strings;
+            }
+            final RetraceFieldResult retraceFieldResult =
+                retraceString.getClassContext().lookupField(methodName);
+            assert !retraceFieldResult.isAmbiguous();
+            retraceFieldResult.forEach(
+                element -> {
+                  if (classNameGroupHandler != null) {
+                    classNameGroupHandler.commitClassName(
+                        original,
+                        retraceString,
+                        element.getFieldReference().getHolderClass(),
+                        matcher);
+                  }
+                  retracedStrings.add(
+                      retraceString
+                          .updateContext(
+                              context ->
+                                  context.withQualifiedContext(
+                                      element.getFieldReference().getHolderClass()))
+                          .appendRetracedString(
+                              original,
+                              getFieldString(element.getFieldReference()),
+                              startOfGroup,
+                              matcher.end(captureGroup)));
+                });
+          }
+          return retracedStrings;
         }
-        return retracedStrings;
       };
     }
+
+    private String getFieldString(FieldReference fieldReference) {
+      if (!printVerbose) {
+        return fieldReference.getFieldName();
+      }
+      return fieldReference.getFieldType().getTypeName() + " " + fieldReference.getFieldName();
+    }
   }
 
   private static class SourceFileGroup extends RegularExpressionGroup {
 
     @Override
-    String shortName() {
-      return "%s";
-    }
-
-    @Override
     String subExpression() {
       return "(?:(\\w*[\\. ])?(\\w*)?)";
     }
 
     @Override
     RegularExpressionGroupHandler createHandler(String captureGroup) {
-      return (strings, matcher, retraceBase) -> {
-        if (matcher.start(captureGroup) == NO_MATCH) {
+      return (original, strings, matcher, retracer) -> {
+        final int startOfGroup = matcher.start(captureGroup);
+        if (startOfGroup == NO_MATCH) {
           return strings;
         }
         String fileName = matcher.group(captureGroup);
-        List<RetraceString> retracedStrings = new ArrayList<>();
+        List<RetraceString> retracedStrings = null;
         for (RetraceString retraceString : strings) {
-          if (retraceString.classContext == null) {
-            retracedStrings.add(retraceString);
-            continue;
+          if (retraceString.context.classContext == null) {
+            return strings;
           }
-          String newSourceFile =
-              retraceString.getQualifiedContext() != null
-                  ? retraceBase.retraceSourceFile(
-                      retraceString.classContext.getClassReference(),
+          if (retracedStrings == null) {
+            retracedStrings = new ArrayList<>();
+          }
+          RetraceSourceFileResult sourceFileResult =
+              retraceString.getMethodContext() != null
+                  ? retraceString.getMethodContext().retraceSourceFile(fileName)
+                  : RetraceUtils.getSourceFile(
+                      retraceString.getClassContext(),
+                      retraceString.context.qualifiedContext,
                       fileName,
-                      retraceString.getQualifiedContext(),
-                      true)
-                  : retraceString.classContext.retraceSourceFile(fileName, retraceBase);
+                      retracer);
           retracedStrings.add(
               retraceString
-                  .transform()
-                  .setSource(fileName)
-                  .replaceInString(
-                      newSourceFile, matcher.start(captureGroup), matcher.end(captureGroup))
-                  .build());
+                  .updateContext(context -> context.withSource(sourceFileResult.getFilename()))
+                  .appendRetracedString(
+                      original,
+                      sourceFileResult.getFilename(),
+                      startOfGroup,
+                      matcher.end(captureGroup)));
         }
         return retracedStrings;
       };
@@ -645,97 +857,133 @@
   private class LineNumberGroup extends RegularExpressionGroup {
 
     @Override
-    String shortName() {
-      return "%l";
-    }
-
-    @Override
     String subExpression() {
       return "\\d*";
     }
 
     @Override
     RegularExpressionGroupHandler createHandler(String captureGroup) {
-      return (strings, matcher, retraceBase) -> {
-        if (matcher.start(captureGroup) == NO_MATCH) {
-          return strings;
+      return new RegularExpressionGroupHandler() {
+        @Override
+        public List<RetraceString> handleMatch(
+            String original, List<RetraceString> strings, Matcher matcher, RetraceApi retracer) {
+          final int startOfGroup = matcher.start(captureGroup);
+          if (startOfGroup == NO_MATCH) {
+            return strings;
+          }
+          String lineNumberAsString = matcher.group(captureGroup);
+          if (lineNumberAsString.isEmpty()) {
+            return strings;
+          }
+          int lineNumber = Integer.parseInt(lineNumberAsString);
+          List<RetraceString> retracedStrings = new ArrayList<>();
+          for (RetraceString retraceString : strings) {
+            RetraceMethodResult.Element methodContext = retraceString.context.methodContext;
+            if (methodContext == null) {
+              if (retraceString.context.classContext == null
+                  || retraceString.context.methodName == null) {
+                // We have no way of retracing the line number.
+                retracedStrings.add(retraceString);
+                continue;
+              }
+              // This situation arises when we have a matched pattern as %l..%c.%m where the
+              // line number handler is defined before the methodname handler.
+              MethodNameGroup.retraceMethodForString(
+                  retraceString,
+                  retraceString.context.methodName,
+                  (element, newContext) -> {
+                    // The same method can be represented multiple times if it has multiple
+                    // mappings.
+                    if (element.hasNoLineNumberRange()
+                        || !element.containsMinifiedLineNumber(lineNumber)) {
+                      diagnosticsHandler.info(
+                          new StringDiagnostic(
+                              "Pruning "
+                                  + retraceString.builder.retracedString.toString()
+                                  + " from result because method is not in range on line number "
+                                  + lineNumber));
+                    }
+                    final int originalLineNumber = element.getOriginalLineNumber(lineNumber);
+                    retracedStrings.add(
+                        retraceString
+                            .updateContext(
+                                context -> context.withLineNumbers(lineNumber, originalLineNumber))
+                            .appendRetracedString(
+                                original,
+                                originalLineNumber + "",
+                                startOfGroup,
+                                matcher.end(captureGroup)));
+                  });
+              continue;
+            }
+            // If the method context is unknown, do nothing.
+            if (methodContext.getMethodReference().isUnknown()
+                || methodContext.hasNoLineNumberRange()) {
+              retracedStrings.add(retraceString);
+              continue;
+            }
+            int originalLineNumber = methodContext.getOriginalLineNumber(lineNumber);
+            retracedStrings.add(
+                retraceString
+                    .updateContext(
+                        context -> context.withLineNumbers(lineNumber, originalLineNumber))
+                    .appendRetracedString(
+                        original,
+                        originalLineNumber + "",
+                        startOfGroup,
+                        matcher.end(captureGroup)));
+          }
+          return retracedStrings;
         }
-        String lineNumberAsString = matcher.group(captureGroup);
-        int lineNumber =
-            lineNumberAsString.isEmpty() ? NO_MATCH : Integer.parseInt(lineNumberAsString);
-        List<RetraceString> retracedStrings = new ArrayList<>();
-        boolean seenRange = false;
-        for (RetraceString retraceString : strings) {
-          RetraceMethodResult.Element methodContext = retraceString.methodContext;
-          if (methodContext == null || methodContext.getMethodReference().isUnknown()) {
-            retracedStrings.add(retraceString);
-            continue;
+
+        @Override
+        public RetraceStringContext buildInitial(
+            RetraceStringContext context, Matcher matcher, RetraceApi retracer) {
+          if (matcher.start(captureGroup) == NO_MATCH || context.minifiedLineNumber > NO_MATCH) {
+            return context;
           }
-          if (methodContext.hasNoLineNumberRange()) {
-            continue;
-          }
-          seenRange = true;
-          Set<MethodReference> narrowedSet =
-              methodContext.getRetraceMethodResult().narrowByLine(lineNumber).stream()
-                  .map(RetraceMethodResult.Element::getMethodReference)
-                  .collect(Collectors.toSet());
-          if (!narrowedSet.contains(methodContext.getMethodReference())) {
-            // Prune the retraceString since we now have line number information and this is not
-            // a part of the result.
-            diagnosticsHandler.info(
-                new StringDiagnostic(
-                    "Pruning "
-                        + retraceString.getRetracedString()
-                        + " from result because method is not defined on line number "
-                        + lineNumber));
-            continue;
-          }
-          // The same method can be represented multiple times if it has multiple mappings.
-          if (!methodContext.containsMinifiedLineNumber(lineNumber)) {
-            diagnosticsHandler.info(
-                new StringDiagnostic(
-                    "Pruning "
-                        + retraceString.getRetracedString()
-                        + " from result because method is not in range on line number "
-                        + lineNumber));
-            continue;
-          }
-          int originalLineNumber = methodContext.getOriginalLineNumber(lineNumber);
-          retracedStrings.add(
-              retraceString
-                  .transform()
-                  .setAmbiguous(false)
-                  .setLineNumber(originalLineNumber)
-                  .replaceInString(
-                      originalLineNumber + "",
-                      matcher.start(captureGroup),
-                      matcher.end(captureGroup))
-                  .build());
+          String lineNumberAsString = matcher.group(captureGroup);
+          return context.withLineNumbers(
+              lineNumberAsString.isEmpty() ? NO_MATCH : Integer.parseInt(lineNumberAsString),
+              NO_MATCH);
         }
-        return seenRange ? retracedStrings : strings;
       };
     }
   }
 
+  private static class SourceFileLineNumberGroup extends RegularExpressionGroup {
+
+    @Override
+    String subExpression() {
+      return "%s(?::%l)?";
+    }
+
+    @Override
+    RegularExpressionGroupHandler createHandler(String captureGroup) {
+      throw new Unreachable("Should never be called");
+    }
+
+    @Override
+    boolean isSynthetic() {
+      return true;
+    }
+  }
+
   private static final String JAVA_TYPE_REGULAR_EXPRESSION =
       "(" + javaIdentifierSegment + "\\.)*" + javaIdentifierSegment + "[\\[\\]]*";
 
   private static class FieldOrReturnTypeGroup extends RegularExpressionGroup {
 
     @Override
-    String shortName() {
-      return "%t";
-    }
-
-    @Override
     String subExpression() {
       return JAVA_TYPE_REGULAR_EXPRESSION;
     }
 
     @Override
     RegularExpressionGroupHandler createHandler(String captureGroup) {
-      return (strings, matcher, retraceBase) -> {
-        if (matcher.start(captureGroup) == NO_MATCH) {
+      return (original, strings, matcher, retracer) -> {
+        final int startOfGroup = matcher.start(captureGroup);
+        if (startOfGroup == NO_MATCH) {
           return strings;
         }
         String typeName = matcher.group(captureGroup);
@@ -744,34 +992,25 @@
           return strings;
         }
         TypeReference typeReference = Reference.returnTypeFromDescriptor(descriptor);
-        List<RetraceString> retracedStrings = new ArrayList<>();
-        RetraceTypeResult retracedType = retraceBase.retrace(typeReference);
+        RetraceTypeResult retracedType = retracer.retrace(typeReference);
+        assert !retracedType.isAmbiguous();
         for (RetraceString retraceString : strings) {
           retracedType.forEach(
               element -> {
                 TypeReference retracedReference = element.getTypeReference();
-                retracedStrings.add(
-                    retraceString
-                        .transform()
-                        .setTypeOrReturnTypeContext(retracedReference)
-                        .replaceInString(
-                            retracedReference == null ? "void" : retracedReference.getTypeName(),
-                            matcher.start(captureGroup),
-                            matcher.end(captureGroup))
-                        .build());
+                retraceString.appendRetracedString(
+                    original,
+                    retracedReference == null ? "void" : retracedReference.getTypeName(),
+                    startOfGroup,
+                    matcher.end(captureGroup));
               });
         }
-        return retracedStrings;
+        return strings;
       };
     }
   }
 
-  private class MethodArgumentsGroup extends RegularExpressionGroup {
-
-    @Override
-    String shortName() {
-      return "%a";
-    }
+  private static class MethodArgumentsGroup extends RegularExpressionGroup {
 
     @Override
     String subExpression() {
@@ -780,74 +1019,36 @@
 
     @Override
     RegularExpressionGroupHandler createHandler(String captureGroup) {
-      return (strings, matcher, retraceBase) -> {
-        if (matcher.start(captureGroup) == NO_MATCH) {
+      return (original, strings, matcher, retracer) -> {
+        final int startOfGroup = matcher.start(captureGroup);
+        if (startOfGroup == NO_MATCH) {
           return strings;
         }
-        Set<List<TypeReference>> initialValue = new LinkedHashSet<>();
-        initialValue.add(new ArrayList<>());
-        Set<List<TypeReference>> allRetracedReferences =
+        final String formals =
             Arrays.stream(matcher.group(captureGroup).split(","))
-                .map(String::trim)
-                .reduce(
-                    initialValue,
-                    (acc, typeName) -> {
+                .map(
+                    typeName -> {
+                      typeName = typeName.trim();
+                      if (typeName.isEmpty()) {
+                        return null;
+                      }
                       String descriptor = DescriptorUtils.javaTypeToDescriptor(typeName);
                       if (!DescriptorUtils.isDescriptor(descriptor) && !"V".equals(descriptor)) {
-                        return acc;
+                        return typeName;
                       }
-                      TypeReference typeReference = Reference.returnTypeFromDescriptor(descriptor);
-                      Set<List<TypeReference>> retracedTypes = new LinkedHashSet<>();
-                      retraceBase
-                          .retrace(typeReference)
-                          .forEach(
-                              element -> {
-                                for (List<TypeReference> currentReferences : acc) {
-                                  ArrayList<TypeReference> newList =
-                                      new ArrayList<>(currentReferences);
-                                  newList.add(element.getTypeReference());
-                                  retracedTypes.add(newList);
-                                }
-                              });
-                      return retracedTypes;
-                    },
-                    (l1, l2) -> {
-                      l1.addAll(l2);
-                      return l1;
-                    });
-        List<RetraceString> retracedStrings = new ArrayList<>();
-        for (RetraceString retraceString : strings) {
-          if (retraceString.getMethodContext() != null
-              && !allRetracedReferences.contains(
-                  retraceString.getMethodContext().getMethodReference().getFormalTypes())) {
-            // Prune the string since we now know the formals.
-            String formals =
-                retraceString.getMethodContext().getMethodReference().getFormalTypes().stream()
-                    .map(TypeReference::getTypeName)
-                    .collect(Collectors.joining(","));
-            diagnosticsHandler.info(
-                new StringDiagnostic(
-                    "Pruning "
-                        + retraceString.getRetracedString()
-                        + " from result because formals ("
-                        + formals
-                        + ") do not match result set."));
-            continue;
-          }
-          for (List<TypeReference> retracedReferences : allRetracedReferences) {
-            retracedStrings.add(
-                retraceString
-                    .transform()
-                    .replaceInString(
-                        retracedReferences.stream()
-                            .map(TypeReference::getTypeName)
-                            .collect(Collectors.joining(",")),
-                        matcher.start(captureGroup),
-                        matcher.end(captureGroup))
-                    .build());
-          }
+                      final RetraceTypeResult retraceResult =
+                          retracer.retrace(Reference.returnTypeFromDescriptor(descriptor));
+                      assert !retraceResult.isAmbiguous();
+                      final Box<TypeReference> elementBox = new Box<>();
+                      retraceResult.forEach(element -> elementBox.set(element.getTypeReference()));
+                      return elementBox.get().getTypeName();
+                    })
+                .filter(Objects::nonNull)
+                .collect(Collectors.joining(","));
+        for (RetraceString string : strings) {
+          string.appendRetracedString(original, formals, startOfGroup, matcher.end(captureGroup));
         }
-        return retracedStrings;
+        return strings;
       };
     }
   }
diff --git a/src/main/java/com/android/tools/r8/retrace/RetraceSourceFileResult.java b/src/main/java/com/android/tools/r8/retrace/RetraceSourceFileResult.java
new file mode 100644
index 0000000..4b21be1
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/retrace/RetraceSourceFileResult.java
@@ -0,0 +1,27 @@
+// Copyright (c) 2020, 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.retrace;
+
+import com.android.tools.r8.Keep;
+
+@Keep
+public class RetraceSourceFileResult {
+
+  private final String filename;
+  private final boolean synthesized;
+
+  RetraceSourceFileResult(String filename, boolean synthesized) {
+    this.filename = filename;
+    this.synthesized = synthesized;
+  }
+
+  public String getFilename() {
+    return filename;
+  }
+
+  public boolean isSynthesized() {
+    return synthesized;
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/retrace/RetraceStackTrace.java b/src/main/java/com/android/tools/r8/retrace/RetraceStackTrace.java
index c63a707..fd28127 100644
--- a/src/main/java/com/android/tools/r8/retrace/RetraceStackTrace.java
+++ b/src/main/java/com/android/tools/r8/retrace/RetraceStackTrace.java
@@ -86,17 +86,17 @@
     }
   }
 
-  private final RetraceBase retraceBase;
+  private final RetraceApi retracer;
   private final List<String> stackTrace;
   private final DiagnosticsHandler diagnosticsHandler;
   private final boolean verbose;
 
   RetraceStackTrace(
-      RetraceBase retraceBase,
+      RetraceApi retracer,
       List<String> stackTrace,
       DiagnosticsHandler diagnosticsHandler,
       boolean verbose) {
-    this.retraceBase = retraceBase;
+    this.retracer = retracer;
     this.stackTrace = stackTrace;
     this.diagnosticsHandler = diagnosticsHandler;
     this.verbose = verbose;
@@ -117,7 +117,7 @@
       return;
     }
     StackTraceLine stackTraceLine = parseLine(index + 1, stackTrace.get(index));
-    List<StackTraceLine> retraced = stackTraceLine.retrace(retraceBase, verbose);
+    List<StackTraceLine> retraced = stackTraceLine.retrace(retracer, verbose);
     StackTraceNode node = new StackTraceNode(retraced);
     result.add(node);
     retraceLine(stackTrace, index + 1, result);
@@ -125,7 +125,7 @@
 
   abstract static class StackTraceLine {
 
-    abstract List<StackTraceLine> retrace(RetraceBase retraceBase, boolean verbose);
+    abstract List<StackTraceLine> retrace(RetraceApi retracer, boolean verbose);
 
     static int firstNonWhiteSpaceCharacterFromIndex(String line, int index) {
       return firstFromIndex(line, index, not(Character::isWhitespace));
@@ -225,9 +225,9 @@
     }
 
     @Override
-    List<StackTraceLine> retrace(RetraceBase retraceBase, boolean verbose) {
+    List<StackTraceLine> retrace(RetraceApi retracer, boolean verbose) {
       List<StackTraceLine> exceptionLines = new ArrayList<>();
-      retraceBase
+      retracer
           .retrace(Reference.classFromTypeName(exceptionClass))
           .forEach(
               element ->
@@ -397,31 +397,29 @@
     }
 
     @Override
-    List<StackTraceLine> retrace(RetraceBase retraceBase, boolean verbose) {
+    List<StackTraceLine> retrace(RetraceApi retracer, boolean verbose) {
       List<StackTraceLine> lines = new ArrayList<>();
       String retraceClassLoaderName = classLoaderName;
       if (retraceClassLoaderName != null) {
         ClassReference classLoaderReference = Reference.classFromTypeName(retraceClassLoaderName);
-        retraceBase
+        retracer
             .retrace(classLoaderReference)
             .forEach(
                 classElement -> {
                   retraceClassAndMethods(
-                      retraceBase, verbose, lines, classElement.getClassReference().getTypeName());
+                      retracer, verbose, lines, classElement.getClassReference().getTypeName());
                 });
       } else {
-        retraceClassAndMethods(retraceBase, verbose, lines, retraceClassLoaderName);
+        retraceClassAndMethods(retracer, verbose, lines, retraceClassLoaderName);
       }
       return lines;
     }
 
     private void retraceClassAndMethods(
-        RetraceBase retraceBase,
-        boolean verbose,
-        List<StackTraceLine> lines,
-        String classLoaderName) {
+        RetraceApi retracer, boolean verbose, List<StackTraceLine> lines, String classLoaderName) {
       ClassReference classReference = Reference.classFromTypeName(clazz);
-      RetraceMethodResult retraceResult = retraceBase.retrace(classReference).lookupMethod(method);
+      RetraceClassResult classResult = retracer.retrace(classReference);
+      RetraceMethodResult retraceResult = classResult.lookupMethod(method);
       if (linePosition != NO_POSITION && linePosition != INVALID_POSITION) {
         retraceResult = retraceResult.narrowByLine(linePosition);
       }
@@ -436,9 +434,8 @@
                     moduleName,
                     methodReference.getHolderClass().getTypeName(),
                     methodReference.getMethodName(),
-                    methodDescriptionFromMethodReference(methodReference, verbose),
-                    retraceBase.retraceSourceFile(
-                        classReference, fileName, methodReference.getHolderClass(), true),
+                    methodDescriptionFromMethodReference(methodReference, true, verbose),
+                    methodElement.retraceSourceFile(fileName).getFilename(),
                     hasLinePosition()
                         ? methodElement.getOriginalLineNumber(linePosition)
                         : linePosition,
@@ -509,7 +506,7 @@
     }
 
     @Override
-    List<StackTraceLine> retrace(RetraceBase retraceBase, boolean verbose) {
+    List<StackTraceLine> retrace(RetraceApi retracer, boolean verbose) {
       return ImmutableList.of(new MoreLine(line));
     }
 
@@ -562,9 +559,9 @@
     }
 
     @Override
-    List<StackTraceLine> retrace(RetraceBase retraceBase, boolean verbose) {
+    List<StackTraceLine> retrace(RetraceApi retracer, boolean verbose) {
       List<StackTraceLine> exceptionLines = new ArrayList<>();
-      retraceBase
+      retracer
           .retrace(Reference.classFromTypeName(exceptionClass))
           .forEach(
               element ->
@@ -590,7 +587,7 @@
     }
 
     @Override
-    List<StackTraceLine> retrace(RetraceBase retraceBase, boolean verbose) {
+    List<StackTraceLine> retrace(RetraceApi retracer, boolean verbose) {
       return ImmutableList.of(new UnknownLine(line));
     }
 
diff --git a/src/main/java/com/android/tools/r8/retrace/RetraceTypeResult.java b/src/main/java/com/android/tools/r8/retrace/RetraceTypeResult.java
index 2ab72a7..b70602d 100644
--- a/src/main/java/com/android/tools/r8/retrace/RetraceTypeResult.java
+++ b/src/main/java/com/android/tools/r8/retrace/RetraceTypeResult.java
@@ -13,11 +13,11 @@
 public class RetraceTypeResult extends Result<Element, RetraceTypeResult> {
 
   private final TypeReference obfuscatedType;
-  private final RetraceBase retraceBase;
+  private final RetraceApi retracer;
 
-  RetraceTypeResult(TypeReference obfuscatedType, RetraceBase retraceBase) {
+  RetraceTypeResult(TypeReference obfuscatedType, RetraceApi retracer) {
     this.obfuscatedType = obfuscatedType;
-    this.retraceBase = retraceBase;
+    this.retracer = retracer;
   }
 
   @Override
@@ -28,13 +28,17 @@
     }
     if (obfuscatedType.isArray()) {
       int dimensions = obfuscatedType.asArray().getDimensions();
-      return retraceBase.retrace(obfuscatedType.asArray().getBaseType()).stream()
+      return retracer.retrace(obfuscatedType.asArray().getBaseType()).stream()
           .map(base -> new Element(Reference.array(base.getTypeReference(), dimensions)));
     }
-    return retraceBase.retrace(obfuscatedType.asClass()).stream()
+    return retracer.retrace(obfuscatedType.asClass()).stream()
         .map(clazz -> new Element(clazz.getClassReference()));
   }
 
+  public boolean isAmbiguous() {
+    return false;
+  }
+
   @Override
   public RetraceTypeResult forEach(Consumer<Element> resultConsumer) {
     stream().forEach(resultConsumer);
diff --git a/src/main/java/com/android/tools/r8/retrace/RetraceUtils.java b/src/main/java/com/android/tools/r8/retrace/RetraceUtils.java
index 81c2272..77aff7d 100644
--- a/src/main/java/com/android/tools/r8/retrace/RetraceUtils.java
+++ b/src/main/java/com/android/tools/r8/retrace/RetraceUtils.java
@@ -4,24 +4,34 @@
 
 package com.android.tools.r8.retrace;
 
+import com.android.tools.r8.references.ClassReference;
 import com.android.tools.r8.references.MethodReference;
 import com.android.tools.r8.references.TypeReference;
+import com.android.tools.r8.utils.Box;
+import com.google.common.collect.Sets;
+import com.google.common.io.Files;
+import java.util.Set;
 
 public class RetraceUtils {
 
+  private static final Set<String> UNKNOWN_SOURCEFILE_NAMES =
+      Sets.newHashSet("", "SourceFile", "Unknown", "Unknown Source", "PG");
+
   public static String methodDescriptionFromMethodReference(
-      MethodReference methodReference, boolean verbose) {
+      MethodReference methodReference, boolean appendHolder, boolean verbose) {
     if (!verbose || methodReference.isUnknown()) {
       return methodReference.getHolderClass().getTypeName() + "." + methodReference.getMethodName();
     }
     StringBuilder sb = new StringBuilder();
+    if (appendHolder) {
+      sb.append(methodReference.getHolderClass().getTypeName());
+      sb.append(".");
+    }
     sb.append(
         methodReference.getReturnType() == null
             ? "void"
             : methodReference.getReturnType().getTypeName());
     sb.append(" ");
-    sb.append(methodReference.getHolderClass().getTypeName());
-    sb.append(".");
     sb.append(methodReference.getMethodName());
     sb.append("(");
     boolean seenFirstIndex = false;
@@ -35,4 +45,76 @@
     sb.append(")");
     return sb.toString();
   }
+
+  public static boolean hasPredictableSourceFileName(String originalClassName, String sourceFile) {
+    String synthesizedSourceFileName = getClassSimpleName(originalClassName) + ".java";
+    return synthesizedSourceFileName.equals(sourceFile);
+  }
+
+  private static String getClassSimpleName(String clazz) {
+    int lastIndexOfPeriod = clazz.lastIndexOf('.');
+    // Check if we can find a subclass separator.
+    int endIndex = clazz.lastIndexOf('$');
+    if (lastIndexOfPeriod > endIndex || endIndex < 0) {
+      endIndex = clazz.length();
+    }
+    return clazz.substring(lastIndexOfPeriod + 1, endIndex);
+  }
+
+  static RetraceSourceFileResult getSourceFile(
+      RetraceClassResult.Element classElement,
+      ClassReference context,
+      String sourceFile,
+      RetraceApi retracer) {
+    // If no context is specified always retrace using the found class element.
+    if (context == null) {
+      return classElement.retraceSourceFile(sourceFile);
+    }
+    if (context.equals(classElement.getClassReference())) {
+      return classElement.retraceSourceFile(sourceFile);
+    } else {
+      RetraceClassResult contextClassResult = retracer.retrace(context);
+      assert !contextClassResult.isAmbiguous();
+      if (contextClassResult.hasRetraceResult()) {
+        Box<RetraceSourceFileResult> retraceSourceFile = new Box<>();
+        contextClassResult.forEach(
+            element -> retraceSourceFile.set(element.retraceSourceFile(sourceFile)));
+        return retraceSourceFile.get();
+      } else {
+        return new RetraceSourceFileResult(
+            synthesizeFileName(
+                context.getTypeName(),
+                classElement.getClassReference().getTypeName(),
+                sourceFile,
+                true),
+            true);
+      }
+    }
+  }
+
+  public static String synthesizeFileName(
+      String retracedClassName,
+      String minifiedClassName,
+      String sourceFile,
+      boolean hasRetraceResult) {
+    boolean fileNameProbablyChanged =
+        hasRetraceResult && !retracedClassName.startsWith(minifiedClassName);
+    if (!UNKNOWN_SOURCEFILE_NAMES.contains(sourceFile) && !fileNameProbablyChanged) {
+      // We have no new information, only rewrite filename if it is unknown.
+      // PG-retrace will always rewrite the filename, but that seems a bit to harsh to do.
+      return sourceFile;
+    }
+    String extension = Files.getFileExtension(sourceFile);
+    if (extension.isEmpty()) {
+      extension = "java";
+    }
+    if (!hasRetraceResult) {
+      // We have no mapping but but file name is unknown, so the best we can do is take the
+      // name of the obfuscated clazz.
+      assert minifiedClassName.equals(retracedClassName);
+      return getClassSimpleName(minifiedClassName) + "." + extension;
+    }
+    String newFileName = getClassSimpleName(retracedClassName);
+    return newFileName + "." + extension;
+  }
 }
diff --git a/src/main/java/com/android/tools/r8/retrace/Retracer.java b/src/main/java/com/android/tools/r8/retrace/Retracer.java
new file mode 100644
index 0000000..0f7d547
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/retrace/Retracer.java
@@ -0,0 +1,48 @@
+// 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.retrace;
+
+import com.android.tools.r8.Keep;
+import com.android.tools.r8.naming.ClassNameMapper;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.references.FieldReference;
+import com.android.tools.r8.references.MethodReference;
+import com.android.tools.r8.references.TypeReference;
+
+/** A default implementation for the retrace api using the ClassNameMapper defined in R8. */
+@Keep
+public class Retracer implements RetraceApi {
+
+  private final ClassNameMapper classNameMapper;
+
+  private Retracer(ClassNameMapper classNameMapper) {
+    this.classNameMapper = classNameMapper;
+  }
+
+  public static RetraceApi create(ClassNameMapper classNameMapper) {
+    return new Retracer(classNameMapper);
+  }
+
+  @Override
+  public RetraceMethodResult retrace(MethodReference methodReference) {
+    return retrace(methodReference.getHolderClass()).lookupMethod(methodReference.getMethodName());
+  }
+
+  @Override
+  public RetraceFieldResult retrace(FieldReference fieldReference) {
+    return retrace(fieldReference.getHolderClass()).lookupField(fieldReference.getFieldName());
+  }
+
+  @Override
+  public RetraceClassResult retrace(ClassReference classReference) {
+    return RetraceClassResult.create(
+        classReference, classNameMapper.getClassNaming(classReference.getTypeName()), this);
+  }
+
+  @Override
+  public RetraceTypeResult retrace(TypeReference typeReference) {
+    return new RetraceTypeResult(typeReference, this);
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/retrace/DuplicateMappingsTest.java b/src/test/java/com/android/tools/r8/retrace/DuplicateMappingsTest.java
new file mode 100644
index 0000000..bbe2d5b
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/retrace/DuplicateMappingsTest.java
@@ -0,0 +1,64 @@
+// Copyright (c) 2020, 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.retrace;
+
+import static org.hamcrest.CoreMatchers.allOf;
+import static org.hamcrest.CoreMatchers.containsString;
+
+import com.android.tools.r8.DiagnosticsMatcher;
+import com.android.tools.r8.PositionMatcher;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestDiagnosticMessagesImpl;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.StringUtils;
+import com.google.common.collect.ImmutableList;
+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 DuplicateMappingsTest extends TestBase {
+
+  private final TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  public DuplicateMappingsTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void testSourceFileName() {
+    TestDiagnosticMessagesImpl diagnosticsHandler = new TestDiagnosticMessagesImpl();
+    Retrace.run(
+        RetraceCommand.builder(diagnosticsHandler)
+            .setProguardMapProducer(
+                () ->
+                    StringUtils.lines(
+                        "com.android.tools.r8.retrace.SourceFileTest$ClassWithCustomFileName ->"
+                            + " com.android.tools.r8.retrace.a:",
+                        "# {'id':'sourceFile','fileName':'foobarbaz.java'}",
+                        "# {'id':'sourceFile','fileName':'foobarbaz2.java'}"))
+            .setStackTrace(ImmutableList.of())
+            .setRetracedStackTraceConsumer(
+                strings -> {
+                  // No need to do anything, we are just checking for diagnostics.
+                })
+            .build());
+    diagnosticsHandler
+        .assertWarningsCount(1)
+        .assertWarningsMatch(
+            allOf(
+                DiagnosticsMatcher.diagnosticMessage(containsString("The mapping")),
+                DiagnosticsMatcher.diagnosticMessage(
+                    containsString("is not allowed in combination with")),
+                DiagnosticsMatcher.diagnosticPosition(PositionMatcher.positionLine(3))));
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/retrace/RetraceCommandLineTests.java b/src/test/java/com/android/tools/r8/retrace/RetraceCommandLineTests.java
index 102f7f0..8a0f5e5 100644
--- a/src/test/java/com/android/tools/r8/retrace/RetraceCommandLineTests.java
+++ b/src/test/java/com/android/tools/r8/retrace/RetraceCommandLineTests.java
@@ -4,23 +4,27 @@
 
 package com.android.tools.r8.retrace;
 
-import static com.android.tools.r8.retrace.RetraceTests.DEFAULT_REGULAR_EXPRESSION;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.core.StringContains.containsString;
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
 
 import com.android.tools.r8.ToolHelper;
 import com.android.tools.r8.ToolHelper.ProcessResult;
+import com.android.tools.r8.Version;
 import com.android.tools.r8.retrace.stacktraces.ActualRetraceBotStackTrace;
 import com.android.tools.r8.retrace.stacktraces.ActualRetraceBotStackTraceWithInfo;
 import com.android.tools.r8.retrace.stacktraces.FoundMethodVerboseStackTrace;
+import com.android.tools.r8.retrace.stacktraces.PGStackTrace;
 import com.android.tools.r8.utils.StringUtils;
+import com.google.common.base.Charsets;
 import java.io.ByteArrayOutputStream;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.PrintStream;
+import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.ArrayList;
@@ -38,6 +42,8 @@
 
   @Rule public TemporaryFolder folder = new TemporaryFolder();
 
+  private static String SMILEY_EMOJI = "\uD83D\uDE00";
+
   @Test
   public void testPrintIdentityStackTraceFile() throws IOException {
     runTest("", nonMappableStackTrace, false, nonMappableStackTrace);
@@ -70,14 +76,34 @@
   }
 
   @Test
+  public void testVerboseSingleHyphen() throws IOException {
+    FoundMethodVerboseStackTrace stackTrace = new FoundMethodVerboseStackTrace();
+    runTest(
+        stackTrace.mapping(),
+        StringUtils.joinLines(stackTrace.obfuscatedStackTrace()),
+        false,
+        StringUtils.joinLines(stackTrace.retracedStackTrace()) + StringUtils.LINE_SEPARATOR,
+        "-verbose");
+  }
+
+  @Test
   public void testRegularExpression() throws IOException {
     ActualRetraceBotStackTrace stackTrace = new ActualRetraceBotStackTrace();
     runTest(
         stackTrace.mapping(),
         StringUtils.joinLines(stackTrace.obfuscatedStackTrace()),
         false,
-        StringUtils.joinLines(stackTrace.retracedStackTrace()) + StringUtils.LINE_SEPARATOR,
-        "--regex=" + DEFAULT_REGULAR_EXPRESSION);
+        StringUtils.joinLines(stackTrace.retracedStackTrace()) + StringUtils.LINE_SEPARATOR);
+  }
+
+  @Test
+  public void testRegularExpressionSingleHyphen() throws IOException {
+    ActualRetraceBotStackTrace stackTrace = new ActualRetraceBotStackTrace();
+    runTest(
+        stackTrace.mapping(),
+        StringUtils.joinLines(stackTrace.obfuscatedStackTrace()),
+        false,
+        StringUtils.joinLines(stackTrace.retracedStackTrace()) + StringUtils.LINE_SEPARATOR);
   }
 
   @Test
@@ -88,11 +114,20 @@
         StringUtils.joinLines(stackTrace.obfuscatedStackTrace()),
         false,
         StringUtils.joinLines(stackTrace.retracedStackTrace()) + StringUtils.LINE_SEPARATOR,
-        "--regex=" + DEFAULT_REGULAR_EXPRESSION,
         "--info");
   }
 
   @Test
+  public void testPGStackTrace() throws Exception {
+    PGStackTrace pgStackTrace = new PGStackTrace();
+    runTest(
+        pgStackTrace.mapping(),
+        StringUtils.joinLines(pgStackTrace.obfuscatedStackTrace()),
+        false,
+        StringUtils.joinLines(pgStackTrace.retracedStackTrace()) + StringUtils.LINE_SEPARATOR);
+  }
+
+  @Test
   public void testEmpty() throws IOException {
     runTest("", "", false, "");
   }
@@ -104,6 +139,23 @@
     assertEquals(Retrace.USAGE_MESSAGE, processResult.stdout);
   }
 
+  @Test
+  public void testVersion() throws Exception {
+    ProcessResult processResult = runRetraceCommandLine(null, Arrays.asList("--version"));
+    assertEquals(0, processResult.exitCode);
+    assertEquals(StringUtils.lines("Retrace " + Version.getVersionString()), processResult.stdout);
+  }
+
+  @Test
+  public void testNonAscii() throws IOException {
+    runTest("", SMILEY_EMOJI, false, SMILEY_EMOJI + StringUtils.LINE_SEPARATOR);
+  }
+
+  @Test
+  public void testNonAsciiStdIn() throws IOException {
+    runTest("", SMILEY_EMOJI, true, SMILEY_EMOJI + StringUtils.LINE_SEPARATOR);
+  }
+
   private final String nonMappableStackTrace =
       StringUtils.lines(
           "com.android.r8.R8Exception: Problem when compiling program",
@@ -123,6 +175,14 @@
     assertEquals(expected, result.stdout);
   }
 
+  private void runTestNotEquals(
+      String mapping, String stackTrace, boolean stacktraceStdIn, String expected, String... args)
+      throws IOException {
+    ProcessResult result = runRetrace(mapping, stackTrace, stacktraceStdIn, args);
+    assertEquals(0, result.exitCode);
+    assertNotEquals(expected, result.stdout);
+  }
+
   private void runAbortTest(Matcher<String> errorMatch, String... args) throws IOException {
     ProcessResult result = runRetraceCommandLine(null, Arrays.asList(args));
     assertEquals(1, result.exitCode);
@@ -135,7 +195,7 @@
     Path mappingFile = folder.newFile("mapping.txt").toPath();
     Files.write(mappingFile, mapping.getBytes());
     File stackTraceFile = folder.newFile("stacktrace.txt");
-    Files.write(stackTraceFile.toPath(), stackTrace.getBytes());
+    Files.write(stackTraceFile.toPath(), stackTrace.getBytes(StandardCharsets.UTF_8));
 
     Collection<String> args = new ArrayList<>();
     args.add(mappingFile.toString());
@@ -187,8 +247,8 @@
       System.setErr(originalErr);
       return new ProcessResult(
           exitCode,
-          outputByteStream.toString(),
-          errorByteStream.toString(),
+          outputByteStream.toString(Charsets.UTF_8.name()),
+          errorByteStream.toString(Charsets.UTF_8.name()),
           StringUtils.joinLines(args));
     }
   }
diff --git a/src/test/java/com/android/tools/r8/retrace/RetraceRegularExpressionTests.java b/src/test/java/com/android/tools/r8/retrace/RetraceRegularExpressionTests.java
index bb69fc3..4fb8389 100644
--- a/src/test/java/com/android/tools/r8/retrace/RetraceRegularExpressionTests.java
+++ b/src/test/java/com/android/tools/r8/retrace/RetraceRegularExpressionTests.java
@@ -4,6 +4,7 @@
 
 package com.android.tools.r8.retrace;
 
+import static com.android.tools.r8.retrace.Retrace.DEFAULT_REGULAR_EXPRESSION;
 import static junit.framework.TestCase.assertEquals;
 
 import com.android.tools.r8.TestBase;
@@ -11,11 +12,13 @@
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
 import com.android.tools.r8.retrace.stacktraces.InlineFileNameStackTrace;
+import com.android.tools.r8.retrace.stacktraces.RetraceAssertionErrorStackTrace;
 import com.android.tools.r8.retrace.stacktraces.StackTraceForTest;
 import com.android.tools.r8.utils.StringUtils;
 import com.google.common.collect.ImmutableList;
 import java.util.Collections;
 import java.util.List;
+import org.junit.Ignore;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
@@ -24,9 +27,6 @@
 @RunWith(Parameterized.class)
 public class RetraceRegularExpressionTests extends TestBase {
 
-  private static final String DEFAULT_REGULAR_EXPRESSION =
-      "(?:.*?\\bat\\s+%c\\.%m\\s*\\(%s(?::%l)?\\)\\s*(?:~\\[.*\\])?)|(?:(?:.*?[:\"]\\s+)?%c(?::.*)?)";
-
   @Parameters(name = "{0}")
   public static TestParametersCollection data() {
     return getTestParameters().withNoneRuntime().build();
@@ -395,7 +395,7 @@
   }
 
   @Test
-  public void testNotFoundLineNumberInMethodContext() {
+  public void testNoLineNumberInMethodContext() {
     runRetraceTest(
         "%c\\.%m\\(%l\\)",
         new StackTraceForTest() {
@@ -412,7 +412,35 @@
 
           @Override
           public List<String> retracedStackTrace() {
-            return ImmutableList.of("a.b.c.a()");
+            return ImmutableList.of("com.android.tools.r8.R8.foo()");
+          }
+
+          @Override
+          public int expectedWarnings() {
+            return 0;
+          }
+        });
+  }
+
+  @Test
+  public void testNotFoundLineNumberInMethodContext() {
+    runRetraceTest(
+        "%c\\.%m\\(%l\\)",
+        new StackTraceForTest() {
+          @Override
+          public List<String> obfuscatedStackTrace() {
+            return ImmutableList.of("a.b.c.a(42)");
+          }
+
+          @Override
+          public String mapping() {
+            return StringUtils.lines(
+                "com.android.tools.r8.R8 -> a.b.c:", "  3:3:boolean foo():7 -> a");
+          }
+
+          @Override
+          public List<String> retracedStackTrace() {
+            return ImmutableList.of("com.android.tools.r8.R8.a(42)");
           }
 
           @Override
@@ -540,6 +568,7 @@
   }
 
   @Test
+  @Ignore("b/165782924")
   public void useReturnTypeToNarrowMethodMatches() {
     runRetraceTest(
         "%t %c.%m",
@@ -663,6 +692,7 @@
   }
 
   @Test
+  @Ignore("b/165782924")
   public void testPruningOfMethodsByFormals() {
     runRetraceTest(
         "%c.%m\\(%a\\)",
@@ -731,6 +761,41 @@
         });
   }
 
+  @Test
+  public void testSourceFileLineNumber() {
+    runRetraceTest(
+        DEFAULT_REGULAR_EXPRESSION.replace("%s(?::%l)?", "%S"),
+        new RetraceAssertionErrorStackTrace());
+  }
+
+  @Test
+  public void testEscaping() {
+    runRetraceTest(
+        "\\%c\\\\%c\\\\\\%c.%m\\(\\\\%S\\)\\\\\\%S",
+        new StackTraceForTest() {
+          @Override
+          public List<String> obfuscatedStackTrace() {
+            return ImmutableList.of("%c\\com.android.tools.r8.Foo\\%c.a(\\SourceFile:1)\\%S");
+          }
+
+          @Override
+          public String mapping() {
+            return "com.android.tools.r8.Bar -> com.android.tools.r8.Foo:\n"
+                + "  1:1:void m():13:13 -> a";
+          }
+
+          @Override
+          public List<String> retracedStackTrace() {
+            return ImmutableList.of("%c\\com.android.tools.r8.Bar\\%c.m(\\Bar.java:13)\\%S");
+          }
+
+          @Override
+          public int expectedWarnings() {
+            return 0;
+          }
+        });
+  }
+
   private TestDiagnosticMessagesImpl runRetraceTest(
       String regularExpression, StackTraceForTest stackTraceForTest) {
     TestDiagnosticMessagesImpl diagnosticsHandler = new TestDiagnosticMessagesImpl();
diff --git a/src/test/java/com/android/tools/r8/retrace/RetraceTests.java b/src/test/java/com/android/tools/r8/retrace/RetraceTests.java
index 47dc5c3..8bf3b29 100644
--- a/src/test/java/com/android/tools/r8/retrace/RetraceTests.java
+++ b/src/test/java/com/android/tools/r8/retrace/RetraceTests.java
@@ -4,6 +4,7 @@
 
 package com.android.tools.r8.retrace;
 
+import static com.android.tools.r8.retrace.Retrace.DEFAULT_REGULAR_EXPRESSION;
 import static junit.framework.TestCase.assertEquals;
 import static org.hamcrest.CoreMatchers.containsString;
 import static org.hamcrest.MatcherAssert.assertThat;
@@ -23,6 +24,7 @@
 import com.android.tools.r8.retrace.stacktraces.FileNameExtensionStackTrace;
 import com.android.tools.r8.retrace.stacktraces.InlineFileNameStackTrace;
 import com.android.tools.r8.retrace.stacktraces.InlineNoLineNumberStackTrace;
+import com.android.tools.r8.retrace.stacktraces.InlineSourceFileContextStackTrace;
 import com.android.tools.r8.retrace.stacktraces.InlineWithLineNumbersStackTrace;
 import com.android.tools.r8.retrace.stacktraces.InvalidStackTrace;
 import com.android.tools.r8.retrace.stacktraces.NamedModuleStackTrace;
@@ -45,12 +47,6 @@
 @RunWith(Parameterized.class)
 public class RetraceTests extends TestBase {
 
-  // This is a slight modification of the default regular expression shown for proguard retrace
-  // that allow for retracing classes in the form <class>: lorem ipsum...
-  // Seems like Proguard retrace is expecting the form "Caused by: <class>".
-  public static final String DEFAULT_REGULAR_EXPRESSION =
-      "(?:.*?\\bat\\s+%c\\.%m\\s*\\(%s(?::%l)?\\)\\s*(?:~\\[.*\\])?)|(?:(?:(?:%c|.*)?[:\"]\\s+)?%c(?::.*)?)";
-
   @Parameters(name = "{0}, use regular expression: {1}")
   public static Collection<Object[]> data() {
     return buildParameters(getTestParameters().withNoneRuntime().build(), BooleanUtils.values());
@@ -178,6 +174,11 @@
     runRetraceTest(new UnknownSourceStackTrace());
   }
 
+  @Test
+  public void testInlineSourceFileContext() {
+    runRetraceTest(new InlineSourceFileContextStackTrace());
+  }
+
   private TestDiagnosticMessagesImpl runRetraceTest(StackTraceForTest stackTraceForTest) {
     TestDiagnosticMessagesImpl diagnosticsHandler = new TestDiagnosticMessagesImpl();
     RetraceCommand retraceCommand =
diff --git a/src/test/java/com/android/tools/r8/retrace/stacktraces/ActualRetraceBotStackTraceWithInfo.java b/src/test/java/com/android/tools/r8/retrace/stacktraces/ActualRetraceBotStackTraceWithInfo.java
index 53aa7c6..d57b024 100644
--- a/src/test/java/com/android/tools/r8/retrace/stacktraces/ActualRetraceBotStackTraceWithInfo.java
+++ b/src/test/java/com/android/tools/r8/retrace/stacktraces/ActualRetraceBotStackTraceWithInfo.java
@@ -45,59 +45,6 @@
   @Override
   public List<String> retracedStackTrace() {
     return Arrays.asList(
-        "Pruning \tat com.android.tools.r8.utils.Reporter.error(Reporter.java:21) from result"
-            + " because method is not defined on line number 21",
-        "Pruning \tat com.android.tools.r8.utils.Reporter.error(Reporter.java:21) from result"
-            + " because method is not defined on line number 21",
-        "Pruning \tat com.android.tools.r8.utils.Reporter.fatalError(Reporter.java:21) from result"
-            + " because method is not defined on line number 21",
-        "Pruning \tat"
-            + " com.android.tools.r8.utils.Reporter.addSuppressedExceptions(Reporter.java:21) from"
-            + " result because method is not defined on line number 21",
-        "Pruning \tat"
-            + " com.android.tools.r8.shaking.ProguardConfigurationParser.parse(ProguardConfigurationParser.java:19)"
-            + " from result because method is not defined on line number 19",
-        "Pruning \tat"
-            + " com.android.tools.r8.shaking.ProguardConfigurationParser.parse(ProguardConfigurationParser.java:19)"
-            + " from result because method is not defined on line number 19",
-        "Pruning \tat"
-            + " com.android.tools.r8.shaking.ProguardConfigurationParser.parse(ProguardConfigurationParser.java:19)"
-            + " from result because method is not in range on line number 19",
-        "Pruning \tat"
-            + " com.android.tools.r8.shaking.ProguardConfigurationParser.parse(ProguardConfigurationParser.java:19)"
-            + " from result because method is not in range on line number 19",
-        "Pruning \tat com.android.tools.r8.R8Command$Builder.makeCommand(R8Command.java:11) from"
-            + " result because method is not defined on line number 11",
-        "Pruning \tat"
-            + " com.android.tools.r8.R8Command$Builder.setDisableVerticalClassMerging(R8Command.java:11)"
-            + " from result because method is not defined on line number 11",
-        "Pruning \tat"
-            + " com.android.tools.r8.R8Command$Builder.lambda$addProguardConfigurationFiles$4(R8Command.java:11)"
-            + " from result because method is not defined on line number 11",
-        "Pruning \tat"
-            + " com.android.tools.r8.R8Command$Builder.lambda$addProguardConfiguration$6(R8Command.java:11)"
-            + " from result because method is not defined on line number 11",
-        "Pruning \tat"
-            + " com.android.tools.r8.R8Command$Builder.lambda$addProguardConfiguration$6(R8Command.java:11)"
-            + " from result because method is not defined on line number 11",
-        "Pruning \tat com.android.tools.r8.R8Command$Builder.makeCommand(R8Command.java:11) from"
-            + " result because method is not in range on line number 11",
-        "Pruning \tat"
-            + " com.android.tools.r8.R8Command$Builder.setDisableVerticalClassMerging(R8Command.java:1)"
-            + " from result because method is not defined on line number 1",
-        "Pruning \tat"
-            + " com.android.tools.r8.R8Command$Builder.lambda$addProguardConfigurationFiles$4(R8Command.java:1)"
-            + " from result because method is not defined on line number 1",
-        "Pruning \tat"
-            + " com.android.tools.r8.R8Command$Builder.lambda$addProguardConfiguration$6(R8Command.java:1)"
-            + " from result because method is not defined on line number 1",
-        "Pruning \tat"
-            + " com.android.tools.r8.R8Command$Builder.lambda$addProguardConfiguration$6(R8Command.java:1)"
-            + " from result because method is not defined on line number 1",
-        "Pruning \tat com.android.tools.r8.R8Command$Builder.makeCommand(R8Command.java:1) from"
-            + " result because method is not defined on line number 1",
-        "Pruning \tat com.android.tools.r8.R8Command$Builder.makeCommand(R8Command.java:1) from"
-            + " result because method is not defined on line number 1",
         "com.android.tools.r8.CompilationFailedException: Compilation failed to complete",
         "\tat com.android.tools.r8.BaseCommand$Builder.build(BaseCommand.java:143)",
         "\tat com.android.tools.r8.R8TestBuilder.internalCompile(R8TestBuilder.java:104)",
diff --git a/src/test/java/com/android/tools/r8/retrace/stacktraces/FoundMethodVerboseStackTrace.java b/src/test/java/com/android/tools/r8/retrace/stacktraces/FoundMethodVerboseStackTrace.java
index 4d9418c..ce7a8f5 100644
--- a/src/test/java/com/android/tools/r8/retrace/stacktraces/FoundMethodVerboseStackTrace.java
+++ b/src/test/java/com/android/tools/r8/retrace/stacktraces/FoundMethodVerboseStackTrace.java
@@ -27,7 +27,7 @@
   public List<String> retracedStackTrace() {
     return Arrays.asList(
         "Exception in thread \"main\" java.lang.NullPointerException",
-        "\tat com.android.Foo com.android.tools.r8.naming.retrace.Main.main(java.lang.String[],"
+        "\tat com.android.tools.r8.naming.retrace.Main.com.android.Foo main(java.lang.String[],"
             + "com.android.Bar)(Main.java:102)");
   }
 
diff --git a/src/test/java/com/android/tools/r8/retrace/stacktraces/InlineSourceFileContextStackTrace.java b/src/test/java/com/android/tools/r8/retrace/stacktraces/InlineSourceFileContextStackTrace.java
new file mode 100644
index 0000000..3c22097
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/retrace/stacktraces/InlineSourceFileContextStackTrace.java
@@ -0,0 +1,54 @@
+// Copyright (c) 2020, 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.retrace.stacktraces;
+
+import com.android.tools.r8.utils.StringUtils;
+import java.util.Arrays;
+import java.util.List;
+
+public class InlineSourceFileContextStackTrace implements StackTraceForTest {
+
+  @Override
+  public List<String> obfuscatedStackTrace() {
+    return Arrays.asList(
+        "  at com.google.appreduce.remapper.KotlinJavaSourceFileTestObject"
+            + ".main(KotlinJavaSourceFileTestObject.java:1)");
+  }
+
+  @Override
+  public String mapping() {
+    return StringUtils.joinLines(
+        "com.google.appreduce.remapper.KotlinJavaSourceFileTestLibrary ->"
+            + " com.google.appreduce.remapper.KotlinJavaSourceFileTestLibrary:",
+        "# {\"id\":\"sourceFile\",\"fileName\":\"KotlinJavaSourceFileTestLibrary.kt\"}",
+        "    void <init>() -> <init>",
+        "com.google.appreduce.remapper.KotlinJavaSourceFileTestObject ->"
+            + " com.google.appreduce.remapper.KotlinJavaSourceFileTestObject:",
+        "    void <init>() -> <init>",
+        "    1:1:void com.google.appreduce.remapper.KotlinJavaSourceFileTestLibrary"
+            + ".throwsException():22:22 -> main",
+        "    1:1:void com.google.appreduce.remapper.KotlinJavaSourceFileTestLibrary"
+            + ".callsThrowsException():19 -> main",
+        "    1:1:void main(java.lang.String[]):32 -> main",
+        "    2:7:void printStackTraceUpToMain(java.lang.Exception):19:24 -> main",
+        "    2:7:void main(java.lang.String[]):34 -> main");
+  }
+
+  @Override
+  public List<String> retracedStackTrace() {
+    return Arrays.asList(
+        "  at com.google.appreduce.remapper.KotlinJavaSourceFileTestLibrary"
+            + ".throwsException(KotlinJavaSourceFileTestLibrary.kt:22)",
+        "  at com.google.appreduce.remapper.KotlinJavaSourceFileTestLibrary"
+            + ".callsThrowsException(KotlinJavaSourceFileTestLibrary.kt:19)",
+        "  at com.google.appreduce.remapper.KotlinJavaSourceFileTestObject"
+            + ".main(KotlinJavaSourceFileTestObject.java:32)");
+  }
+
+  @Override
+  public int expectedWarnings() {
+    return 0;
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/retrace/stacktraces/PGStackTrace.java b/src/test/java/com/android/tools/r8/retrace/stacktraces/PGStackTrace.java
new file mode 100644
index 0000000..2732b34
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/retrace/stacktraces/PGStackTrace.java
@@ -0,0 +1,47 @@
+// Copyright (c) 2020, 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.retrace.stacktraces;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class PGStackTrace implements StackTraceForTest {
+
+  @Override
+  public List<String> obfuscatedStackTrace() {
+    return Arrays.asList(
+        "09-16 15:43:01.249 23316 23316 E AndroidRuntime: java.lang.NullPointerException: Attempt"
+            + " to invoke virtual method 'boolean"
+            + " com.google.android.foo(com.google.android.foo.Data$Key)' on a null object"
+            + " reference",
+        "09-16 15:43:01.249 23316 23316 E AndroidRuntime:        at"
+            + " com.google.apps.sectionheader.SectionHeaderListController.onToolbarStateChanged(PG:586)",
+        "09-16 15:43:01.249 23316 23316 E AndroidRuntime:        at"
+            + " com.google.apps.Controller.onToolbarStateChanged(PG:1087)");
+  }
+
+  @Override
+  public String mapping() {
+    return "";
+  }
+
+  @Override
+  public List<String> retracedStackTrace() {
+    return Arrays.asList(
+        "09-16 15:43:01.249 23316 23316 E AndroidRuntime: java.lang.NullPointerException: Attempt"
+            + " to invoke virtual method 'boolean"
+            + " com.google.android.foo(com.google.android.foo.Data$Key)' on a null object"
+            + " reference",
+        "09-16 15:43:01.249 23316 23316 E AndroidRuntime:        at"
+            + " com.google.apps.sectionheader.SectionHeaderListController.onToolbarStateChanged(SectionHeaderListController.java:586)",
+        "09-16 15:43:01.249 23316 23316 E AndroidRuntime:        at"
+            + " com.google.apps.Controller.onToolbarStateChanged(Controller.java:1087)");
+  }
+
+  @Override
+  public int expectedWarnings() {
+    return 0;
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/retrace/stacktraces/UnknownMethodVerboseStackTrace.java b/src/test/java/com/android/tools/r8/retrace/stacktraces/UnknownMethodVerboseStackTrace.java
index 3eb9710..5a47079 100644
--- a/src/test/java/com/android/tools/r8/retrace/stacktraces/UnknownMethodVerboseStackTrace.java
+++ b/src/test/java/com/android/tools/r8/retrace/stacktraces/UnknownMethodVerboseStackTrace.java
@@ -25,7 +25,7 @@
         "com.android.tools.r8.naming.retrace.Main -> a.a:",
         "    com.android.Foo main(java.lang.String[],com.android.Bar) -> a",
         "    com.android.Foo main(java.lang.String[]) -> b",
-        "    com.android.Bar main(com.android.Bar) -> b");
+        "    void main(com.android.Bar) -> b");
   }
 
   @Override
@@ -33,11 +33,11 @@
     return Arrays.asList(
         "Exception in thread \"main\" java.lang.NullPointerException",
         "\tat com.android.tools.r8.naming.retrace.Main.c(Main.java)",
-        "\tat com.android.Foo com.android.tools.r8.naming.retrace.Main.main("
+        "\tat com.android.tools.r8.naming.retrace.Main.com.android.Foo main("
             + "java.lang.String[])(Main.java)",
-        "\t<OR> at com.android.Bar com.android.tools.r8.naming.retrace.Main.main("
+        "\t<OR> at com.android.tools.r8.naming.retrace.Main.void main("
             + "com.android.Bar)(Main.java)",
-        "\tat com.android.Foo com.android.tools.r8.naming.retrace.Main.main("
+        "\tat com.android.tools.r8.naming.retrace.Main.com.android.Foo main("
             + "java.lang.String[],com.android.Bar)(Main.java)");
   }
 
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 3cfbb22..d2c22e5 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
@@ -37,8 +37,8 @@
 import com.android.tools.r8.references.FieldReference;
 import com.android.tools.r8.references.MethodReference;
 import com.android.tools.r8.references.Reference;
-import com.android.tools.r8.retrace.RetraceBase;
-import com.android.tools.r8.retrace.RetraceBaseImpl;
+import com.android.tools.r8.retrace.RetraceApi;
+import com.android.tools.r8.retrace.Retracer;
 import com.android.tools.r8.utils.AndroidApp;
 import com.android.tools.r8.utils.BiMapContainer;
 import com.android.tools.r8.utils.DescriptorUtils;
@@ -471,7 +471,7 @@
     }
   }
 
-  public RetraceBase retrace() {
-    return RetraceBaseImpl.create(mapping);
+  public RetraceApi retrace() {
+    return Retracer.create(mapping);
   }
 }
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/InstructionSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/InstructionSubject.java
index c5ca6c9..c3c961a 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/InstructionSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/InstructionSubject.java
@@ -6,7 +6,7 @@
 
 import com.android.tools.r8.graph.DexField;
 import com.android.tools.r8.graph.DexMethod;
-import com.android.tools.r8.retrace.RetraceBase;
+import com.android.tools.r8.retrace.RetraceApi;
 import com.android.tools.r8.retrace.RetraceMethodResult;
 
 public interface InstructionSubject {
@@ -125,18 +125,18 @@
     return lineNumberTable == null ? -1 : lineNumberTable.getLineForInstruction(this);
   }
 
-  default RetraceMethodResult retrace(RetraceBase retraceBase) {
+  default RetraceMethodResult retrace(RetraceApi retraceApi) {
     MethodSubject methodSubject = getMethodSubject();
     assert methodSubject.isPresent();
-    return retraceBase.retrace(methodSubject.asFoundMethodSubject().asMethodReference());
+    return retraceApi.retrace(methodSubject.asFoundMethodSubject().asMethodReference());
   }
 
-  default RetraceMethodResult retraceLinePosition(RetraceBase retraceBase) {
-    return retrace(retraceBase).narrowByLine(getLineNumber());
+  default RetraceMethodResult retraceLinePosition(RetraceApi retraceApi) {
+    return retrace(retraceApi).narrowByLine(getLineNumber());
   }
 
   default RetraceMethodResult retracePcPosition(
-      RetraceBase retraceBase, MethodSubject methodSubject) {
-    return retrace(retraceBase).narrowByLine(getOffset(methodSubject).offset);
+      RetraceApi retraceApi, MethodSubject methodSubject) {
+    return retrace(retraceApi).narrowByLine(getOffset(methodSubject).offset);
   }
 }