Merge commit '50f70c15b80b489373b7d6b9134062b546eb0b30' into dev-release

diff --git a/build.gradle b/build.gradle
index eca19a7..f775822 100644
--- a/build.gradle
+++ b/build.gradle

@@ -198,6 +198,11 @@
         }
         output.resourcesDir = 'build/classes/kotlinR8TestResources'
     }
+    keepanno {
+        java {
+            srcDirs = ['src/keepanno/java']
+        }
+    }
 }
 
 // Ensure importing into IntelliJ IDEA use the same output directories as Gradle. In tests we
@@ -207,7 +212,7 @@
 idea {
     sourceSets.all { SourceSet sources ->
         module {
-            if (sources.name == "main") {
+            if (sources.name == "main" || sources.name == "keepanno") {
                 sourceDirs += sources.java.srcDirs
                 outputDir sources.output.classesDirs[0]
             } else {
@@ -311,6 +316,11 @@
     apiUsageSampleCompile "com.google.guava:guava:$guavaVersion"
     kotlinR8TestResourcesCompileOnly "org.jetbrains.kotlin:kotlin-stdlib:$kotlinVersion"
     errorprone("com.google.errorprone:error_prone_core:$errorproneVersion")
+
+    keepannoCompile group: 'org.ow2.asm', name: 'asm', version: asmVersion
+    keepannoCompile "com.google.guava:guava:$guavaVersion"
+    testCompile sourceSets.keepanno.output
+    testRuntime sourceSets.keepanno.output
 }
 
 def r8LibPath = "$buildDir/libs/r8lib.jar"
@@ -1093,6 +1103,7 @@
 task testJarSources(type: Jar, dependsOn: [testClasses, buildLibraryDesugarConversions]) {
     archiveFileName = "r8testsbase.jar"
     from sourceSets.test.output
+    from sourceSets.keepanno.output
     // We only want to include tests that use R8 when generating keep rules for applymapping.
     include "com/android/tools/r8/**"
     include "android/**"

diff --git a/src/keepanno/java/com/android/tools/r8/keepanno/annotations/KeepCondition.java b/src/keepanno/java/com/android/tools/r8/keepanno/annotations/KeepCondition.java
new file mode 100644
index 0000000..9d0265e
--- /dev/null
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/annotations/KeepCondition.java

@@ -0,0 +1,13 @@
+// Copyright (c) 2022, 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.keepanno.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target(ElementType.ANNOTATION_TYPE)
+@Retention(RetentionPolicy.CLASS)
+public @interface KeepCondition {}

diff --git a/src/keepanno/java/com/android/tools/r8/keepanno/annotations/KeepConstants.java b/src/keepanno/java/com/android/tools/r8/keepanno/annotations/KeepConstants.java
new file mode 100644
index 0000000..24e49d1
--- /dev/null
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/annotations/KeepConstants.java

@@ -0,0 +1,35 @@
+// Copyright (c) 2022, 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.keepanno.annotations;
+
+/**
+ * Utility class for referencing the various keep annotations and their structure.
+ *
+ * <p>Use of these references avoids poluting the Java namespace with imports of the java
+ * annotations which overlap in name with the actual semantic AST types.
+ */
+public final class KeepConstants {
+
+  public static String getDescriptor(Class<?> clazz) {
+    return "L" + clazz.getTypeName().replace('.', '/') + ";";
+  }
+
+  public static String getBinaryNameFromClassTypeName(String classTypeName) {
+    return classTypeName.replace('.', '/');
+  }
+
+  public static final class Edge {
+    public static final Class<KeepEdge> CLASS = KeepEdge.class;
+    public static final String DESCRIPTOR = getDescriptor(CLASS);
+    public static final String preconditions = "preconditions";
+    public static final String consequences = "consequences";
+  }
+
+  public static final class Target {
+    public static final Class<KeepTarget> CLASS = KeepTarget.class;
+    public static final String DESCRIPTOR = getDescriptor(CLASS);
+    public static final String classConstant = "classConstant";
+    public static final String methodName = "methodName";
+  }
+}

diff --git a/src/keepanno/java/com/android/tools/r8/keepanno/annotations/KeepEdge.java b/src/keepanno/java/com/android/tools/r8/keepanno/annotations/KeepEdge.java
new file mode 100644
index 0000000..19b1a4a
--- /dev/null
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/annotations/KeepEdge.java

@@ -0,0 +1,17 @@
+// Copyright (c) 2022, 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.keepanno.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.CLASS)
+public @interface KeepEdge {
+  KeepCondition[] preconditions() default {};
+
+  KeepTarget[] consequences();
+}

diff --git a/src/keepanno/java/com/android/tools/r8/keepanno/annotations/KeepTarget.java b/src/keepanno/java/com/android/tools/r8/keepanno/annotations/KeepTarget.java
new file mode 100644
index 0000000..e20f288
--- /dev/null
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/annotations/KeepTarget.java

@@ -0,0 +1,19 @@
+// Copyright (c) 2022, 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.keepanno.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target(ElementType.ANNOTATION_TYPE)
+@Retention(RetentionPolicy.CLASS)
+public @interface KeepTarget {
+  Class<?> classConstant() default Object.class;
+
+  String classTypeName() default "";
+
+  String methodName() default "";
+}

diff --git a/src/keepanno/java/com/android/tools/r8/keepanno/asm/KeepEdgeReader.java b/src/keepanno/java/com/android/tools/r8/keepanno/asm/KeepEdgeReader.java
new file mode 100644
index 0000000..3ba3b8b
--- /dev/null
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/asm/KeepEdgeReader.java

@@ -0,0 +1,181 @@
+// Copyright (c) 2022, 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.keepanno.asm;
+
+import com.android.tools.r8.keepanno.annotations.KeepConstants.Edge;
+import com.android.tools.r8.keepanno.annotations.KeepConstants.Target;
+import com.android.tools.r8.keepanno.ast.KeepConsequences;
+import com.android.tools.r8.keepanno.ast.KeepEdge;
+import com.android.tools.r8.keepanno.ast.KeepEdgeException;
+import com.android.tools.r8.keepanno.ast.KeepItemPattern;
+import com.android.tools.r8.keepanno.ast.KeepItemPattern.Builder;
+import com.android.tools.r8.keepanno.ast.KeepMembersPattern;
+import com.android.tools.r8.keepanno.ast.KeepMethodNamePattern;
+import com.android.tools.r8.keepanno.ast.KeepMethodPattern;
+import com.android.tools.r8.keepanno.ast.KeepPreconditions;
+import com.android.tools.r8.keepanno.ast.KeepQualifiedClassNamePattern;
+import com.android.tools.r8.keepanno.ast.KeepTarget;
+import java.util.HashSet;
+import java.util.Set;
+import org.objectweb.asm.AnnotationVisitor;
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.Type;
+
+public class KeepEdgeReader implements Opcodes {
+
+  public static int ASM_VERSION = ASM9;
+
+  public static Set<KeepEdge> readKeepEdges(byte[] classFileBytes) {
+    ClassReader reader = new ClassReader(classFileBytes);
+    Set<KeepEdge> edges = new HashSet<>();
+    reader.accept(new KeepEdgeClassVisitor(edges::add), ClassReader.SKIP_CODE);
+    return edges;
+  }
+
+  private static class KeepEdgeClassVisitor extends ClassVisitor {
+    private final Parent<KeepEdge> parent;
+
+    KeepEdgeClassVisitor(Parent<KeepEdge> parent) {
+      super(ASM_VERSION);
+      this.parent = parent;
+    }
+
+    @Override
+    public AnnotationVisitor visitAnnotation(String descriptor, boolean visible) {
+      // Skip any visible annotations as @KeepEdge is not runtime visible.
+      if (!visible && descriptor.equals(Edge.DESCRIPTOR)) {
+        return new KeepEdgeVisitor(parent);
+      }
+      return null;
+    }
+  }
+
+  // Interface for providing AST result(s) for a sub-tree back up to its parent.
+  private interface Parent<T> {
+    void accept(T result);
+  }
+
+  private abstract static class AnnotationVisitorBase extends AnnotationVisitor {
+
+    AnnotationVisitorBase() {
+      super(ASM_VERSION);
+    }
+
+    @Override
+    public void visit(String name, Object value) {
+      throw new KeepEdgeException("Unexpected value in @KeepEdge: " + name + " = " + value);
+    }
+
+    @Override
+    public AnnotationVisitor visitAnnotation(String name, String descriptor) {
+      throw new KeepEdgeException("Unexpected annotation in @KeepEdge: " + name);
+    }
+
+    @Override
+    public void visitEnum(String name, String descriptor, String value) {
+      throw new KeepEdgeException("Unexpected enum in @KeepEdge: " + name);
+    }
+
+    @Override
+    public AnnotationVisitor visitArray(String name) {
+      throw new KeepEdgeException("Unexpected array in @KeepEdge: " + name);
+    }
+  }
+
+  private static class KeepEdgeVisitor extends AnnotationVisitorBase {
+    private final Parent<KeepEdge> parent;
+    private final KeepEdge.Builder builder = KeepEdge.builder();
+
+    KeepEdgeVisitor(Parent<KeepEdge> parent) {
+      this.parent = parent;
+    }
+
+    @Override
+    public AnnotationVisitor visitArray(String name) {
+      if (name.equals(Edge.preconditions)) {
+        return new KeepPreconditionsVisitor(builder::setPreconditions);
+      }
+      if (name.equals(Edge.consequences)) {
+        return new KeepConsequencesVisitor(builder::setConsequences);
+      }
+      return super.visitArray(name);
+    }
+
+    @Override
+    public void visitEnd() {
+      parent.accept(builder.build());
+    }
+  }
+
+  private static class KeepPreconditionsVisitor extends AnnotationVisitorBase {
+    private final Parent<KeepPreconditions> parent;
+
+    public KeepPreconditionsVisitor(Parent<KeepPreconditions> parent) {
+      this.parent = parent;
+    }
+  }
+
+  private static class KeepConsequencesVisitor extends AnnotationVisitorBase {
+    private final Parent<KeepConsequences> parent;
+    private final KeepConsequences.Builder builder = KeepConsequences.builder();
+
+    public KeepConsequencesVisitor(Parent<KeepConsequences> parent) {
+      this.parent = parent;
+    }
+
+    @Override
+    public AnnotationVisitor visitAnnotation(String name, String descriptor) {
+      if (descriptor.equals(Target.DESCRIPTOR)) {
+        return new KeepTargetVisitor(builder::addTarget);
+      }
+      return super.visitAnnotation(name, descriptor);
+    }
+
+    @Override
+    public void visitEnd() {
+      parent.accept(builder.build());
+    }
+  }
+
+  private static class KeepTargetVisitor extends AnnotationVisitorBase {
+    private final Parent<KeepTarget> parent;
+    private KeepQualifiedClassNamePattern classNamePattern = null;
+    private KeepMethodNamePattern methodName = null;
+
+    public KeepTargetVisitor(Parent<KeepTarget> parent) {
+      this.parent = parent;
+    }
+
+    @Override
+    public void visit(String name, Object value) {
+      if (name.equals(Target.classConstant) && value instanceof Type) {
+        classNamePattern = KeepQualifiedClassNamePattern.exact(((Type) value).getClassName());
+        return;
+      }
+      if (name.equals(Target.methodName) && value instanceof String) {
+        methodName = KeepMethodNamePattern.exact((String) value);
+        return;
+      }
+      super.visit(name, value);
+    }
+
+    @Override
+    public void visitEnd() {
+      Builder itemBuilder = KeepItemPattern.builder();
+      if (classNamePattern != null) {
+        itemBuilder.setClassPattern(classNamePattern);
+      }
+      if (methodName != null) {
+        itemBuilder.setMembersPattern(
+            KeepMembersPattern.builder()
+                .addMethodPattern(KeepMethodPattern.builder().setNamePattern(methodName).build())
+                .build());
+      }
+      KeepTarget target = KeepTarget.builder().setItem(itemBuilder.build()).build();
+      parent.accept(target);
+    }
+  }
+}

diff --git a/src/keepanno/java/com/android/tools/r8/keepanno/asm/KeepEdgeWriter.java b/src/keepanno/java/com/android/tools/r8/keepanno/asm/KeepEdgeWriter.java
new file mode 100644
index 0000000..1641d8d
--- /dev/null
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/asm/KeepEdgeWriter.java

@@ -0,0 +1,112 @@
+// Copyright (c) 2022, 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.keepanno.asm;
+
+import com.android.tools.r8.keepanno.annotations.KeepConstants;
+import com.android.tools.r8.keepanno.annotations.KeepConstants.Edge;
+import com.android.tools.r8.keepanno.annotations.KeepConstants.Target;
+import com.android.tools.r8.keepanno.ast.KeepConsequences;
+import com.android.tools.r8.keepanno.ast.KeepEdge;
+import com.android.tools.r8.keepanno.ast.KeepMethodNamePattern;
+import com.android.tools.r8.keepanno.ast.KeepPreconditions;
+import com.android.tools.r8.keepanno.ast.KeepQualifiedClassNamePattern;
+import com.android.tools.r8.keepanno.utils.Unimplemented;
+import java.util.function.BiFunction;
+import org.objectweb.asm.AnnotationVisitor;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.Type;
+
+public class KeepEdgeWriter implements Opcodes {
+
+  public static void writeEdge(KeepEdge edge, ClassVisitor visitor) {
+    writeEdge(edge, visitor::visitAnnotation);
+  }
+
+  public static void writeEdge(
+      KeepEdge edge, BiFunction<String, Boolean, AnnotationVisitor> getVisitor) {
+    new KeepEdgeWriter().writeEdge(edge, getVisitor.apply(Edge.DESCRIPTOR, false));
+  }
+
+  private void writeEdge(KeepEdge edge, AnnotationVisitor visitor) {
+    writePreconditions(visitor, edge.getPreconditions());
+    writeConsequences(visitor, edge.getConsequences());
+    visitor.visitEnd();
+  }
+
+  private void writePreconditions(AnnotationVisitor visitor, KeepPreconditions preconditions) {
+    if (preconditions.isAlways()) {
+      return;
+    }
+    throw new Unimplemented();
+  }
+
+  private void writeConsequences(AnnotationVisitor visitor, KeepConsequences consequences) {
+    assert !consequences.isEmpty();
+    String ignoredArrayValueName = null;
+    AnnotationVisitor arrayVisitor = visitor.visitArray(KeepConstants.Edge.consequences);
+    consequences.forEachTarget(
+        target -> {
+          AnnotationVisitor targetVisitor =
+              arrayVisitor.visitAnnotation(ignoredArrayValueName, KeepConstants.Target.DESCRIPTOR);
+          // No options imply keep all.
+          if (!target.getOptions().isKeepAll()) {
+            throw new Unimplemented();
+          }
+          target
+              .getItem()
+              .match(
+                  () -> {
+                    throw new Unimplemented();
+                  },
+                  clazz -> {
+                    KeepQualifiedClassNamePattern namePattern = clazz.getClassNamePattern();
+                    if (namePattern.isExact()) {
+                      Type typeConstant = Type.getType(namePattern.getExactDescriptor());
+                      targetVisitor.visit(KeepConstants.Target.classConstant, typeConstant);
+                    } else {
+                      throw new Unimplemented();
+                    }
+                    if (!clazz.getExtendsPattern().isAny()) {
+                      throw new Unimplemented();
+                    }
+                    if (clazz.getMembersPattern().isNone()) {
+                      // Default is "no methods".
+                    } else if (clazz.getMembersPattern().isAll()) {
+                      throw new Unimplemented();
+                    } else {
+                      clazz
+                          .getMembersPattern()
+                          .forEach(
+                              field -> {
+                                throw new Unimplemented();
+                              },
+                              method -> {
+                                KeepMethodNamePattern methodNamePattern = method.getNamePattern();
+                                methodNamePattern.match(
+                                    () -> {
+                                      throw new Unimplemented();
+                                    },
+                                    exactMethodName -> {
+                                      targetVisitor.visit(Target.methodName, exactMethodName);
+                                      return null;
+                                    });
+                                if (!method.getAccessPattern().isAny()) {
+                                  throw new Unimplemented();
+                                }
+                                if (!method.getReturnTypePattern().isAny()) {
+                                  throw new Unimplemented();
+                                }
+                                if (!method.getParametersPattern().isAny()) {
+                                  throw new Unimplemented();
+                                }
+                              });
+                    }
+                    return null;
+                  });
+          targetVisitor.visitEnd();
+        });
+    arrayVisitor.visitEnd();
+  }
+}

diff --git a/src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepCondition.java b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepCondition.java
similarity index 95%
rename from src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepCondition.java
rename to src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepCondition.java
index acd327d..43b4176 100644
--- a/src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepCondition.java
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepCondition.java

@@ -1,7 +1,7 @@
 // Copyright (c) 2022, 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.experimental.keepanno.ast;
+package com.android.tools.r8.keepanno.ast;
 
 /**
  * A keep condition is the content of an item in the set of preconditions.
@@ -41,5 +41,5 @@
 
   public KeepItemPattern getItemPattern() {
     return itemPattern;
-    }
+  }
 }

diff --git a/src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepConsequences.java b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepConsequences.java
similarity index 64%
rename from src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepConsequences.java
rename to src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepConsequences.java
index 6a227fd..1322746 100644
--- a/src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepConsequences.java
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepConsequences.java

@@ -1,11 +1,12 @@
 // Copyright (c) 2022, 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.experimental.keepanno.ast;
+package com.android.tools.r8.keepanno.ast;
 
 import java.util.ArrayList;
 import java.util.List;
 import java.util.function.Consumer;
+import java.util.stream.Collectors;
 
 /**
  * Set of consequences of a keep edge.
@@ -29,6 +30,9 @@
     }
 
     public KeepConsequences build() {
+      if (targets.isEmpty()) {
+        throw new KeepEdgeException("Invalid empty consequent set");
+      }
       return new KeepConsequences(targets);
     }
   }
@@ -40,6 +44,8 @@
   private final List<KeepTarget> targets;
 
   private KeepConsequences(List<KeepTarget> targets) {
+    assert targets != null;
+    assert !targets.isEmpty();
     this.targets = targets;
   }
 
@@ -50,4 +56,26 @@
   public void forEachTarget(Consumer<KeepTarget> fn) {
     targets.forEach(fn);
   }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) {
+      return true;
+    }
+    if (o == null || getClass() != o.getClass()) {
+      return false;
+    }
+    KeepConsequences that = (KeepConsequences) o;
+    return targets.equals(that.targets);
+  }
+
+  @Override
+  public int hashCode() {
+    return targets.hashCode();
+  }
+
+  @Override
+  public String toString() {
+    return targets.stream().map(Object::toString).collect(Collectors.joining(", "));
+  }
 }

diff --git a/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepEdge.java b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepEdge.java
new file mode 100644
index 0000000..4da44aa
--- /dev/null
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepEdge.java

@@ -0,0 +1,125 @@
+// Copyright (c) 2022, 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.keepanno.ast;
+
+import java.util.Objects;
+
+/**
+ * An edge in the keep graph.
+ *
+ * <p>An edge describes a set of preconditions and a set of consequences. If the preconditions are
+ * met, then the consequences are put into effect.
+ *
+ * <p>Below is a BNF of the keep edge AST for reference. The non-terminals are written in ALL_CAPS,
+ * possibly-empty repeatable subexpressions denoted with SUB* and non-empty with SUB+
+ *
+ * <p>In the Java AST, the non-terminals are prefixed with 'Keep' and in CamelCase.
+ *
+ * <p>TODO(b/248408342): Update the BNF and AST to be complete.
+ *
+ * <pre>
+ *   EDGE ::= PRECONDITIONS -> CONSEQUENCES
+ *
+ *   PRECONDITIONS ::= always | CONDITION+
+ *   CONDITION ::= ITEM_PATTERN
+ *
+ *   CONSEQUENCES ::= TARGET+
+ *   TARGET ::= any | OPTIONS ITEM_PATTERN
+ *   OPTIONS ::= keep-all | OPTION+
+ *   OPTION ::= shrinking | optimizing | obfuscating | access-modifying
+ *
+ *   ITEM_PATTERN ::= any | CLASS_PATTERN
+ *   CLASS_PATTERN ::= QUALIFIED_CLASS_NAME_PATTERN extends EXTENDS_PATTERN { MEMBERS_PATTERN }
+ *
+ *   TYPE_PATTERN ::= any
+ *   PACKAGE_PATTERN ::= any | exact package-name
+ *   QUALIFIED_CLASS_NAME_PATTERN ::= any | PACKAGE_PATTERN | UNQUALIFIED_CLASS_NAME_PATTERN
+ *   UNQUALIFIED_CLASS_NAME_PATTERN ::= any | exact simple-class-name
+ *   EXTENDS_PATTERN ::= any | QUALIFIED_CLASS_NAME_PATTERN
+ *
+ *   MEMBERS_PATTERN ::= none | all | METHOD_PATTERN*
+ *
+ *   METHOD_PATTERN
+ *     ::= METHOD_ACCESS_PATTERN
+ *           METHOD_RETURN_TYPE_PATTERN
+ *           METHOD_NAME_PATTERN
+ *           METHOD_PARAMETERS_PATTERN
+ *
+ *   METHOD_ACCESS_PATTERN ::= any
+ *   METHOD_NAME_PATTERN ::= any | exact method-name
+ *   METHOD_RETURN_TYPE_PATTERN ::= void | TYPE_PATTERN
+ *   METHOD_PARAMETERS_PATTERN ::= any | none | TYPE_PATTERN+
+ * </pre>
+ */
+public final class KeepEdge {
+
+  public static class Builder {
+    private KeepPreconditions preconditions = KeepPreconditions.always();
+    private KeepConsequences consequences;
+
+    private Builder() {}
+
+    public Builder setPreconditions(KeepPreconditions preconditions) {
+      this.preconditions = preconditions;
+      return this;
+    }
+
+    public Builder setConsequences(KeepConsequences consequences) {
+      this.consequences = consequences;
+      return this;
+    }
+
+    public KeepEdge build() {
+      if (consequences.isEmpty()) {
+        throw new KeepEdgeException("KeepEdge must have non-empty set of consequences.");
+      }
+      return new KeepEdge(preconditions, consequences);
+    }
+  }
+
+  public static Builder builder() {
+    return new Builder();
+  }
+
+  private final KeepPreconditions preconditions;
+  private final KeepConsequences consequences;
+
+  private KeepEdge(KeepPreconditions preconditions, KeepConsequences consequences) {
+    assert preconditions != null;
+    assert consequences != null;
+    this.preconditions = preconditions;
+    this.consequences = consequences;
+  }
+
+  public KeepPreconditions getPreconditions() {
+    return preconditions;
+  }
+
+  public KeepConsequences getConsequences() {
+    return consequences;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) {
+      return true;
+    }
+    if (o == null || getClass() != o.getClass()) {
+      return false;
+    }
+    KeepEdge keepEdge = (KeepEdge) o;
+    return preconditions.equals(keepEdge.preconditions)
+        && consequences.equals(keepEdge.consequences);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(preconditions, consequences);
+  }
+
+  @Override
+  public String toString() {
+    return "KeepEdge{" + "preconditions=" + preconditions + ", consequences=" + consequences + '}';
+  }
+}

diff --git a/src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepEdgeException.java b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepEdgeException.java
similarity index 85%
rename from src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepEdgeException.java
rename to src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepEdgeException.java
index 3345c8f..5abe947 100644
--- a/src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepEdgeException.java
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepEdgeException.java

@@ -1,7 +1,7 @@
 // Copyright (c) 2022, 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.experimental.keepanno.ast;
+package com.android.tools.r8.keepanno.ast;
 
 public class KeepEdgeException extends RuntimeException {
 

diff --git a/src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepExtendsPattern.java b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepExtendsPattern.java
similarity index 67%
rename from src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepExtendsPattern.java
rename to src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepExtendsPattern.java
index 17e543f..b6b0fd7 100644
--- a/src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepExtendsPattern.java
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepExtendsPattern.java

@@ -1,7 +1,7 @@
 // Copyright (c) 2022, 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.experimental.keepanno.ast;
+package com.android.tools.r8.keepanno.ast;
 
 /** Pattern for matching the "extends" or "implements" clause of a class. */
 public abstract class KeepExtendsPattern {
@@ -42,6 +42,21 @@
     public boolean isAny() {
       return true;
     }
+
+    @Override
+    public boolean equals(Object obj) {
+      return this == obj;
+    }
+
+    @Override
+    public int hashCode() {
+      return System.identityHashCode(this);
+    }
+
+    @Override
+    public String toString() {
+      return "*";
+    }
   }
 
   private static class KeepExtendsClassPattern extends KeepExtendsPattern {
@@ -49,6 +64,7 @@
     private final KeepQualifiedClassNamePattern pattern;
 
     public KeepExtendsClassPattern(KeepQualifiedClassNamePattern pattern) {
+      assert pattern != null;
       this.pattern = pattern;
     }
 
@@ -56,6 +72,28 @@
     public boolean isAny() {
       return pattern.isAny();
     }
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) {
+        return true;
+      }
+      if (o == null || getClass() != o.getClass()) {
+        return false;
+      }
+      KeepExtendsClassPattern that = (KeepExtendsClassPattern) o;
+      return pattern.equals(that.pattern);
+    }
+
+    @Override
+    public int hashCode() {
+      return pattern.hashCode();
+    }
+
+    @Override
+    public String toString() {
+      return pattern.toString();
+    }
   }
 
   public static Builder builder() {

diff --git a/src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepFieldPattern.java b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepFieldPattern.java
similarity index 86%
rename from src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepFieldPattern.java
rename to src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepFieldPattern.java
index 04e2697..8de46e1 100644
--- a/src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepFieldPattern.java
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepFieldPattern.java

@@ -1,7 +1,7 @@
 // Copyright (c) 2022, 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.experimental.keepanno.ast;
+package com.android.tools.r8.keepanno.ast;
 
 public class KeepFieldPattern extends KeepMemberPattern {
 

diff --git a/src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepItemPattern.java b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepItemPattern.java
similarity index 75%
rename from src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepItemPattern.java
rename to src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepItemPattern.java
index 3c6f947..e5b0987 100644
--- a/src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepItemPattern.java
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepItemPattern.java

@@ -1,8 +1,9 @@
 // Copyright (c) 2022, 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.experimental.keepanno.ast;
+package com.android.tools.r8.keepanno.ast;
 
+import java.util.Objects;
 import java.util.function.Function;
 import java.util.function.Supplier;
 
@@ -87,6 +88,21 @@
     public <T> T match(Supplier<T> onAny, Function<KeepClassPattern, T> onItem) {
       return onAny.get();
     }
+
+    @Override
+    public boolean equals(Object obj) {
+      return this == obj;
+    }
+
+    @Override
+    public int hashCode() {
+      return System.identityHashCode(this);
+    }
+
+    @Override
+    public String toString() {
+      return "*";
+    }
   }
 
   public static class KeepClassPattern extends KeepItemPattern {
@@ -100,6 +116,9 @@
         KeepQualifiedClassNamePattern qualifiedClassPattern,
         KeepExtendsPattern extendsPattern,
         KeepMembersPattern membersPattern) {
+      assert qualifiedClassPattern != null;
+      assert extendsPattern != null;
+      assert membersPattern != null;
       this.qualifiedClassPattern = qualifiedClassPattern;
       this.extendsPattern = extendsPattern;
       this.membersPattern = membersPattern;
@@ -130,6 +149,37 @@
     public KeepMembersPattern getMembersPattern() {
       return membersPattern;
     }
+
+    @Override
+    public boolean equals(Object obj) {
+      if (this == obj) {
+        return true;
+      }
+      if (obj == null || getClass() != obj.getClass()) {
+        return false;
+      }
+      KeepClassPattern that = (KeepClassPattern) obj;
+      return qualifiedClassPattern.equals(that.qualifiedClassPattern)
+          && extendsPattern.equals(that.extendsPattern)
+          && membersPattern.equals(that.membersPattern);
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hash(qualifiedClassPattern, extendsPattern, membersPattern);
+    }
+
+    @Override
+    public String toString() {
+      return "KeepClassPattern{"
+          + "qualifiedClassPattern="
+          + qualifiedClassPattern
+          + ", extendsPattern="
+          + extendsPattern
+          + ", membersPattern="
+          + membersPattern
+          + '}';
+    }
   }
 
   public abstract boolean isAny();

diff --git a/src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepMemberPattern.java b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepMemberPattern.java
similarity index 93%
rename from src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepMemberPattern.java
rename to src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepMemberPattern.java
index 73bae7e..bd716e9 100644
--- a/src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepMemberPattern.java
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepMemberPattern.java

@@ -1,7 +1,7 @@
 // Copyright (c) 2022, 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.experimental.keepanno.ast;
+package com.android.tools.r8.keepanno.ast;
 
 public abstract class KeepMemberPattern {
 

diff --git a/src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepMembersPattern.java b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepMembersPattern.java
similarity index 73%
rename from src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepMembersPattern.java
rename to src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepMembersPattern.java
index 6d3f93e..be5af32 100644
--- a/src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepMembersPattern.java
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepMembersPattern.java

@@ -1,12 +1,14 @@
 // Copyright (c) 2022, 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.experimental.keepanno.ast;
+package com.android.tools.r8.keepanno.ast;
 
-import com.android.tools.r8.errors.Unimplemented;
+import com.android.tools.r8.keepanno.utils.Unimplemented;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Objects;
 import java.util.function.Consumer;
+import java.util.stream.Collectors;
 
 public abstract class KeepMembersPattern {
 
@@ -89,6 +91,21 @@
     public void forEach(Consumer<KeepFieldPattern> onField, Consumer<KeepMethodPattern> onMethod) {
       throw new Unimplemented("Should this include all and none?");
     }
+
+    @Override
+    public boolean equals(Object obj) {
+      return this == obj;
+    }
+
+    @Override
+    public int hashCode() {
+      return System.identityHashCode(this);
+    }
+
+    @Override
+    public String toString() {
+      return "*";
+    }
   }
 
   private static class KeepMembersNonePattern extends KeepMembersPattern {
@@ -116,6 +133,21 @@
     public void forEach(Consumer<KeepFieldPattern> onField, Consumer<KeepMethodPattern> onMethod) {
       throw new Unimplemented("Should this include all and none?");
     }
+
+    @Override
+    public boolean equals(Object obj) {
+      return this == obj;
+    }
+
+    @Override
+    public int hashCode() {
+      return System.identityHashCode(this);
+    }
+
+    @Override
+    public String toString() {
+      return "<none>";
+    }
   }
 
   private static class KeepMembersSomePattern extends KeepMembersPattern {
@@ -146,6 +178,33 @@
       fields.forEach(onField);
       methods.forEach(onMethod);
     }
+
+    @Override
+    public boolean equals(Object obj) {
+      if (this == obj) {
+        return true;
+      }
+      if (obj == null || getClass() != obj.getClass()) {
+        return false;
+      }
+      KeepMembersSomePattern that = (KeepMembersSomePattern) obj;
+      return methods.equals(that.methods) && fields.equals(that.fields);
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hash(methods, fields);
+    }
+
+    @Override
+    public String toString() {
+      return "KeepMembersSomePattern{"
+          + "methods={"
+          + methods.stream().map(Object::toString).collect(Collectors.joining(", "))
+          + "}, fields={"
+          + fields.stream().map(Object::toString).collect(Collectors.joining(", "))
+          + "}}";
+    }
   }
 
   private KeepMembersPattern() {}

diff --git a/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepMethodAccessPattern.java b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepMethodAccessPattern.java
new file mode 100644
index 0000000..fd0fd3e
--- /dev/null
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepMethodAccessPattern.java

@@ -0,0 +1,46 @@
+// Copyright (c) 2022, 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.keepanno.ast;
+
+// TODO: finish this.
+public abstract class KeepMethodAccessPattern {
+
+  public static KeepMethodAccessPattern any() {
+    return Any.getInstance();
+  }
+
+  public abstract boolean isAny();
+
+  private static class Any extends KeepMethodAccessPattern {
+
+    private static Any INSTANCE = null;
+
+    private static Any getInstance() {
+      if (INSTANCE == null) {
+        INSTANCE = new Any();
+      }
+      return INSTANCE;
+    }
+
+    @Override
+    public boolean isAny() {
+      return true;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+      return this == obj;
+    }
+
+    @Override
+    public int hashCode() {
+      return System.identityHashCode(this);
+    }
+
+    @Override
+    public String toString() {
+      return "*";
+    }
+  }
+}

diff --git a/src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepMethodNamePattern.java b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepMethodNamePattern.java
similarity index 68%
rename from src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepMethodNamePattern.java
rename to src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepMethodNamePattern.java
index ada6701..6dc373d 100644
--- a/src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepMethodNamePattern.java
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepMethodNamePattern.java

@@ -1,7 +1,7 @@
 // Copyright (c) 2022, 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.experimental.keepanno.ast;
+package com.android.tools.r8.keepanno.ast;
 
 import java.util.function.Function;
 import java.util.function.Supplier;
@@ -47,12 +47,28 @@
     public <T> T match(Supplier<T> onAny, Function<String, T> onExact) {
       return onAny.get();
     }
+
+    @Override
+    public boolean equals(Object obj) {
+      return this == obj;
+    }
+
+    @Override
+    public int hashCode() {
+      return System.identityHashCode(this);
+    }
+
+    @Override
+    public String toString() {
+      return "*";
+    }
   }
 
   private static class KeepMethodNameExactPattern extends KeepMethodNamePattern {
     private final String name;
 
     public KeepMethodNameExactPattern(String name) {
+      assert name != null;
       this.name = name;
     }
 
@@ -60,5 +76,27 @@
     public <T> T match(Supplier<T> onAny, Function<String, T> onExact) {
       return onExact.apply(name);
     }
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) {
+        return true;
+      }
+      if (o == null || getClass() != o.getClass()) {
+        return false;
+      }
+      KeepMethodNameExactPattern that = (KeepMethodNameExactPattern) o;
+      return name.equals(that.name);
+    }
+
+    @Override
+    public int hashCode() {
+      return name.hashCode();
+    }
+
+    @Override
+    public String toString() {
+      return name;
+    }
   }
 }

diff --git a/src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepMethodParametersPattern.java b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepMethodParametersPattern.java
similarity index 70%
rename from src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepMethodParametersPattern.java
rename to src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepMethodParametersPattern.java
index 4f42202..83b4606 100644
--- a/src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepMethodParametersPattern.java
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepMethodParametersPattern.java

@@ -1,7 +1,7 @@
 // Copyright (c) 2022, 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.experimental.keepanno.ast;
+package com.android.tools.r8.keepanno.ast;
 
 import java.util.Collections;
 import java.util.List;
@@ -22,6 +22,10 @@
 
   public abstract <T> T match(Supplier<T> onAny, Function<List<KeepTypePattern>, T> onList);
 
+  public boolean isAny() {
+    return match(() -> true, params -> false);
+  }
+
   private static class None extends KeepMethodParametersPattern {
     private static None INSTANCE = null;
 
@@ -36,6 +40,21 @@
     public <T> T match(Supplier<T> onAny, Function<List<KeepTypePattern>, T> onList) {
       return onList.apply(Collections.emptyList());
     }
+
+    @Override
+    public boolean equals(Object obj) {
+      return this == obj;
+    }
+
+    @Override
+    public int hashCode() {
+      return System.identityHashCode(this);
+    }
+
+    @Override
+    public String toString() {
+      return "()";
+    }
   }
 
   private static class Any extends KeepMethodParametersPattern {
@@ -52,5 +71,20 @@
     public <T> T match(Supplier<T> onAny, Function<List<KeepTypePattern>, T> onList) {
       return onAny.get();
     }
+
+    @Override
+    public boolean equals(Object obj) {
+      return this == obj;
+    }
+
+    @Override
+    public int hashCode() {
+      return System.identityHashCode(this);
+    }
+
+    @Override
+    public String toString() {
+      return "(...)";
+    }
   }
 }

diff --git a/src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepMethodPattern.java b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepMethodPattern.java
similarity index 71%
rename from src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepMethodPattern.java
rename to src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepMethodPattern.java
index 5db7d26..b3ec418 100644
--- a/src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepMethodPattern.java
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepMethodPattern.java

@@ -1,7 +1,9 @@
 // Copyright (c) 2022, 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.experimental.keepanno.ast;
+package com.android.tools.r8.keepanno.ast;
+
+import java.util.Objects;
 
 public final class KeepMethodPattern extends KeepMemberPattern {
 
@@ -62,6 +64,10 @@
       KeepMethodNamePattern namePattern,
       KeepMethodReturnTypePattern returnTypePattern,
       KeepMethodParametersPattern parametersPattern) {
+    assert accessPattern != null;
+    assert namePattern != null;
+    assert returnTypePattern != null;
+    assert parametersPattern != null;
     this.accessPattern = accessPattern;
     this.namePattern = namePattern;
     this.returnTypePattern = returnTypePattern;
@@ -87,4 +93,38 @@
   public KeepMethodParametersPattern getParametersPattern() {
     return parametersPattern;
   }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) {
+      return true;
+    }
+    if (o == null || getClass() != o.getClass()) {
+      return false;
+    }
+    KeepMethodPattern that = (KeepMethodPattern) o;
+    return accessPattern.equals(that.accessPattern)
+        && namePattern.equals(that.namePattern)
+        && returnTypePattern.equals(that.returnTypePattern)
+        && parametersPattern.equals(that.parametersPattern);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(accessPattern, namePattern, returnTypePattern, parametersPattern);
+  }
+
+  @Override
+  public String toString() {
+    return "KeepMethodPattern{"
+        + "access="
+        + accessPattern
+        + ", name="
+        + namePattern
+        + ", returnType="
+        + returnTypePattern
+        + ", parameters="
+        + parametersPattern
+        + '}';
+  }
 }

diff --git a/src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepMethodReturnTypePattern.java b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepMethodReturnTypePattern.java
similarity index 63%
rename from src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepMethodReturnTypePattern.java
rename to src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepMethodReturnTypePattern.java
index 4e7b5b9..f711bc0 100644
--- a/src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepMethodReturnTypePattern.java
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepMethodReturnTypePattern.java

@@ -1,7 +1,7 @@
 // Copyright (c) 2022, 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.experimental.keepanno.ast;
+package com.android.tools.r8.keepanno.ast;
 
 import java.util.function.Function;
 import java.util.function.Supplier;
@@ -23,6 +23,10 @@
 
   public abstract <T> T match(Supplier<T> onVoid, Function<KeepTypePattern, T> onType);
 
+  public boolean isAny() {
+    return match(() -> false, KeepTypePattern::isAny);
+  }
+
   private static class VoidType extends KeepMethodReturnTypePattern {
     private static VoidType INSTANCE = null;
 
@@ -37,6 +41,21 @@
     public <T> T match(Supplier<T> onVoid, Function<KeepTypePattern, T> onType) {
       return onVoid.get();
     }
+
+    @Override
+    public boolean equals(Object obj) {
+      return this == obj;
+    }
+
+    @Override
+    public int hashCode() {
+      return System.identityHashCode(this);
+    }
+
+    @Override
+    public String toString() {
+      return "void";
+    }
   }
 
   private static class SomeType extends KeepMethodReturnTypePattern {
@@ -44,6 +63,7 @@
     private final KeepTypePattern typePattern;
 
     private SomeType(KeepTypePattern typePattern) {
+      assert typePattern != null;
       this.typePattern = typePattern;
     }
 
@@ -51,5 +71,27 @@
     public <T> T match(Supplier<T> onVoid, Function<KeepTypePattern, T> onType) {
       return onType.apply(typePattern);
     }
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) {
+        return true;
+      }
+      if (o == null || getClass() != o.getClass()) {
+        return false;
+      }
+      SomeType someType = (SomeType) o;
+      return typePattern.equals(someType.typePattern);
+    }
+
+    @Override
+    public int hashCode() {
+      return typePattern.hashCode();
+    }
+
+    @Override
+    public String toString() {
+      return typePattern.toString();
+    }
   }
 }

diff --git a/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepOptions.java b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepOptions.java
new file mode 100644
index 0000000..21b7487
--- /dev/null
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepOptions.java

@@ -0,0 +1,135 @@
+// Copyright (c) 2022, 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.keepanno.ast;
+
+import com.google.common.collect.ImmutableSet;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Objects;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public final class KeepOptions {
+
+  public boolean isKeepAll() {
+    return allowedOptions.isEmpty();
+  }
+
+  public enum KeepOption {
+    SHRINKING,
+    OPTIMIZING,
+    OBFUSCATING,
+    ACCESS_MODIFYING,
+  }
+
+  public static KeepOptions keepAll() {
+    if (ALLOW_NONE_INSTANCE == null) {
+      ALLOW_NONE_INSTANCE = new KeepOptions(ImmutableSet.of());
+    }
+    return ALLOW_NONE_INSTANCE;
+  }
+
+  public static Builder allowBuilder() {
+    return new Builder(true);
+  }
+
+  public static Builder disallowBuilder() {
+    return new Builder(false);
+  }
+
+  public static KeepOptions allow(KeepOption... options) {
+    return allowBuilder().addAll(options).build();
+  }
+
+  public static KeepOptions disallow(KeepOption... options) {
+    return disallowBuilder().addAll(options).build();
+  }
+
+  public static class Builder {
+    public final boolean allowIfSet;
+    public Set<KeepOption> options = new HashSet<>();
+
+    private Builder(boolean allowIfSet) {
+      this.allowIfSet = allowIfSet;
+    }
+
+    public Builder add(KeepOption option) {
+      options.add(option);
+      return this;
+    }
+
+    public Builder addAll(KeepOption... options) {
+      return addAll(Arrays.asList(options));
+    }
+
+    public Builder addAll(Collection<KeepOption> options) {
+      this.options.addAll(options);
+      return this;
+    }
+
+    public KeepOptions build() {
+      // Fast path check for the two variants of "keep all".
+      if (options.isEmpty()) {
+        if (allowIfSet) {
+          return keepAll();
+        }
+        throw new KeepEdgeException("Invalid keep options that disallow nothing.");
+      }
+      if (options.size() == KeepOption.values().length) {
+        if (!allowIfSet) {
+          return keepAll();
+        }
+        throw new KeepEdgeException("Invalid keep options that allow everything.");
+      }
+      // The normalized options is the "allow variant", if not of that form invert it on build.
+      if (allowIfSet) {
+        return new KeepOptions(ImmutableSet.copyOf(options));
+      }
+      ImmutableSet.Builder<KeepOption> invertedOptions = ImmutableSet.builder();
+      for (KeepOption option : KeepOption.values()) {
+        if (!options.contains(option)) {
+          invertedOptions.add(option);
+        }
+      }
+      return new KeepOptions(invertedOptions.build());
+    }
+  }
+
+  private static KeepOptions ALLOW_NONE_INSTANCE = null;
+
+  private final ImmutableSet<KeepOption> allowedOptions;
+
+  private KeepOptions(ImmutableSet<KeepOption> options) {
+    this.allowedOptions = options;
+  }
+
+  public boolean isAllowed(KeepOption option) {
+    return allowedOptions.contains(option);
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) {
+      return true;
+    }
+    if (o == null || getClass() != o.getClass()) {
+      return false;
+    }
+    KeepOptions that = (KeepOptions) o;
+    return allowedOptions.equals(that.allowedOptions);
+  }
+
+  @Override
+  public int hashCode() {
+    return allowedOptions.hashCode();
+  }
+
+  @Override
+  public String toString() {
+    return "KeepOptions{"
+        + allowedOptions.stream().map(Objects::toString).collect(Collectors.joining(", "))
+        + '}';
+  }
+}

diff --git a/src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepPackagePattern.java b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepPackagePattern.java
similarity index 93%
rename from src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepPackagePattern.java
rename to src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepPackagePattern.java
index 10db385..7d23490 100644
--- a/src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepPackagePattern.java
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepPackagePattern.java

@@ -1,7 +1,7 @@
 // Copyright (c) 2022, 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.experimental.keepanno.ast;
+package com.android.tools.r8.keepanno.ast;
 
 public abstract class KeepPackagePattern {
 
@@ -88,6 +88,11 @@
     public int hashCode() {
       return System.identityHashCode(this);
     }
+
+    @Override
+    public String toString() {
+      return "*";
+    }
   }
 
   private static final class KeepPackageTopPattern extends KeepPackageExactPattern {
@@ -114,6 +119,11 @@
     public boolean isTop() {
       return true;
     }
+
+    @Override
+    public String toString() {
+      return "";
+    }
   }
 
   public static class KeepPackageExactPattern extends KeepPackagePattern {
@@ -166,6 +176,11 @@
     public int hashCode() {
       return fullPackage.hashCode();
     }
+
+    @Override
+    public String toString() {
+      return fullPackage;
+    }
   }
 
   public abstract boolean isAny();

diff --git a/src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepPreconditions.java b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepPreconditions.java
similarity index 69%
rename from src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepPreconditions.java
rename to src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepPreconditions.java
index f3083df..f672013 100644
--- a/src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepPreconditions.java
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepPreconditions.java

@@ -1,7 +1,7 @@
 // Copyright (c) 2022, 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.experimental.keepanno.ast;
+package com.android.tools.r8.keepanno.ast;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -59,6 +59,21 @@
     public void forEach(Consumer<KeepCondition> fn) {
       // Empty.
     }
+
+    @Override
+    public boolean equals(Object obj) {
+      return this == obj;
+    }
+
+    @Override
+    public int hashCode() {
+      return System.identityHashCode(this);
+    }
+
+    @Override
+    public String toString() {
+      return "true";
+    }
   }
 
   private static class KeepPreconditionsSome extends KeepPreconditions {
@@ -66,6 +81,8 @@
     private final List<KeepCondition> preconditions;
 
     private KeepPreconditionsSome(List<KeepCondition> preconditions) {
+      assert preconditions != null;
+      assert !preconditions.isEmpty();
       this.preconditions = preconditions;
     }
 
@@ -78,5 +95,27 @@
     public void forEach(Consumer<KeepCondition> fn) {
       preconditions.forEach(fn);
     }
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) {
+        return true;
+      }
+      if (o == null || getClass() != o.getClass()) {
+        return false;
+      }
+      KeepPreconditionsSome that = (KeepPreconditionsSome) o;
+      return preconditions.equals(that.preconditions);
+    }
+
+    @Override
+    public int hashCode() {
+      return preconditions.hashCode();
+    }
+
+    @Override
+    public String toString() {
+      return preconditions.toString();
+    }
   }
 }

diff --git a/src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepQualifiedClassNamePattern.java b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepQualifiedClassNamePattern.java
similarity index 82%
rename from src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepQualifiedClassNamePattern.java
rename to src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepQualifiedClassNamePattern.java
index 9485580..97d01b9 100644
--- a/src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepQualifiedClassNamePattern.java
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepQualifiedClassNamePattern.java

@@ -1,7 +1,7 @@
 // Copyright (c) 2022, 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.experimental.keepanno.ast;
+package com.android.tools.r8.keepanno.ast;
 
 import java.util.Objects;
 
@@ -74,6 +74,21 @@
     return packagePattern.isAny() && namePattern.isAny();
   }
 
+  public boolean isExact() {
+    return packagePattern.isExact() && namePattern.isExact();
+  }
+
+  public String getExactDescriptor() {
+    if (!isExact()) {
+      throw new KeepEdgeException("Attempt to obtain exact qualified type for inexact pattern");
+    }
+    return 'L'
+        + packagePattern.asExact().getExactPackageAsString().replace('.', '/')
+        + (packagePattern.isTop() ? "" : "/")
+        + namePattern.asExact().getExactNameAsString()
+        + ';';
+  }
+
   public KeepPackagePattern getPackagePattern() {
     return packagePattern;
   }
@@ -98,4 +113,9 @@
   public int hashCode() {
     return Objects.hash(packagePattern.hashCode(), namePattern.hashCode());
   }
+
+  @Override
+  public String toString() {
+    return packagePattern + (packagePattern.isTop() ? "" : ".") + namePattern;
+  }
 }

diff --git a/src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepTarget.java b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepTarget.java
similarity index 67%
rename from src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepTarget.java
rename to src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepTarget.java
index a63a34a..111022b 100644
--- a/src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepTarget.java
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepTarget.java

@@ -1,7 +1,9 @@
 // Copyright (c) 2022, 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.experimental.keepanno.ast;
+package com.android.tools.r8.keepanno.ast;
+
+import java.util.Objects;
 
 public class KeepTarget {
 
@@ -38,6 +40,8 @@
   private final KeepOptions options;
 
   private KeepTarget(KeepItemPattern item, KeepOptions options) {
+    assert item != null;
+    assert options != null;
     this.item = item;
     this.options = options;
   }
@@ -53,4 +57,26 @@
   public KeepOptions getOptions() {
     return options;
   }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) {
+      return true;
+    }
+    if (o == null || getClass() != o.getClass()) {
+      return false;
+    }
+    KeepTarget that = (KeepTarget) o;
+    return item.equals(that.item) && options.equals(that.options);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(item, options);
+  }
+
+  @Override
+  public String toString() {
+    return "KeepTarget{" + "item=" + item + ", options=" + options + '}';
+  }
 }

diff --git a/src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepTypePattern.java b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepTypePattern.java
similarity index 69%
rename from src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepTypePattern.java
rename to src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepTypePattern.java
index eff9e9c..a790094 100644
--- a/src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepTypePattern.java
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepTypePattern.java

@@ -1,7 +1,7 @@
 // Copyright (c) 2022, 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.experimental.keepanno.ast;
+package com.android.tools.r8.keepanno.ast;
 
 public abstract class KeepTypePattern {
 
@@ -23,6 +23,21 @@
     public boolean isAny() {
       return true;
     }
+
+    @Override
+    public boolean equals(Object obj) {
+      return this == obj;
+    }
+
+    @Override
+    public int hashCode() {
+      return System.identityHashCode(this);
+    }
+
+    @Override
+    public String toString() {
+      return "*";
+    }
   }
 
   public abstract boolean isAny();

diff --git a/src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepUnqualfiedClassNamePattern.java b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepUnqualfiedClassNamePattern.java
similarity index 93%
rename from src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepUnqualfiedClassNamePattern.java
rename to src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepUnqualfiedClassNamePattern.java
index ab38ed2..c9ac380 100644
--- a/src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepUnqualfiedClassNamePattern.java
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/ast/KeepUnqualfiedClassNamePattern.java

@@ -1,7 +1,7 @@
 // Copyright (c) 2022, 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.experimental.keepanno.ast;
+package com.android.tools.r8.keepanno.ast;
 
 public abstract class KeepUnqualfiedClassNamePattern {
 
@@ -71,6 +71,11 @@
     public int hashCode() {
       return System.identityHashCode(this);
     }
+
+    @Override
+    public String toString() {
+      return "*";
+    }
   }
 
   public static class KeepClassNameExactPattern extends KeepUnqualfiedClassNamePattern {
@@ -117,6 +122,11 @@
     public int hashCode() {
       return className.hashCode();
     }
+
+    @Override
+    public String toString() {
+      return className;
+    }
   }
 
   public abstract boolean isAny();

diff --git a/src/main/java/com/android/tools/r8/experimental/keepanno/keeprules/KeepRuleExtractor.java b/src/keepanno/java/com/android/tools/r8/keepanno/keeprules/KeepRuleExtractor.java
similarity index 83%
rename from src/main/java/com/android/tools/r8/experimental/keepanno/keeprules/KeepRuleExtractor.java
rename to src/keepanno/java/com/android/tools/r8/keepanno/keeprules/KeepRuleExtractor.java
index 6c24ec1..d9b75ae 100644
--- a/src/main/java/com/android/tools/r8/experimental/keepanno/keeprules/KeepRuleExtractor.java
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/keeprules/KeepRuleExtractor.java

@@ -1,32 +1,31 @@
 // Copyright (c) 2022, 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.experimental.keepanno.keeprules;
+package com.android.tools.r8.keepanno.keeprules;
 
-import com.android.tools.r8.errors.Unimplemented;
-import com.android.tools.r8.experimental.keepanno.ast.KeepConsequences;
-import com.android.tools.r8.experimental.keepanno.ast.KeepEdge;
-import com.android.tools.r8.experimental.keepanno.ast.KeepFieldPattern;
-import com.android.tools.r8.experimental.keepanno.ast.KeepItemPattern.KeepClassPattern;
-import com.android.tools.r8.experimental.keepanno.ast.KeepMembersPattern;
-import com.android.tools.r8.experimental.keepanno.ast.KeepMethodAccessPattern;
-import com.android.tools.r8.experimental.keepanno.ast.KeepMethodNamePattern;
-import com.android.tools.r8.experimental.keepanno.ast.KeepMethodParametersPattern;
-import com.android.tools.r8.experimental.keepanno.ast.KeepMethodPattern;
-import com.android.tools.r8.experimental.keepanno.ast.KeepMethodReturnTypePattern;
-import com.android.tools.r8.experimental.keepanno.ast.KeepOptions;
-import com.android.tools.r8.experimental.keepanno.ast.KeepOptions.KeepOption;
-import com.android.tools.r8.experimental.keepanno.ast.KeepPackagePattern;
-import com.android.tools.r8.experimental.keepanno.ast.KeepPreconditions;
-import com.android.tools.r8.experimental.keepanno.ast.KeepQualifiedClassNamePattern;
-import com.android.tools.r8.experimental.keepanno.ast.KeepTarget;
-import com.android.tools.r8.experimental.keepanno.ast.KeepTypePattern;
-import com.android.tools.r8.experimental.keepanno.ast.KeepUnqualfiedClassNamePattern;
-import com.android.tools.r8.utils.StringUtils;
-import com.android.tools.r8.utils.StringUtils.BraceType;
+import com.android.tools.r8.keepanno.ast.KeepConsequences;
+import com.android.tools.r8.keepanno.ast.KeepEdge;
+import com.android.tools.r8.keepanno.ast.KeepFieldPattern;
+import com.android.tools.r8.keepanno.ast.KeepItemPattern.KeepClassPattern;
+import com.android.tools.r8.keepanno.ast.KeepMembersPattern;
+import com.android.tools.r8.keepanno.ast.KeepMethodAccessPattern;
+import com.android.tools.r8.keepanno.ast.KeepMethodNamePattern;
+import com.android.tools.r8.keepanno.ast.KeepMethodParametersPattern;
+import com.android.tools.r8.keepanno.ast.KeepMethodPattern;
+import com.android.tools.r8.keepanno.ast.KeepMethodReturnTypePattern;
+import com.android.tools.r8.keepanno.ast.KeepOptions;
+import com.android.tools.r8.keepanno.ast.KeepOptions.KeepOption;
+import com.android.tools.r8.keepanno.ast.KeepPackagePattern;
+import com.android.tools.r8.keepanno.ast.KeepPreconditions;
+import com.android.tools.r8.keepanno.ast.KeepQualifiedClassNamePattern;
+import com.android.tools.r8.keepanno.ast.KeepTarget;
+import com.android.tools.r8.keepanno.ast.KeepTypePattern;
+import com.android.tools.r8.keepanno.ast.KeepUnqualfiedClassNamePattern;
+import com.android.tools.r8.keepanno.utils.Unimplemented;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.function.Consumer;
+import java.util.stream.Collectors;
 
 public class KeepRuleExtractor {
 
@@ -151,7 +150,11 @@
       StringBuilder builder, KeepMethodParametersPattern parametersPattern) {
     return parametersPattern.match(
         () -> builder.append("(***)"),
-        list -> StringUtils.append(builder, list, ", ", BraceType.PARENS));
+        list ->
+            builder
+                .append('(')
+                .append(list.stream().map(Object::toString).collect(Collectors.joining(", ")))
+                .append(')'));
   }
 
   private static StringBuilder printMethodName(
@@ -220,7 +223,7 @@
         return "optimization";
       case OBFUSCATING:
         return "obfuscation";
-      case ACCESS_MODIFING:
+      case ACCESS_MODIFYING:
         return "accessmodification";
       default:
         throw new Unimplemented();

diff --git a/src/keepanno/java/com/android/tools/r8/keepanno/processor/KeepEdgeProcessor.java b/src/keepanno/java/com/android/tools/r8/keepanno/processor/KeepEdgeProcessor.java
new file mode 100644
index 0000000..36bbaeb
--- /dev/null
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/processor/KeepEdgeProcessor.java

@@ -0,0 +1,279 @@
+// Copyright (c) 2022, 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.keepanno.processor;
+
+import static org.objectweb.asm.Opcodes.ACC_FINAL;
+import static org.objectweb.asm.Opcodes.ACC_PUBLIC;
+import static org.objectweb.asm.Opcodes.ACC_SUPER;
+
+import com.android.tools.r8.keepanno.annotations.KeepConstants;
+import com.android.tools.r8.keepanno.annotations.KeepConstants.Edge;
+import com.android.tools.r8.keepanno.annotations.KeepConstants.Target;
+import com.android.tools.r8.keepanno.asm.KeepEdgeReader;
+import com.android.tools.r8.keepanno.asm.KeepEdgeWriter;
+import com.android.tools.r8.keepanno.ast.KeepConsequences;
+import com.android.tools.r8.keepanno.ast.KeepEdge;
+import com.android.tools.r8.keepanno.ast.KeepEdge.Builder;
+import com.android.tools.r8.keepanno.ast.KeepItemPattern;
+import com.android.tools.r8.keepanno.ast.KeepMembersPattern;
+import com.android.tools.r8.keepanno.ast.KeepMethodNamePattern;
+import com.android.tools.r8.keepanno.ast.KeepMethodPattern;
+import com.android.tools.r8.keepanno.ast.KeepQualifiedClassNamePattern;
+import com.android.tools.r8.keepanno.ast.KeepTarget;
+import com.android.tools.r8.keepanno.utils.Unimplemented;
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Consumer;
+import javax.annotation.processing.AbstractProcessor;
+import javax.annotation.processing.Filer;
+import javax.annotation.processing.RoundEnvironment;
+import javax.annotation.processing.SupportedAnnotationTypes;
+import javax.annotation.processing.SupportedSourceVersion;
+import javax.lang.model.SourceVersion;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.AnnotationValue;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.TypeMirror;
+import javax.lang.model.util.SimpleAnnotationValueVisitor7;
+import javax.lang.model.util.SimpleTypeVisitor7;
+import javax.tools.Diagnostic.Kind;
+import javax.tools.JavaFileObject;
+import org.objectweb.asm.ClassWriter;
+
+@SupportedAnnotationTypes("com.android.tools.r8.keepanno.annotations.*")
+@SupportedSourceVersion(SourceVersion.RELEASE_7)
+public class KeepEdgeProcessor extends AbstractProcessor {
+
+  public static String getClassTypeNameForSynthesizedEdges(String classTypeName) {
+    return classTypeName + "$$KeepEdges";
+  }
+
+  @Override
+  public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
+    for (Element rootElement : roundEnv.getRootElements()) {
+      TypeElement typeElement = getEnclosingTypeElement(rootElement);
+      KeepEdge edge = processKeepEdge(typeElement, roundEnv);
+      if (edge != null) {
+        String edgeTargetClass =
+            getClassTypeNameForSynthesizedEdges(typeElement.getQualifiedName().toString());
+        byte[] writtenEdge = writeEdge(edge, edgeTargetClass);
+        Filer filer = processingEnv.getFiler();
+        try {
+          JavaFileObject classFile = filer.createClassFile(edgeTargetClass);
+          classFile.openOutputStream().write(writtenEdge);
+        } catch (IOException e) {
+          error(e.getMessage());
+        }
+      }
+    }
+    return true;
+  }
+
+  private static byte[] writeEdge(KeepEdge edge, String classTypeName) {
+    String classBinaryName = KeepConstants.getBinaryNameFromClassTypeName(classTypeName);
+    ClassWriter classWriter = new ClassWriter(0);
+    classWriter.visit(
+        KeepEdgeReader.ASM_VERSION,
+        ACC_PUBLIC | ACC_FINAL | ACC_SUPER,
+        classBinaryName,
+        null,
+        "java/lang/Object",
+        null);
+    classWriter.visitSource("SynthesizedKeepEdge", null);
+    KeepEdgeWriter.writeEdge(edge, classWriter);
+    classWriter.visitEnd();
+    return classWriter.toByteArray();
+  }
+
+  private KeepEdge processKeepEdge(TypeElement keepEdge, RoundEnvironment roundEnv) {
+    AnnotationMirror mirror = getAnnotationMirror(keepEdge, KeepConstants.Edge.CLASS);
+    if (mirror == null) {
+      return null;
+    }
+    Builder edgeBuilder = KeepEdge.builder();
+    processPreconditions(edgeBuilder, mirror);
+    processConsequences(edgeBuilder, mirror);
+    return edgeBuilder.build();
+  }
+
+  private void processPreconditions(Builder edgeBuilder, AnnotationMirror mirror) {
+    AnnotationValue preconditions = getAnnotationValue(mirror, Edge.preconditions);
+    if (preconditions == null) {
+      return;
+    }
+    throw new Unimplemented();
+  }
+
+  private void processConsequences(Builder edgeBuilder, AnnotationMirror mirror) {
+    AnnotationValue consequences = getAnnotationValue(mirror, Edge.consequences);
+    if (consequences == null) {
+      return;
+    }
+    KeepConsequences.Builder consequencesBuilder = KeepConsequences.builder();
+    new AnnotationListValueVisitor(
+            value -> {
+              KeepTarget.Builder targetBuilder = KeepTarget.builder();
+              processTarget(targetBuilder, AnnotationMirrorValueVisitor.getMirror(value));
+              consequencesBuilder.addTarget(targetBuilder.build());
+            })
+        .onValue(consequences);
+    edgeBuilder.setConsequences(consequencesBuilder.build());
+  }
+
+  private void processTarget(KeepTarget.Builder builder, AnnotationMirror mirror) {
+    KeepItemPattern.Builder itemBuilder = KeepItemPattern.builder();
+    AnnotationValue classConstantValue = getAnnotationValue(mirror, Target.classConstant);
+    if (classConstantValue != null) {
+      DeclaredType type = AnnotationClassValueVisitor.getType(classConstantValue);
+      itemBuilder.setClassPattern(KeepQualifiedClassNamePattern.exact(type.toString()));
+    }
+    AnnotationValue methodNameValue = getAnnotationValue(mirror, Target.methodName);
+    if (methodNameValue != null) {
+      String methodName = AnnotationStringValueVisitor.getString(methodNameValue);
+      itemBuilder.setMembersPattern(
+          KeepMembersPattern.builder()
+              .addMethodPattern(
+                  KeepMethodPattern.builder()
+                      .setNamePattern(KeepMethodNamePattern.exact(methodName))
+                      .build())
+              .build());
+    }
+
+    builder.setItem(itemBuilder.build());
+  }
+
+  private void error(String message) {
+    processingEnv.getMessager().printMessage(Kind.ERROR, message);
+  }
+
+  private static TypeElement getEnclosingTypeElement(Element element) {
+    while (true) {
+      if (element == null || element instanceof TypeElement) {
+        return (TypeElement) element;
+      }
+      element = element.getEnclosingElement();
+    }
+  }
+
+  private static AnnotationMirror getAnnotationMirror(TypeElement typeElement, Class<?> clazz) {
+    String clazzName = clazz.getName();
+    for (AnnotationMirror m : typeElement.getAnnotationMirrors()) {
+      if (m.getAnnotationType().toString().equals(clazzName)) {
+        return m;
+      }
+    }
+    return null;
+  }
+
+  private static AnnotationValue getAnnotationValue(AnnotationMirror annotationMirror, String key) {
+    for (Map.Entry<? extends ExecutableElement, ? extends AnnotationValue> entry :
+        annotationMirror.getElementValues().entrySet()) {
+      if (entry.getKey().getSimpleName().toString().equals(key)) {
+        return entry.getValue();
+      }
+    }
+    return null;
+  }
+
+  /// Annotation Visitors
+
+  private abstract static class AnnotationValueVisitorBase<T>
+      extends SimpleAnnotationValueVisitor7<T, Object> {
+    @Override
+    protected T defaultAction(Object o1, Object o2) {
+      throw new IllegalStateException();
+    }
+
+    public T onValue(AnnotationValue value) {
+      return value.accept(this, null);
+    }
+  }
+
+  private static class AnnotationListValueVisitor
+      extends AnnotationValueVisitorBase<AnnotationListValueVisitor> {
+
+    private final Consumer<AnnotationValue> fn;
+
+    public AnnotationListValueVisitor(Consumer<AnnotationValue> fn) {
+      this.fn = fn;
+    }
+
+    @Override
+    public AnnotationListValueVisitor visitArray(
+        List<? extends AnnotationValue> values, Object ignore) {
+      values.forEach(fn);
+      return this;
+    }
+  }
+
+  private static class AnnotationMirrorValueVisitor
+      extends AnnotationValueVisitorBase<AnnotationMirrorValueVisitor> {
+
+    private AnnotationMirror mirror = null;
+
+    public static AnnotationMirror getMirror(AnnotationValue value) {
+      return new AnnotationMirrorValueVisitor().onValue(value).mirror;
+    }
+
+    @Override
+    public AnnotationMirrorValueVisitor visitAnnotation(AnnotationMirror mirror, Object o) {
+      this.mirror = mirror;
+      return this;
+    }
+  }
+
+  private static class AnnotationStringValueVisitor
+      extends AnnotationValueVisitorBase<AnnotationStringValueVisitor> {
+    private String string;
+
+    public static String getString(AnnotationValue value) {
+      return new AnnotationStringValueVisitor().onValue(value).string;
+    }
+
+    @Override
+    public AnnotationStringValueVisitor visitString(String string, Object ignore) {
+      this.string = string;
+      return this;
+    }
+  }
+
+  private static class AnnotationClassValueVisitor
+      extends AnnotationValueVisitorBase<AnnotationClassValueVisitor> {
+    private DeclaredType type = null;
+
+    public static DeclaredType getType(AnnotationValue value) {
+      return new AnnotationClassValueVisitor().onValue(value).type;
+    }
+
+    @Override
+    public AnnotationClassValueVisitor visitType(TypeMirror t, Object ignore) {
+      ClassTypeVisitor classTypeVisitor = new ClassTypeVisitor();
+      t.accept(classTypeVisitor, null);
+      type = classTypeVisitor.type;
+      return this;
+    }
+  }
+
+  private static class TypeVisitorBase<T> extends SimpleTypeVisitor7<T, Object> {
+    @Override
+    protected T defaultAction(TypeMirror typeMirror, Object ignore) {
+      throw new IllegalStateException();
+    }
+  }
+
+  private static class ClassTypeVisitor extends TypeVisitorBase<ClassTypeVisitor> {
+    private DeclaredType type = null;
+
+    @Override
+    public ClassTypeVisitor visitDeclared(DeclaredType t, Object ignore) {
+      this.type = t;
+      return this;
+    }
+  }
+}

diff --git a/src/keepanno/java/com/android/tools/r8/keepanno/utils/Unimplemented.java b/src/keepanno/java/com/android/tools/r8/keepanno/utils/Unimplemented.java
new file mode 100644
index 0000000..8293126
--- /dev/null
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/utils/Unimplemented.java

@@ -0,0 +1,12 @@
+// Copyright (c) 2022, 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.keepanno.utils;
+
+public class Unimplemented extends RuntimeException {
+  public Unimplemented() {}
+
+  public Unimplemented(String msg) {
+    super(msg);
+  }
+}

diff --git a/src/library_desugar/java/java/nio/file/FileApiFlips.java b/src/library_desugar/java/java/nio/file/FileApiFlips.java
index b68aeb2..9c8a46a 100644
--- a/src/library_desugar/java/java/nio/file/FileApiFlips.java
+++ b/src/library_desugar/java/java/nio/file/FileApiFlips.java

@@ -101,32 +101,35 @@
     throw exception("java.nio.file.attribute.FileTime", suffix);
   }
 
+  public static Object flipMaybeFileTime(Object val) {
+    if (val instanceof j$.nio.file.attribute.FileTime) {
+      j$.nio.file.attribute.FileTime fileTime;
+      try {
+        fileTime = (j$.nio.file.attribute.FileTime) val;
+      } catch (ClassCastException cce) {
+        throw exceptionFileTime(cce);
+      }
+      return FileAttributeConversions.convert(fileTime);
+    }
+    if (val instanceof java.nio.file.attribute.FileTime) {
+      java.nio.file.attribute.FileTime fileTime;
+      try {
+        fileTime = (java.nio.file.attribute.FileTime) val;
+      } catch (ClassCastException cce) {
+        throw exceptionFileTime(cce);
+      }
+      return FileAttributeConversions.convert(fileTime);
+    }
+    return val;
+  }
+
   public static Map<String, Object> flipMapWithMaybeFileTimeValues(Map<String, Object> in) {
     if (in == null || in.isEmpty()) {
       return in;
     }
     HashMap<String, Object> newMap = new HashMap<>();
     for (String key : in.keySet()) {
-      Object val = in.get(key);
-      if (val instanceof j$.nio.file.attribute.FileTime) {
-        j$.nio.file.attribute.FileTime fileTime;
-        try {
-          fileTime = (j$.nio.file.attribute.FileTime) val;
-        } catch (ClassCastException cce) {
-          throw exceptionFileTime(cce);
-        }
-        newMap.put(key, FileAttributeConversions.convert(fileTime));
-      } else if (val instanceof java.nio.file.attribute.FileTime) {
-        java.nio.file.attribute.FileTime fileTime;
-        try {
-          fileTime = (java.nio.file.attribute.FileTime) val;
-        } catch (ClassCastException cce) {
-          throw exceptionFileTime(cce);
-        }
-        newMap.put(key, FileAttributeConversions.convert(fileTime));
-      } else {
-        newMap.put(key, val);
-      }
+      newMap.put(key, flipMaybeFileTime(in.get(key)));
     }
     return newMap;
   }

diff --git a/src/library_desugar/jdk11/desugar_jdk_libs_nio.json b/src/library_desugar/jdk11/desugar_jdk_libs_nio.json
index ff05a80..c97bd79 100644
--- a/src/library_desugar/jdk11/desugar_jdk_libs_nio.json
+++ b/src/library_desugar/jdk11/desugar_jdk_libs_nio.json

@@ -7,6 +7,13 @@
   "common_flags": [
     {
       "api_level_below_or_equal": 10000,
+      "amend_library_method": [
+        "public static java.nio.file.Path java.nio.file.Path#of(java.lang.String, java.lang.String[])",
+        "public static java.nio.file.Path java.nio.file.Path#of(java.net.URI)"
+      ]
+    },
+    {
+      "api_level_below_or_equal": 10000,
       "api_level_greater_or_equal": 24,
       "rewrite_prefix": {
         "java.util.stream.DesugarDoubleStream": "j$.util.stream.DesugarDoubleStream",
@@ -35,13 +42,15 @@
         "long java.util.concurrent.TimeUnit#convert(java.time.Duration)": "java.util.concurrent.DesugarTimeUnit"
       },
       "retarget_method_with_emulated_dispatch": {
-        "long java.io.InputStream#transferTo(java.io.OutputStream)": "java.io.DesugarInputStream"
+        "long java.io.InputStream#transferTo(java.io.OutputStream)": "java.io.DesugarInputStream",
+        "long java.io.ByteArrayInputStream#transferTo(java.io.OutputStream)": "long java.io.DesugarInputStream#transferTo(java.io.InputStream, java.io.OutputStream)"
       },
       "amend_library_method": [
         "public static java.util.concurrent.TimeUnit java.util.concurrent.TimeUnit#of(java.time.temporal.ChronoUnit)",
         "public java.time.temporal.ChronoUnit java.util.concurrent.TimeUnit#toChronoUnit()",
         "public long java.util.concurrent.TimeUnit#convert(java.time.Duration)",
-        "public long java.io.InputStream#transferTo(java.io.OutputStream)"
+        "public long java.io.InputStream#transferTo(java.io.OutputStream)",
+        "public long java.io.ByteArrayInputStream#transferTo(java.io.OutputStream)"
       ]
     },
     {
@@ -220,7 +229,8 @@
         "java.util.Map java.nio.file.spi.FileSystemProvider#readAttributes(java.nio.file.Path, java.lang.String, java.nio.file.LinkOption[])" : [-1, "java.util.Map java.nio.file.FileApiFlips#flipMapWithMaybeFileTimeValues(java.util.Map)"],
         "java.lang.Iterable java.nio.file.FileSystem#getRootDirectories()": [-1, "java.lang.Iterable java.nio.file.PathApiFlips#flipIterablePath(java.lang.Iterable)"],
         "java.util.Iterator java.nio.file.Path#iterator()": [-1, "java.util.Iterator java.nio.file.PathApiFlips#flipIteratorPath(java.util.Iterator)"],
-        "java.nio.file.DirectoryStream java.nio.file.spi.FileSystemProvider#newDirectoryStream(java.nio.file.Path, java.nio.file.DirectoryStream$Filter)": [-1, "java.nio.file.DirectoryStream java.nio.file.PathApiFlips#flipDirectoryStreamPath(java.nio.file.DirectoryStream)", 1, "java.nio.file.DirectoryStream$Filter java.nio.file.PathApiFlips#flipDirectoryStreamFilterPath(java.nio.file.DirectoryStream$Filter)"]
+        "java.nio.file.DirectoryStream java.nio.file.spi.FileSystemProvider#newDirectoryStream(java.nio.file.Path, java.nio.file.DirectoryStream$Filter)": [-1, "java.nio.file.DirectoryStream java.nio.file.PathApiFlips#flipDirectoryStreamPath(java.nio.file.DirectoryStream)", 1, "java.nio.file.DirectoryStream$Filter java.nio.file.PathApiFlips#flipDirectoryStreamFilterPath(java.nio.file.DirectoryStream$Filter)"],
+        "void java.nio.file.spi.FileSystemProvider#setAttribute(java.nio.file.Path, java.lang.String, java.lang.Object, java.nio.file.LinkOption[])": [2, "java.lang.Object java.nio.file.FileApiFlips#flipMaybeFileTime(java.lang.Object)"]
       },
       "wrapper_conversion": [
         "java.nio.channels.CompletionHandler",
@@ -403,6 +413,14 @@
       ]
     },
     {
+      "api_level_below_or_equal": 10000,
+      "api_level_greater_or_equal": 26,
+      "retarget_method": {
+        "java.nio.file.Path java.nio.file.Path#of(java.lang.String, java.lang.String[])": "java.nio.file.Path java.nio.file.Paths#get(java.lang.String, java.lang.String[])",
+        "java.nio.file.Path java.nio.file.Path#of(java.net.URI)": "java.nio.file.Path java.nio.file.Paths#get(java.net.URI)"
+      }
+    },
+    {
       "api_level_below_or_equal": 33,
       "amend_library_method": [
         "public java.lang.Object[] java.util.Collection#toArray(java.util.function.IntFunction)"

diff --git a/src/main/java/com/android/tools/r8/cf/code/CfInvoke.java b/src/main/java/com/android/tools/r8/cf/code/CfInvoke.java
index 249de08..84334f5 100644
--- a/src/main/java/com/android/tools/r8/cf/code/CfInvoke.java
+++ b/src/main/java/com/android/tools/r8/cf/code/CfInvoke.java

@@ -131,7 +131,8 @@
       String owner = namingLens.lookupInternalName(rewrittenMethod.holder);
       String name = namingLens.lookupName(rewrittenMethod).toString();
       String desc = rewrittenMethod.proto.toDescriptorString(namingLens);
-      visitor.visitMethodInsn(rewrittenType.getCfOpcode(), owner, name, desc, itf);
+      visitor.visitMethodInsn(
+          rewrittenType.getCfOpcode(), owner, name, desc, rewrittenType.isInterface() || itf);
     }
   }
 

diff --git a/src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepEdge.java b/src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepEdge.java
deleted file mode 100644
index f61483a..0000000
--- a/src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepEdge.java
+++ /dev/null

@@ -1,57 +0,0 @@
-// Copyright (c) 2022, 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.experimental.keepanno.ast;
-
-/**
- * An edge in the keep graph.
- *
- * <p>An edge describes a set of preconditions and a set of consequences. If the preconditions are
- * met, then the consequences are put into effect.
- */
-public final class KeepEdge {
-
-  public static class Builder {
-    private KeepPreconditions preconditions = KeepPreconditions.always();
-    private KeepConsequences consequences;
-
-    private Builder() {}
-
-    public Builder setPreconditions(KeepPreconditions preconditions) {
-      this.preconditions = preconditions;
-      return this;
-    }
-
-    public Builder setConsequences(KeepConsequences consequences) {
-      this.consequences = consequences;
-      return this;
-    }
-
-    public KeepEdge build() {
-      if (consequences.isEmpty()) {
-        throw new KeepEdgeException("KeepEdge must have non-empty set of consequences.");
-      }
-      return new KeepEdge(preconditions, consequences);
-    }
-  }
-
-  public static Builder builder() {
-    return new Builder();
-  }
-
-  private final KeepPreconditions preconditions;
-  private final KeepConsequences consequences;
-
-  private KeepEdge(KeepPreconditions preconditions, KeepConsequences consequences) {
-    this.preconditions = preconditions;
-    this.consequences = consequences;
-  }
-
-  public KeepPreconditions getPreconditions() {
-    return preconditions;
-  }
-
-  public KeepConsequences getConsequences() {
-    return consequences;
-  }
-}

diff --git a/src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepMethodAccessPattern.java b/src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepMethodAccessPattern.java
deleted file mode 100644
index 7f83937..0000000
--- a/src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepMethodAccessPattern.java
+++ /dev/null

@@ -1,16 +0,0 @@
-// Copyright (c) 2022, 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.experimental.keepanno.ast;
-
-// TODO: finish this.
-public class KeepMethodAccessPattern {
-
-  public static KeepMethodAccessPattern any() {
-    return new KeepMethodAccessPattern();
-  }
-
-  public boolean isAny() {
-    return true;
-  }
-}

diff --git a/src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepOptions.java b/src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepOptions.java
deleted file mode 100644
index 9fb521c..0000000
--- a/src/main/java/com/android/tools/r8/experimental/keepanno/ast/KeepOptions.java
+++ /dev/null

@@ -1,97 +0,0 @@
-// Copyright (c) 2022, 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.experimental.keepanno.ast;
-
-import com.android.tools.r8.utils.SetUtils;
-import com.google.common.collect.ImmutableSet;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Set;
-
-public final class KeepOptions {
-
-  public enum KeepOption {
-    SHRINKING,
-    OPTIMIZING,
-    OBFUSCATING,
-    ACCESS_MODIFING,
-  }
-
-  public static KeepOptions keepAll() {
-    if (ALLOW_NONE_INSTANCE == null) {
-      ALLOW_NONE_INSTANCE = new KeepOptions(true, Collections.emptySet());
-    }
-    return ALLOW_NONE_INSTANCE;
-  }
-
-  public static Builder allowBuilder() {
-    return new Builder(true);
-  }
-
-  public static Builder disallowBuilder() {
-    return new Builder(false);
-  }
-
-  public static KeepOptions allow(KeepOption... options) {
-    return allowBuilder().addAll(options).build();
-  }
-
-  public static KeepOptions disallow(KeepOption... options) {
-    return disallowBuilder().addAll(options).build();
-  }
-
-  public static class Builder {
-    public final boolean allowIfSet;
-    public Set<KeepOption> options = SetUtils.newIdentityHashSet();
-
-    private Builder(boolean allowIfSet) {
-      this.allowIfSet = allowIfSet;
-    }
-
-    public Builder add(KeepOption option) {
-      options.add(option);
-      return this;
-    }
-
-    public Builder addAll(KeepOption... options) {
-      return addAll(Arrays.asList(options));
-    }
-
-    public Builder addAll(Collection<KeepOption> options) {
-      this.options.addAll(options);
-      return this;
-    }
-
-    public KeepOptions build() {
-      if (options.isEmpty()) {
-        if (allowIfSet) {
-          return keepAll();
-        }
-        throw new KeepEdgeException("Invalid keep options that disallow nothing.");
-      }
-      if (options.size() == KeepOption.values().length) {
-        if (!allowIfSet) {
-          return keepAll();
-        }
-        throw new KeepEdgeException("Invalid keep options that allow everything.");
-      }
-      return new KeepOptions(allowIfSet, ImmutableSet.copyOf(options));
-    }
-  }
-
-  private static KeepOptions ALLOW_NONE_INSTANCE = null;
-
-  private final boolean allowIfSet;
-  private final Set<KeepOption> options;
-
-  private KeepOptions(boolean allowIfSet, Set<KeepOption> options) {
-    this.allowIfSet = allowIfSet;
-    this.options = options;
-  }
-
-  public boolean isAllowed(KeepOption option) {
-    return options.contains(option) == allowIfSet;
-  }
-}

diff --git a/src/main/java/com/android/tools/r8/graph/AccessFlags.java b/src/main/java/com/android/tools/r8/graph/AccessFlags.java
index 10620fc6..ee86680 100644
--- a/src/main/java/com/android/tools/r8/graph/AccessFlags.java
+++ b/src/main/java/com/android/tools/r8/graph/AccessFlags.java

@@ -109,25 +109,14 @@
   }
 
   public boolean isMoreVisibleThan(
-      AccessFlags other, String packageNameThis, String packageNameOther) {
+      AccessFlags<?> other, String packageNameThis, String packageNameOther) {
     int visibilityOrdinal = getVisibilityOrdinal();
     if (visibilityOrdinal > other.getVisibilityOrdinal()) {
       return true;
     }
-    if (visibilityOrdinal == other.getVisibilityOrdinal()
+    return visibilityOrdinal == other.getVisibilityOrdinal()
         && isVisibilityDependingOnPackage()
-        && !packageNameThis.equals(packageNameOther)) {
-      return true;
-    }
-    return false;
-  }
-
-  public boolean isAtLeastAsVisibleAs(AccessFlags other) {
-    return getVisibilityOrdinal() >= other.getVisibilityOrdinal();
-  }
-
-  public boolean isSameVisibility(AccessFlags other) {
-    return getVisibilityOrdinal() == other.getVisibilityOrdinal();
+        && !packageNameThis.equals(packageNameOther);
   }
 
   public int getVisibilityOrdinal() {

diff --git a/src/main/java/com/android/tools/r8/graph/AppInfoWithClassHierarchy.java b/src/main/java/com/android/tools/r8/graph/AppInfoWithClassHierarchy.java
index 42f5d96..369e60c 100644
--- a/src/main/java/com/android/tools/r8/graph/AppInfoWithClassHierarchy.java
+++ b/src/main/java/com/android/tools/r8/graph/AppInfoWithClassHierarchy.java

@@ -536,7 +536,7 @@
     assert potentialHolder.isInterface();
     for (DexEncodedMethod virtualMethod : potentialHolder.virtualMethods()) {
       if (virtualMethod.getReference().match(method.getReference())
-          && virtualMethod.accessFlags.isSameVisibility(method.accessFlags)) {
+          && virtualMethod.isSameVisibility(method)) {
         return true;
       }
     }

diff --git a/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java b/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
index d68d906..985e215 100644
--- a/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
+++ b/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java

@@ -569,6 +569,40 @@
     return isStatic();
   }
 
+  public boolean isAtLeastAsVisibleAsOtherInSameHierarchy(
+      DexEncodedMethod other, AppView<? extends AppInfoWithClassHierarchy> appView) {
+    assert getReference().getProto() == other.getReference().getProto();
+    assert appView.isSubtype(getHolderType(), other.getHolderType()).isTrue()
+        || appView.isSubtype(other.getHolderType(), getHolderType()).isTrue();
+    AccessFlags<MethodAccessFlags> accessFlags = getAccessFlags();
+    AccessFlags<?> otherAccessFlags = other.getAccessFlags();
+    if (accessFlags.getVisibilityOrdinal() < otherAccessFlags.getVisibilityOrdinal()) {
+      return false;
+    } else if (accessFlags.isPrivate()) {
+      return getHolderType() == other.getHolderType();
+    } else if (accessFlags.isPublic() || accessFlags.isProtected()) {
+      return true;
+    } else {
+      assert accessFlags.isPackagePrivate();
+      return getHolderType().getPackageName().equals(other.getHolderType().getPackageName());
+    }
+  }
+
+  public boolean isSameVisibility(DexEncodedMethod other) {
+    AccessFlags<MethodAccessFlags> accessFlags = getAccessFlags();
+    if (accessFlags.getVisibilityOrdinal() != other.getAccessFlags().getVisibilityOrdinal()) {
+      return false;
+    }
+    if (accessFlags.isPublic()) {
+      return true;
+    }
+    if (accessFlags.isPrivate()) {
+      return getHolderType() == other.getHolderType();
+    }
+    assert accessFlags.isVisibilityDependingOnPackage();
+    return getHolderType().getPackageName().equals(other.getHolderType().getPackageName());
+  }
+
   /**
    * Returns true if this method is synthetic.
    */

diff --git a/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/humanspecification/HumanDesugaredLibrarySpecificationParser.java b/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/humanspecification/HumanDesugaredLibrarySpecificationParser.java
index 16c578b..8f7f2b6 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/humanspecification/HumanDesugaredLibrarySpecificationParser.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/humanspecification/HumanDesugaredLibrarySpecificationParser.java

@@ -302,9 +302,26 @@
     if (jsonFlagSet.has(RETARGET_METHOD_KEY)) {
       for (Map.Entry<String, JsonElement> retarget :
           jsonFlagSet.get(RETARGET_METHOD_KEY).getAsJsonObject().entrySet()) {
-        builder.retargetMethod(
-            parseMethod(retarget.getKey()),
-            stringDescriptorToDexType(retarget.getValue().getAsString()));
+        String key = retarget.getKey();
+        String value = retarget.getValue().getAsString();
+        if (value.contains("#")) {
+          builder.retargetMethodToMethod(parseMethod(key), parseMethod(value));
+        } else {
+          builder.retargetMethodToType(parseMethod(key), stringDescriptorToDexType(value));
+        }
+      }
+    }
+    if (jsonFlagSet.has(RETARGET_METHOD_EMULATED_DISPATCH_KEY)) {
+      for (Map.Entry<String, JsonElement> retarget :
+          jsonFlagSet.get(RETARGET_METHOD_EMULATED_DISPATCH_KEY).getAsJsonObject().entrySet()) {
+        String key = retarget.getKey();
+        String value = retarget.getValue().getAsString();
+        if (value.contains("#")) {
+          builder.retargetMethodEmulatedDispatchToMethod(parseMethod(key), parseMethod(value));
+        } else {
+          builder.retargetMethodEmulatedDispatchToType(
+              parseMethod(key), stringDescriptorToDexType(value));
+        }
       }
     }
     if (jsonFlagSet.has(COVARIANT_RETARGET_METHOD_KEY)) {
@@ -315,14 +332,6 @@
             stringDescriptorToDexType(retarget.getValue().getAsString()));
       }
     }
-    if (jsonFlagSet.has(RETARGET_METHOD_EMULATED_DISPATCH_KEY)) {
-      for (Map.Entry<String, JsonElement> retarget :
-          jsonFlagSet.get(RETARGET_METHOD_EMULATED_DISPATCH_KEY).getAsJsonObject().entrySet()) {
-        builder.retargetMethodEmulatedDispatch(
-            parseMethod(retarget.getKey()),
-            stringDescriptorToDexType(retarget.getValue().getAsString()));
-      }
-    }
     if (jsonFlagSet.has(BACKPORT_KEY)) {
       for (Map.Entry<String, JsonElement> backport :
           jsonFlagSet.get(BACKPORT_KEY).getAsJsonObject().entrySet()) {

diff --git a/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/humanspecification/HumanRewritingFlags.java b/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/humanspecification/HumanRewritingFlags.java
index 8c4316f..314d657 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/humanspecification/HumanRewritingFlags.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/humanspecification/HumanRewritingFlags.java

@@ -32,8 +32,10 @@
   private final Map<DexType, DexType> emulatedInterfaces;
   private final Map<DexField, DexField> retargetStaticField;
   private final Map<DexMethod, DexType> covariantRetarget;
-  private final Map<DexMethod, DexType> retargetMethod;
-  private final Map<DexMethod, DexType> retargetMethodEmulatedDispatch;
+  private final Map<DexMethod, DexType> retargetMethodToType;
+  private final Map<DexMethod, DexType> retargetMethodEmulatedDispatchToType;
+  private final Map<DexMethod, DexMethod> retargetMethodToMethod;
+  private final Map<DexMethod, DexMethod> retargetMethodEmulatedDispatchToMethod;
   private final Map<DexMethod, DexMethod[]> apiGenericTypesConversion;
   private final Map<DexType, DexType> legacyBackport;
   private final Map<DexType, DexType> customConversions;
@@ -52,8 +54,10 @@
       Map<DexType, DexType> emulateLibraryInterface,
       Map<DexField, DexField> retargetStaticField,
       Map<DexMethod, DexType> covariantRetarget,
-      Map<DexMethod, DexType> retargetMethod,
-      Map<DexMethod, DexType> retargetMethodEmulatedDispatch,
+      Map<DexMethod, DexType> retargetMethodToType,
+      Map<DexMethod, DexType> retargetMethodEmulatedDispatchToType,
+      Map<DexMethod, DexMethod> retargetMethodToMethod,
+      Map<DexMethod, DexMethod> retargetMethodEmulatedDispatchToMethod,
       Map<DexMethod, DexMethod[]> apiGenericTypesConversion,
       Map<DexType, DexType> legacyBackport,
       Map<DexType, DexType> customConversion,
@@ -70,8 +74,10 @@
     this.emulatedInterfaces = emulateLibraryInterface;
     this.retargetStaticField = retargetStaticField;
     this.covariantRetarget = covariantRetarget;
-    this.retargetMethod = retargetMethod;
-    this.retargetMethodEmulatedDispatch = retargetMethodEmulatedDispatch;
+    this.retargetMethodToType = retargetMethodToType;
+    this.retargetMethodEmulatedDispatchToType = retargetMethodEmulatedDispatchToType;
+    this.retargetMethodToMethod = retargetMethodToMethod;
+    this.retargetMethodEmulatedDispatchToMethod = retargetMethodEmulatedDispatchToMethod;
     this.apiGenericTypesConversion = apiGenericTypesConversion;
     this.legacyBackport = legacyBackport;
     this.customConversions = customConversion;
@@ -97,6 +103,8 @@
         ImmutableMap.of(),
         ImmutableMap.of(),
         ImmutableMap.of(),
+        ImmutableMap.of(),
+        ImmutableMap.of(),
         ImmutableSet.of(),
         ImmutableSet.of(),
         ImmutableMap.of(),
@@ -120,8 +128,10 @@
         emulatedInterfaces,
         retargetStaticField,
         covariantRetarget,
-        retargetMethod,
-        retargetMethodEmulatedDispatch,
+        retargetMethodToType,
+        retargetMethodEmulatedDispatchToType,
+        retargetMethodToMethod,
+        retargetMethodEmulatedDispatchToMethod,
         apiGenericTypesConversion,
         legacyBackport,
         customConversions,
@@ -161,12 +171,20 @@
     return covariantRetarget;
   }
 
-  public Map<DexMethod, DexType> getRetargetMethod() {
-    return retargetMethod;
+  public Map<DexMethod, DexType> getRetargetMethodToType() {
+    return retargetMethodToType;
   }
 
-  public Map<DexMethod, DexType> getRetargetMethodEmulatedDispatch() {
-    return retargetMethodEmulatedDispatch;
+  public Map<DexMethod, DexType> getRetargetMethodEmulatedDispatchToType() {
+    return retargetMethodEmulatedDispatchToType;
+  }
+
+  public Map<DexMethod, DexMethod> getRetargetMethodToMethod() {
+    return retargetMethodToMethod;
+  }
+
+  public Map<DexMethod, DexMethod> getRetargetMethodEmulatedDispatchToMethod() {
+    return retargetMethodEmulatedDispatchToMethod;
   }
 
   public Set<DexMethod> getNeverOutlineApi() {
@@ -211,8 +229,8 @@
         && maintainPrefix.isEmpty()
         && emulatedInterfaces.isEmpty()
         && covariantRetarget.isEmpty()
-        && retargetMethod.isEmpty()
-        && retargetMethodEmulatedDispatch.isEmpty()
+        && retargetMethodToType.isEmpty()
+        && retargetMethodEmulatedDispatchToType.isEmpty()
         && retargetStaticField.isEmpty();
   }
 
@@ -228,8 +246,10 @@
     private final Map<DexType, DexType> emulatedInterfaces;
     private final Map<DexField, DexField> retargetStaticField;
     private final Map<DexMethod, DexType> covariantRetarget;
-    private final Map<DexMethod, DexType> retargetMethod;
-    private final Map<DexMethod, DexType> retargetMethodEmulatedDispatch;
+    private final Map<DexMethod, DexType> retargetMethodToType;
+    private final Map<DexMethod, DexType> retargetMethodEmulatedDispatchToType;
+    private final Map<DexMethod, DexMethod> retargetMethodToMethod;
+    private final Map<DexMethod, DexMethod> retargetMethodEmulatedDispatchToMethod;
     private final Map<DexMethod, DexMethod[]> apiGenericTypesConversion;
     private final Map<DexType, DexType> legacyBackport;
     private final Map<DexType, DexType> customConversions;
@@ -256,6 +276,8 @@
           new IdentityHashMap<>(),
           new IdentityHashMap<>(),
           new IdentityHashMap<>(),
+          new IdentityHashMap<>(),
+          new IdentityHashMap<>(),
           Sets.newIdentityHashSet(),
           Sets.newIdentityHashSet(),
           new IdentityHashMap<>(),
@@ -274,8 +296,10 @@
         Map<DexType, DexType> emulateLibraryInterface,
         Map<DexField, DexField> retargetStaticField,
         Map<DexMethod, DexType> covariantRetarget,
-        Map<DexMethod, DexType> retargetMethod,
-        Map<DexMethod, DexType> retargetMethodEmulatedDispatch,
+        Map<DexMethod, DexType> retargetMethodToType,
+        Map<DexMethod, DexType> retargetMethodEmulatedDispatchToType,
+        Map<DexMethod, DexMethod> retargetMethodToMethod,
+        Map<DexMethod, DexMethod> retargetMethodEmulatedDispatchToMethod,
         Map<DexMethod, DexMethod[]> apiConversionCollection,
         Map<DexType, DexType> backportCoreLibraryMember,
         Map<DexType, DexType> customConversions,
@@ -294,8 +318,12 @@
       this.emulatedInterfaces = new IdentityHashMap<>(emulateLibraryInterface);
       this.retargetStaticField = new IdentityHashMap<>(retargetStaticField);
       this.covariantRetarget = new IdentityHashMap<>(covariantRetarget);
-      this.retargetMethod = new IdentityHashMap<>(retargetMethod);
-      this.retargetMethodEmulatedDispatch = new IdentityHashMap<>(retargetMethodEmulatedDispatch);
+      this.retargetMethodToType = new IdentityHashMap<>(retargetMethodToType);
+      this.retargetMethodEmulatedDispatchToType =
+          new IdentityHashMap<>(retargetMethodEmulatedDispatchToType);
+      this.retargetMethodToMethod = new IdentityHashMap<>(retargetMethodToMethod);
+      this.retargetMethodEmulatedDispatchToMethod =
+          new IdentityHashMap<>(retargetMethodEmulatedDispatchToMethod);
       this.apiGenericTypesConversion = new IdentityHashMap<>(apiConversionCollection);
       this.legacyBackport = new IdentityHashMap<>(backportCoreLibraryMember);
       this.customConversions = new IdentityHashMap<>(customConversions);
@@ -384,15 +412,42 @@
       return this;
     }
 
-    public Builder retargetMethod(DexMethod key, DexType rewrittenType) {
+    public Builder retargetMethodToType(DexMethod key, DexType rewrittenType) {
       put(
-          retargetMethod,
+          retargetMethodToType,
           key,
           rewrittenType,
           HumanDesugaredLibrarySpecificationParser.RETARGET_METHOD_KEY);
       return this;
     }
 
+    public Builder retargetMethodEmulatedDispatchToType(DexMethod key, DexType rewrittenType) {
+      put(
+          retargetMethodEmulatedDispatchToType,
+          key,
+          rewrittenType,
+          HumanDesugaredLibrarySpecificationParser.RETARGET_METHOD_EMULATED_DISPATCH_KEY);
+      return this;
+    }
+
+    public Builder retargetMethodToMethod(DexMethod key, DexMethod retarget) {
+      put(
+          retargetMethodToMethod,
+          key,
+          retarget,
+          HumanDesugaredLibrarySpecificationParser.RETARGET_METHOD_KEY);
+      return this;
+    }
+
+    public Builder retargetMethodEmulatedDispatchToMethod(DexMethod key, DexMethod retarget) {
+      put(
+          retargetMethodEmulatedDispatchToMethod,
+          key,
+          retarget,
+          HumanDesugaredLibrarySpecificationParser.RETARGET_METHOD_EMULATED_DISPATCH_KEY);
+      return this;
+    }
+
     public Builder covariantRetargetMethod(DexMethod key, DexType rewrittenType) {
       put(
           covariantRetarget,
@@ -411,15 +466,6 @@
       return this;
     }
 
-    public Builder retargetMethodEmulatedDispatch(DexMethod key, DexType rewrittenType) {
-      put(
-          retargetMethodEmulatedDispatch,
-          key,
-          rewrittenType,
-          HumanDesugaredLibrarySpecificationParser.RETARGET_METHOD_EMULATED_DISPATCH_KEY);
-      return this;
-    }
-
     public void addApiGenericTypesConversion(DexMethod method, int index, DexMethod conversion) {
       DexMethod[] types =
           apiGenericTypesConversion.computeIfAbsent(
@@ -473,8 +519,10 @@
           ImmutableMap.copyOf(emulatedInterfaces),
           ImmutableMap.copyOf(retargetStaticField),
           ImmutableMap.copyOf(covariantRetarget),
-          ImmutableMap.copyOf(retargetMethod),
-          ImmutableMap.copyOf(retargetMethodEmulatedDispatch),
+          ImmutableMap.copyOf(retargetMethodToType),
+          ImmutableMap.copyOf(retargetMethodEmulatedDispatchToType),
+          ImmutableMap.copyOf(retargetMethodToMethod),
+          ImmutableMap.copyOf(retargetMethodEmulatedDispatchToMethod),
           ImmutableMap.copyOf(apiGenericTypesConversion),
           ImmutableMap.copyOf(legacyBackport),
           ImmutableMap.copyOf(customConversions),

diff --git a/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/humanspecification/MultiAPILevelHumanDesugaredLibrarySpecificationFlagDeduplicator.java b/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/humanspecification/MultiAPILevelHumanDesugaredLibrarySpecificationFlagDeduplicator.java
index 6283419..ad9735c 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/humanspecification/MultiAPILevelHumanDesugaredLibrarySpecificationFlagDeduplicator.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/humanspecification/MultiAPILevelHumanDesugaredLibrarySpecificationFlagDeduplicator.java

@@ -93,15 +93,15 @@
         commonBuilder::putEmulatedInterface,
         builder::putEmulatedInterface);
     deduplicateFlags(
-        flags.getRetargetMethod(),
-        otherFlags.getRetargetMethod(),
-        commonBuilder::retargetMethod,
-        builder::retargetMethod);
+        flags.getRetargetMethodToType(),
+        otherFlags.getRetargetMethodToType(),
+        commonBuilder::retargetMethodToType,
+        builder::retargetMethodToType);
     deduplicateFlags(
-        flags.getRetargetMethodEmulatedDispatch(),
-        otherFlags.getRetargetMethodEmulatedDispatch(),
-        commonBuilder::retargetMethodEmulatedDispatch,
-        builder::retargetMethodEmulatedDispatch);
+        flags.getRetargetMethodEmulatedDispatchToType(),
+        otherFlags.getRetargetMethodEmulatedDispatchToType(),
+        commonBuilder::retargetMethodEmulatedDispatchToType,
+        builder::retargetMethodEmulatedDispatchToType);
     deduplicateFlags(
         flags.getLegacyBackport(),
         otherFlags.getLegacyBackport(),

diff --git a/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/humanspecification/MultiAPILevelHumanDesugaredLibrarySpecificationJsonExporter.java b/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/humanspecification/MultiAPILevelHumanDesugaredLibrarySpecificationJsonExporter.java
index 736632a..2096b33 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/humanspecification/MultiAPILevelHumanDesugaredLibrarySpecificationJsonExporter.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/humanspecification/MultiAPILevelHumanDesugaredLibrarySpecificationJsonExporter.java

@@ -124,13 +124,22 @@
       if (!flags.getRetargetStaticField().isEmpty()) {
         toJson.put(RETARGET_STATIC_FIELD_KEY, mapToString(flags.getRetargetStaticField()));
       }
-      if (!flags.getRetargetMethod().isEmpty()) {
-        toJson.put(RETARGET_METHOD_KEY, mapToString(flags.getRetargetMethod()));
+      if (!flags.getRetargetMethodToType().isEmpty()) {
+        toJson.put(RETARGET_METHOD_KEY, mapToString(flags.getRetargetMethodToType()));
       }
-      if (!flags.getRetargetMethodEmulatedDispatch().isEmpty()) {
+      if (!flags.getRetargetMethodEmulatedDispatchToMethod().isEmpty()) {
+        toJson.put(
+            RETARGET_METHOD_KEY, mapToString(flags.getRetargetMethodEmulatedDispatchToMethod()));
+      }
+      if (!flags.getRetargetMethodEmulatedDispatchToType().isEmpty()) {
         toJson.put(
             RETARGET_METHOD_EMULATED_DISPATCH_KEY,
-            mapToString(flags.getRetargetMethodEmulatedDispatch()));
+            mapToString(flags.getRetargetMethodEmulatedDispatchToType()));
+      }
+      if (!flags.getRetargetMethodEmulatedDispatchToMethod().isEmpty()) {
+        toJson.put(
+            RETARGET_METHOD_EMULATED_DISPATCH_KEY,
+            mapToString(flags.getRetargetMethodEmulatedDispatchToMethod()));
       }
       if (!flags.getDontRetarget().isEmpty()) {
         toJson.put(DONT_RETARGET_KEY, setToString(flags.getDontRetarget()));

diff --git a/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/specificationconversion/HumanToMachineEmulatedInterfaceConverter.java b/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/specificationconversion/HumanToMachineEmulatedInterfaceConverter.java
index 5f385c5..00c7da1 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/specificationconversion/HumanToMachineEmulatedInterfaceConverter.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/specificationconversion/HumanToMachineEmulatedInterfaceConverter.java

@@ -95,7 +95,7 @@
     LinkedHashMap<DexType, DerivedMethod> extraDispatchCases = new LinkedHashMap<>();
     // Retarget core lib emulated dispatch handled as part of emulated interface dispatch.
     Map<DexMethod, DexType> retargetCoreLibMember =
-        rewritingFlags.getRetargetMethodEmulatedDispatch();
+        rewritingFlags.getRetargetMethodEmulatedDispatchToType();
     for (DexMethod retarget : retargetCoreLibMember.keySet()) {
       if (retarget.match(method)) {
         DexClass inClass = appInfo.definitionFor(retarget.getHolderType());

diff --git a/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/specificationconversion/HumanToMachinePrefixConverter.java b/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/specificationconversion/HumanToMachinePrefixConverter.java
index a1a8d29..7a669c2 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/specificationconversion/HumanToMachinePrefixConverter.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/specificationconversion/HumanToMachinePrefixConverter.java

@@ -50,11 +50,14 @@
   public void convertPrefixFlags(
       HumanRewritingFlags rewritingFlags, BiConsumer<String, Set<DexString>> warnConsumer) {
     rewriteClasses();
-    rewriteValues(rewritingFlags.getRetargetMethod());
-    rewriteValues(rewritingFlags.getRetargetMethodEmulatedDispatch());
+    rewriteValues(rewritingFlags.getRetargetMethodToType());
+    rewriteValues(rewritingFlags.getRetargetMethodEmulatedDispatchToType());
     rewriteValues(rewritingFlags.getCustomConversions());
+    rewriteMethodValues(rewritingFlags.getRetargetMethodToMethod());
+    rewriteMethodValues(rewritingFlags.getRetargetMethodEmulatedDispatchToMethod());
     rewriteEmulatedInterface(rewritingFlags.getEmulatedInterfaces());
-    rewriteRetargetKeys(rewritingFlags.getRetargetMethodEmulatedDispatch());
+    rewriteRetargetKeys(rewritingFlags.getRetargetMethodEmulatedDispatchToType());
+    rewriteRetargetKeys(rewritingFlags.getRetargetMethodEmulatedDispatchToMethod());
     rewriteApiConversions(rewritingFlags.getApiGenericConversion());
     warnIfUnusedPrefix(warnConsumer);
   }
@@ -79,7 +82,7 @@
                 convertedPrefix + interfaceType.substring(firstPackage + 1)));
   }
 
-  private void rewriteRetargetKeys(Map<DexMethod, DexType> retarget) {
+  private void rewriteRetargetKeys(Map<DexMethod, ?> retarget) {
     for (DexMethod dexMethod : retarget.keySet()) {
       DexType type = convertJavaNameToDesugaredLibrary(dexMethod.holder);
       builder.rewriteDerivedTypeOnly(dexMethod.holder, type);
@@ -108,6 +111,12 @@
     }
   }
 
+  private void rewriteMethodValues(Map<?, DexMethod> flags) {
+    for (DexMethod method : flags.values()) {
+      registerType(method.getHolderType());
+    }
+  }
+
   private void rewriteClasses() {
     appInfo.app().forEachLibraryType(this::registerClassType);
     if (libraryCompilation) {

diff --git a/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/specificationconversion/HumanToMachineRetargetConverter.java b/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/specificationconversion/HumanToMachineRetargetConverter.java
index 6078e9d..004c35f 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/specificationconversion/HumanToMachineRetargetConverter.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/specificationconversion/HumanToMachineRetargetConverter.java

@@ -24,6 +24,7 @@
 import java.util.Map;
 import java.util.Set;
 import java.util.function.BiConsumer;
+import java.util.function.Consumer;
 
 public class HumanToMachineRetargetConverter {
 
@@ -45,13 +46,22 @@
         .getCovariantRetarget()
         .forEach((method, type) -> convertCovariantRetarget(builder, method, type));
     rewritingFlags
-        .getRetargetMethod()
-        .forEach((method, type) -> convertRetargetMethod(builder, method, type));
+        .getRetargetMethodToType()
+        .forEach((method, type) -> convertRetargetMethodToType(builder, method, type));
     rewritingFlags
-        .getRetargetMethodEmulatedDispatch()
+        .getRetargetMethodEmulatedDispatchToType()
         .forEach(
             (method, type) ->
-                convertRetargetMethodEmulatedDispatch(builder, rewritingFlags, method, type));
+                convertRetargetMethodEmulatedDispatchToType(builder, rewritingFlags, method, type));
+    rewritingFlags
+        .getRetargetMethodToMethod()
+        .forEach((method, retarget) -> convertRetargetMethodToMethod(builder, method, retarget));
+    rewritingFlags
+        .getRetargetMethodEmulatedDispatchToMethod()
+        .forEach(
+            (method, retarget) ->
+                convertRetargetMethodEmulatedDispatchToMethod(
+                    builder, rewritingFlags, method, retarget));
     warnConsumer.accept("Cannot retarget missing references: ", missingReferences);
   }
 
@@ -66,37 +76,6 @@
     builder.putStaticFieldRetarget(field, rewrittenField);
   }
 
-  private void convertRetargetMethodEmulatedDispatch(
-      MachineRewritingFlags.Builder builder,
-      HumanRewritingFlags rewritingFlags,
-      DexMethod method,
-      DexType type) {
-    DexClass holder = appInfo.definitionFor(method.holder);
-    DexEncodedMethod foundMethod = holder.lookupMethod(method);
-    if (foundMethod == null) {
-      missingReferences.add(method);
-      return;
-    }
-    if (foundMethod.isStatic()) {
-      appInfo
-          .app()
-          .options
-          .reporter
-          .error("Cannot generate emulated dispatch for static method " + foundMethod);
-      return;
-    }
-    if (!seemsToNeedEmulatedDispatch(holder, foundMethod)) {
-      appInfo
-          .app()
-          .options
-          .reporter
-          .warning(
-              "Generating (seemingly unnecessary) emulated dispatch for final method "
-                  + foundMethod);
-    }
-    convertEmulatedVirtualRetarget(builder, rewritingFlags, foundMethod, type);
-  }
-
   private void convertCovariantRetarget(
       MachineRewritingFlags.Builder builder, DexMethod method, DexType type) {
     DexClass holder = appInfo.definitionFor(method.holder);
@@ -133,7 +112,9 @@
   }
 
   private void convertRetargetMethod(
-      MachineRewritingFlags.Builder builder, DexMethod method, DexType type) {
+      DexMethod method,
+      Consumer<DexEncodedMethod> staticRetarget,
+      Consumer<DexEncodedMethod> nonEmulatedVirtualRetarget) {
     DexClass holder = appInfo.definitionFor(method.holder);
     DexEncodedMethod foundMethod = holder.lookupMethod(method);
     if (foundMethod == null) {
@@ -141,7 +122,7 @@
       return;
     }
     if (foundMethod.isStatic()) {
-      convertStaticRetarget(builder, foundMethod, type);
+      staticRetarget.accept(foundMethod);
       return;
     }
     if (seemsToNeedEmulatedDispatch(holder, foundMethod)) {
@@ -154,7 +135,72 @@
                   + foundMethod
                   + " which could lead to invalid runtime execution in overrides.");
     }
-    convertNonEmulatedVirtualRetarget(builder, foundMethod, type);
+    nonEmulatedVirtualRetarget.accept(foundMethod);
+  }
+
+  private void convertRetargetMethodToType(
+      MachineRewritingFlags.Builder builder, DexMethod method, DexType type) {
+    convertRetargetMethod(
+        method,
+        foundMethod -> convertStaticRetarget(builder, foundMethod, type),
+        foundMethod -> convertNonEmulatedVirtualRetarget(builder, foundMethod, type));
+  }
+
+  private void convertRetargetMethodToMethod(
+      MachineRewritingFlags.Builder builder, DexMethod method, DexMethod retarget) {
+    convertRetargetMethod(
+        method,
+        foundMethod -> builder.putStaticRetarget(method, retarget),
+        foundMethod -> builder.putNonEmulatedVirtualRetarget(method, retarget));
+  }
+
+  private void convertRetargetMethodEmulatedDispatch(
+      DexMethod method, Consumer<DexEncodedMethod> emulatedRetarget) {
+    DexClass holder = appInfo.definitionFor(method.holder);
+    DexEncodedMethod foundMethod = holder.lookupMethod(method);
+    if (foundMethod == null) {
+      missingReferences.add(method);
+      return;
+    }
+    if (foundMethod.isStatic()) {
+      appInfo
+          .app()
+          .options
+          .reporter
+          .error("Cannot generate emulated dispatch for static method " + foundMethod);
+      return;
+    }
+    if (!seemsToNeedEmulatedDispatch(holder, foundMethod)) {
+      appInfo
+          .app()
+          .options
+          .reporter
+          .warning(
+              "Generating (seemingly unnecessary) emulated dispatch for final method "
+                  + foundMethod);
+    }
+    emulatedRetarget.accept(foundMethod);
+  }
+
+  private void convertRetargetMethodEmulatedDispatchToType(
+      MachineRewritingFlags.Builder builder,
+      HumanRewritingFlags rewritingFlags,
+      DexMethod method,
+      DexType type) {
+    convertRetargetMethodEmulatedDispatch(
+        method,
+        foundMethod -> convertEmulatedVirtualRetarget(builder, rewritingFlags, foundMethod, type));
+  }
+
+  private void convertRetargetMethodEmulatedDispatchToMethod(
+      MachineRewritingFlags.Builder builder,
+      HumanRewritingFlags rewritingFlags,
+      DexMethod method,
+      DexMethod retarget) {
+    convertRetargetMethodEmulatedDispatch(
+        method,
+        foundMethod ->
+            convertEmulatedVirtualRetarget(builder, rewritingFlags, foundMethod, retarget));
   }
 
   private boolean seemsToNeedEmulatedDispatch(DexClass holder, DexEncodedMethod method) {
@@ -166,10 +212,7 @@
       MachineRewritingFlags.Builder builder,
       HumanRewritingFlags rewritingFlags,
       DexEncodedMethod src,
-      DexType type) {
-    DexProto newProto = appInfo.dexItemFactory().prependHolderToProto(src.getReference());
-    DexMethod forwardingDexMethod =
-        appInfo.dexItemFactory().createMethod(type, newProto, src.getName());
+      DexMethod forwardingDexMethod) {
     if (isEmulatedInterfaceDispatch(src, appInfo, rewritingFlags)) {
       // Handled by emulated interface dispatch.
       builder.putEmulatedVirtualRetargetThroughEmulatedInterface(
@@ -190,6 +233,17 @@
             interfaceMethod, dispatchMethod, forwardingMethod, dispatchCases));
   }
 
+  private void convertEmulatedVirtualRetarget(
+      MachineRewritingFlags.Builder builder,
+      HumanRewritingFlags rewritingFlags,
+      DexEncodedMethod src,
+      DexType type) {
+    DexProto newProto = appInfo.dexItemFactory().prependHolderToProto(src.getReference());
+    DexMethod forwardingDexMethod =
+        appInfo.dexItemFactory().createMethod(type, newProto, src.getName());
+    convertEmulatedVirtualRetarget(builder, rewritingFlags, src, forwardingDexMethod);
+  }
+
   private boolean isEmulatedInterfaceDispatch(
       DexEncodedMethod method,
       AppInfoWithClassHierarchy appInfo,

diff --git a/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/specificationconversion/LegacyToHumanSpecificationConverter.java b/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/specificationconversion/LegacyToHumanSpecificationConverter.java
index b251add..1f7fe89 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/specificationconversion/LegacyToHumanSpecificationConverter.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/specificationconversion/LegacyToHumanSpecificationConverter.java

@@ -161,7 +161,7 @@
           itemFactory.createMethod(
               itemFactory.createType(itemFactory.arraysDescriptor), proto, name);
       DexType target = itemFactory.createType("Ljava/util/DesugarArrays;");
-      builder.retargetMethod(source, target);
+      builder.retargetMethodToType(source, target);
 
       builder.amendLibraryMethod(
           source,
@@ -178,7 +178,7 @@
       source =
           itemFactory.createMethod(itemFactory.createType("Ljava/util/TimeZone;"), proto, name);
       target = itemFactory.createType("Ljava/util/DesugarTimeZone;");
-      builder.retargetMethod(source, target);
+      builder.retargetMethodToType(source, target);
     }
     // Required by
     // https://github.com/google/desugar_jdk_libs/commit/485071cd09a3691549d065ba9e323d07edccf085.
@@ -272,9 +272,9 @@
             if (definition.isStatic()
                 || definition.isFinal()
                 || dexClassAndMethod.getHolder().isFinal()) {
-              builder.retargetMethod(dexClassAndMethod.getReference(), rewrittenType);
+              builder.retargetMethodToType(dexClassAndMethod.getReference(), rewrittenType);
             } else {
-              builder.retargetMethodEmulatedDispatch(
+              builder.retargetMethodEmulatedDispatchToType(
                   dexClassAndMethod.getReference(), rewrittenType);
             }
           }

diff --git a/src/main/java/com/android/tools/r8/ir/optimize/CodeRewriter.java b/src/main/java/com/android/tools/r8/ir/optimize/CodeRewriter.java
index 6099074..3d9b8d2 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/CodeRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/CodeRewriter.java

@@ -2220,8 +2220,7 @@
       InstructionListIterator it = block.listIterator(code);
       while (it.hasNext()) {
         Instruction instruction = it.next();
-        if (instruction.getLocalInfo() != null
-            || !allowNewFilledArrayConstruction(instruction)) {
+        if (instruction.getLocalInfo() != null || !allowNewFilledArrayConstruction(instruction)) {
           continue;
         }
         NewArrayEmpty newArray = instruction.asNewArrayEmpty();

diff --git a/src/main/java/com/android/tools/r8/ir/optimize/Devirtualizer.java b/src/main/java/com/android/tools/r8/ir/optimize/Devirtualizer.java
index 8a023db..08f3912 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/Devirtualizer.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/Devirtualizer.java

@@ -395,8 +395,7 @@
             .isPossiblyFalse()
         || !newResolutionResult
             .getResolvedMethod()
-            .getAccessFlags()
-            .isAtLeastAsVisibleAs(resolutionResult.getResolvedMethod().getAccessFlags())
+            .isAtLeastAsVisibleAsOtherInSameHierarchy(resolutionResult.getResolvedMethod(), appView)
         // isOverriding expects both arguments to be not private.
         || (!newResolutionResult.getResolvedMethod().isPrivateMethod()
             && !isOverriding(

diff --git a/src/main/java/com/android/tools/r8/optimize/MemberRebindingIdentityLens.java b/src/main/java/com/android/tools/r8/optimize/MemberRebindingIdentityLens.java
index 0cc861f..0dbea46 100644
--- a/src/main/java/com/android/tools/r8/optimize/MemberRebindingIdentityLens.java
+++ b/src/main/java/com/android/tools/r8/optimize/MemberRebindingIdentityLens.java

@@ -86,7 +86,13 @@
   }
 
   private DexMethod getReboundMethodReference(DexMethod method) {
-    return nonReboundMethodReferenceToDefinitionMap.getOrDefault(method, method);
+    DexMethod rebound = nonReboundMethodReferenceToDefinitionMap.get(method);
+    while (rebound != null) {
+      method = rebound;
+      rebound = nonReboundMethodReferenceToDefinitionMap.get(method);
+    }
+    assert method != rebound;
+    return method;
   }
 
   @Override

diff --git a/src/main/java/com/android/tools/r8/optimize/RedundantBridgeRemover.java b/src/main/java/com/android/tools/r8/optimize/RedundantBridgeRemover.java
index d0066e0..5cbb1b6 100644
--- a/src/main/java/com/android/tools/r8/optimize/RedundantBridgeRemover.java
+++ b/src/main/java/com/android/tools/r8/optimize/RedundantBridgeRemover.java

@@ -10,12 +10,17 @@
 import com.android.tools.r8.graph.DexEncodedMethod;
 import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.MethodResolutionResult;
+import com.android.tools.r8.graph.MethodResolutionResult.FailedResolutionResult;
+import com.android.tools.r8.graph.MethodResolutionResult.SingleResolutionResult;
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.graph.PrunedItems;
 import com.android.tools.r8.ir.optimize.info.bridge.BridgeInfo;
 import com.android.tools.r8.optimize.InvokeSingleTargetExtractor.InvokeKind;
 import com.android.tools.r8.optimize.redundantbridgeremoval.RedundantBridgeRemovalLens;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.android.tools.r8.shaking.KeepMethodInfo;
 import com.android.tools.r8.utils.collections.ProgramMethodSet;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
@@ -31,12 +36,7 @@
   }
 
   private DexClassAndMethod getTargetForRedundantBridge(ProgramMethod method) {
-    // Clean-up the predicate check.
-    if (appView.appInfo().isPinned(method.getReference())) {
-      return null;
-    }
     DexEncodedMethod definition = method.getDefinition();
-    // TODO(b/197490164): Remove if method is abstract.
     BridgeInfo bridgeInfo = definition.getOptimizationInfo().getBridgeInfo();
     boolean isBridge = definition.isBridge() || bridgeInfo != null;
     if (!isBridge || definition.isAbstract()) {
@@ -59,18 +59,10 @@
     if (targetMethod == null) {
       return null;
     }
-    if (method.getAccessFlags().isPublic()) {
-      if (!targetMethod.getAccessFlags().isPublic()) {
-        return null;
-      }
-    } else {
-      if (targetMethod.getAccessFlags().isProtected()
-          && !targetMethod.getHolderType().isSamePackage(method.getHolderType())) {
-        return null;
-      }
-      if (targetMethod.getAccessFlags().isPrivate()) {
-        return null;
-      }
+    if (!targetMethod
+        .getDefinition()
+        .isAtLeastAsVisibleAsOtherInSameHierarchy(method.getDefinition(), appView)) {
+      return null;
     }
     if (definition.isStatic()
         && method.getHolder().hasClassInitializer()
@@ -148,6 +140,16 @@
           ProgramMethodSet bridgesToRemoveForClass = ProgramMethodSet.create();
           clazz.forEachProgramMethod(
               method -> {
+                KeepMethodInfo keepInfo = appView.getKeepInfo(method);
+                if (!keepInfo.isShrinkingAllowed(appView.options())
+                    || !keepInfo.isOptimizationAllowed(appView.options())) {
+                  return;
+                }
+                if (isRedundantAbstractBridge(method)) {
+                  // Record that the redundant bridge should be removed.
+                  bridgesToRemoveForClass.add(method);
+                  return;
+                }
                 DexClassAndMethod target = getTargetForRedundantBridge(method);
                 if (target != null) {
                   // Record that the redundant bridge should be removed.
@@ -175,6 +177,55 @@
     return bridgesToRemove;
   }
 
+  private boolean isRedundantAbstractBridge(ProgramMethod method) {
+    if (!method.getAccessFlags().isAbstract() || method.getDefinition().getCode() != null) {
+      return false;
+    }
+    DexProgramClass holder = method.getHolder();
+    if (holder.getSuperType() == null) {
+      assert holder.getType() == appView.dexItemFactory().objectType;
+      return false;
+    }
+    MethodResolutionResult superTypeResolution =
+        appView.appInfo().resolveMethodOn(holder.getSuperType(), method.getReference(), false);
+    if (superTypeResolution.isMultiMethodResolutionResult()) {
+      return false;
+    }
+    // Check if there is a definition in the super type hieararchy that is also abstract and has the
+    // same visibility.
+    if (superTypeResolution.isSingleResolution()) {
+      DexClassAndMethod resolutionPair =
+          superTypeResolution.asSingleResolution().getResolutionPair();
+      return resolutionPair.getDefinition().isAbstract()
+          && resolutionPair
+              .getDefinition()
+              .isAtLeastAsVisibleAsOtherInSameHierarchy(method.getDefinition(), appView)
+          && (!resolutionPair.getHolder().isInterface() || holder.getInterfaces().isEmpty());
+    }
+    // Only check for interfaces if resolving the method on super type causes NoSuchMethodError.
+    FailedResolutionResult failedResolutionResult = superTypeResolution.asFailedResolution();
+    if (failedResolutionResult == null
+        || !failedResolutionResult.isNoSuchMethodErrorResult(holder, appView.appInfo())
+        || holder.getInterfaces().isEmpty()) {
+      return false;
+    }
+    for (DexType iface : holder.getInterfaces()) {
+      SingleResolutionResult<?> singleIfaceResult =
+          appView
+              .appInfo()
+              .resolveMethodOn(iface, method.getReference(), true)
+              .asSingleResolution();
+      if (singleIfaceResult == null
+          || !singleIfaceResult.getResolvedMethod().isAbstract()
+          || !singleIfaceResult
+              .getResolvedMethod()
+              .isAtLeastAsVisibleAsOtherInSameHierarchy(method.getDefinition(), appView)) {
+        return false;
+      }
+    }
+    return true;
+  }
+
   private void pruneApp(
       Map<DexProgramClass, ProgramMethodSet> bridgesToRemove, ExecutorService executorService)
       throws ExecutionException {

diff --git a/src/main/java/com/android/tools/r8/optimize/redundantbridgeremoval/RedundantBridgeRemovalLens.java b/src/main/java/com/android/tools/r8/optimize/redundantbridgeremoval/RedundantBridgeRemovalLens.java
index a680b36..042cc6a 100644
--- a/src/main/java/com/android/tools/r8/optimize/redundantbridgeremoval/RedundantBridgeRemovalLens.java
+++ b/src/main/java/com/android/tools/r8/optimize/redundantbridgeremoval/RedundantBridgeRemovalLens.java

@@ -13,6 +13,7 @@
 import com.android.tools.r8.graph.GraphLens.NonIdentityGraphLens;
 import com.android.tools.r8.graph.ProgramMethod;
 import com.android.tools.r8.graph.proto.RewrittenPrototypeDescription;
+import com.android.tools.r8.ir.code.Invoke;
 import com.google.common.collect.Sets;
 import java.util.IdentityHashMap;
 import java.util.Map;
@@ -80,14 +81,18 @@
       do {
         newReference = methodMap.get(newReference);
       } while (methodMap.containsKey(newReference));
-      if (previous.getType().isSuper() && interfaces.contains(newReference.getHolderType())) {
+      boolean holderTypeIsInterface = interfaces.contains(newReference.getHolderType());
+      if (previous.getType().isSuper() && holderTypeIsInterface) {
         return previous;
       }
       return MethodLookupResult.builder(this)
           .setReference(newReference)
           .setReboundReference(newReference)
           .setPrototypeChanges(previous.getPrototypeChanges())
-          .setType(previous.getType())
+          .setType(
+              holderTypeIsInterface && previous.getType().isVirtual()
+                  ? Invoke.Type.INTERFACE
+                  : previous.getType())
           .build();
     }
     return previous;

diff --git a/src/main/java/com/android/tools/r8/utils/InternalOptions.java b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
index 9af4f06..e653a7a 100644
--- a/src/main/java/com/android/tools/r8/utils/InternalOptions.java
+++ b/src/main/java/com/android/tools/r8/utils/InternalOptions.java

@@ -1548,7 +1548,8 @@
     private boolean enableInterfaceMerging =
         System.getProperty("com.android.tools.r8.enableHorizontalInterfaceMerging") != null;
     private boolean enableInterfaceMergingInInitial = false;
-    private boolean enableSameFilePolicy = false;
+    private boolean enableSameFilePolicy =
+        System.getProperty("com.android.tools.r8.enableSameFilePolicy") != null;
     private boolean enableSyntheticMerging = true;
     private boolean ignoreRuntimeTypeChecksForTesting = false;
     private boolean restrictToSynthetics = false;

diff --git a/src/main/java/com/android/tools/r8/utils/ZipUtils.java b/src/main/java/com/android/tools/r8/utils/ZipUtils.java
index fc9157d..43b1b02 100644
--- a/src/main/java/com/android/tools/r8/utils/ZipUtils.java
+++ b/src/main/java/com/android/tools/r8/utils/ZipUtils.java

@@ -13,6 +13,7 @@
 import com.android.tools.r8.ResourceException;
 import com.android.tools.r8.androidapi.AndroidApiDataAccess;
 import com.android.tools.r8.errors.CompilationError;
+import com.android.tools.r8.references.ClassReference;
 import com.google.common.io.ByteStreams;
 import com.google.common.io.Closer;
 import java.io.BufferedOutputStream;
@@ -304,6 +305,10 @@
     return DescriptorUtils.getClassBinaryName(clazz) + CLASS_EXTENSION;
   }
 
+  public static String zipEntryNameForClass(ClassReference clazz) {
+    return clazz.getBinaryName() + CLASS_EXTENSION;
+  }
+
   public static long getOffsetOfResourceInZip(File file, String entry) throws IOException {
     // Look into the jar file to see find the offset.
     ZipFile zipFile = new ZipFile(file);

diff --git a/src/test/examplesJava11/path/PathExample.java b/src/test/examplesJava11/path/PathExample.java
new file mode 100644
index 0000000..8b17da2
--- /dev/null
+++ b/src/test/examplesJava11/path/PathExample.java

@@ -0,0 +1,16 @@
+// Copyright (c) 2022, 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 path;
+
+import java.nio.file.Path;
+
+public class PathExample {
+
+  public static void main(String[] args) {
+    Path thePath = Path.of("foo", "bar");
+    System.out.println(thePath);
+    System.out.println(Path.of(thePath.toUri()).getFileName());
+  }
+}

diff --git a/src/test/java/com/android/tools/r8/JavaCompilerTool.java b/src/test/java/com/android/tools/r8/JavaCompilerTool.java
index b961367..ba23dd5 100644
--- a/src/test/java/com/android/tools/r8/JavaCompilerTool.java
+++ b/src/test/java/com/android/tools/r8/JavaCompilerTool.java

@@ -102,10 +102,10 @@
   }
 
   public JavaCompilerTool addAnnotationProcessors(String... processors) {
-    return addAnnotationProcessor(Arrays.asList(processors));
+    return addAnnotationProcessors(Arrays.asList(processors));
   }
 
-  public JavaCompilerTool addAnnotationProcessor(Collection<String> processors) {
+  public JavaCompilerTool addAnnotationProcessors(Collection<String> processors) {
     annotationProcessors.addAll(processors);
     return this;
   }
@@ -118,6 +118,11 @@
     return this;
   }
 
+  public JavaCompilerTool addDebugAgent() {
+    return addOptions(
+        "-J-debug", "-J-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=*:5005");
+  }
+
   private Path getOrCreateOutputPath() throws IOException {
     return output != null ? output : state.getNewTempFolder().resolve("out.jar");
   }

diff --git a/src/test/java/com/android/tools/r8/bridgeremoval/BridgeWithInvokeSuperOnInterfaceTest.java b/src/test/java/com/android/tools/r8/bridgeremoval/BridgeWithInvokeSuperOnInterfaceTest.java
new file mode 100644
index 0000000..cc24115
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/bridgeremoval/BridgeWithInvokeSuperOnInterfaceTest.java

@@ -0,0 +1,107 @@
+// Copyright (c) 2022, 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.bridgeremoval;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.NoVerticalClassMerging;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.graph.MethodAccessFlags;
+import com.android.tools.r8.transformers.ClassFileTransformer.MethodPredicate;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class BridgeWithInvokeSuperOnInterfaceTest extends TestBase {
+
+  private static final String[] EXPECTED = new String[] {"I::foo"};
+
+  @Parameter() public TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  @Test
+  public void testRuntime() throws Exception {
+    testForRuntime(parameters)
+        .addProgramClasses(Main.class, I.class)
+        .addProgramClassFileData(getJWithBridgeAccessFlag())
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLines(EXPECTED);
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    testForR8(parameters.getBackend())
+        .addProgramClasses(Main.class, I.class)
+        .addProgramClassFileData(getJWithBridgeAccessFlag())
+        .setMinApi(parameters.getApiLevel())
+        .addKeepMainRule(Main.class)
+        .enableNoVerticalClassMergingAnnotations()
+        .enableInliningAnnotations()
+        .addDontObfuscate()
+        .compile()
+        .inspect(
+            inspector -> {
+              // Check that we are removing the bridge if we support default methods.
+              if (parameters.canUseDefaultAndStaticInterfaceMethods()) {
+                ClassSubject J = inspector.clazz(J.class);
+                assertThat(J, isPresent());
+                MethodSubject fooMethod = J.uniqueMethodWithOriginalName("foo");
+                assertThat(fooMethod, not(isPresent()));
+              }
+            })
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLines(EXPECTED);
+  }
+
+  private byte[] getJWithBridgeAccessFlag() throws Exception {
+    return transformer(J.class)
+        .setAccessFlags(MethodPredicate.onName("foo"), MethodAccessFlags::setBridge)
+        .transform();
+  }
+
+  @NoVerticalClassMerging
+  public interface I {
+
+    @NeverInline
+    default void foo() {
+      System.out.println("I::foo");
+    }
+  }
+
+  @NoVerticalClassMerging
+  public interface J extends I {
+
+    @Override
+    default void foo() {
+      I.super.foo();
+    }
+  }
+
+  public static class Main implements J {
+
+    public static void main(String[] args) {
+      new Main().callSuper();
+    }
+
+    @NeverInline
+    public void callSuper() {
+      J.super.foo();
+    }
+  }
+}

diff --git a/src/test/java/com/android/tools/r8/bridgeremoval/BridgeWithInvokeSuperTest.java b/src/test/java/com/android/tools/r8/bridgeremoval/BridgeWithInvokeSuperTest.java
new file mode 100644
index 0000000..b965fea
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/bridgeremoval/BridgeWithInvokeSuperTest.java

@@ -0,0 +1,101 @@
+// Copyright (c) 2022, 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.bridgeremoval;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.NoVerticalClassMerging;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.graph.MethodAccessFlags;
+import com.android.tools.r8.transformers.ClassFileTransformer.MethodPredicate;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class BridgeWithInvokeSuperTest extends TestBase {
+
+  private static final String[] EXPECTED = new String[] {"I::foo"};
+
+  @Parameter() public TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  @Test
+  public void testRuntime() throws Exception {
+    testForRuntime(parameters)
+        .addProgramClasses(Main.class, I.class)
+        .addProgramClassFileData(getAWithBridgeAccessFlag())
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLines(EXPECTED);
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    testForR8(parameters.getBackend())
+        .addProgramClasses(Main.class, I.class)
+        .addProgramClassFileData(getAWithBridgeAccessFlag())
+        .setMinApi(parameters.getApiLevel())
+        .addKeepMainRule(Main.class)
+        .enableNoVerticalClassMergingAnnotations()
+        .enableInliningAnnotations()
+        .compile()
+        .inspect(
+            inspector -> {
+              // Check that we are removing the bridge if we support default methods.
+              if (parameters.canUseDefaultAndStaticInterfaceMethods()) {
+                ClassSubject A = inspector.clazz(A.class);
+                assertThat(A, isPresent());
+                MethodSubject fooMethod = A.uniqueMethodWithOriginalName("foo");
+                assertThat(fooMethod, not(isPresent()));
+              }
+            })
+        .run(parameters.getRuntime(), Main.class)
+        .assertSuccessWithOutputLines(EXPECTED);
+  }
+
+  private byte[] getAWithBridgeAccessFlag() throws Exception {
+    return transformer(A.class)
+        .setAccessFlags(MethodPredicate.onName("foo"), MethodAccessFlags::setBridge)
+        .transform();
+  }
+
+  @NoVerticalClassMerging
+  public interface I {
+
+    @NeverInline
+    default void foo() {
+      System.out.println("I::foo");
+    }
+  }
+
+  public static class A implements I {
+
+    @Override
+    @NeverInline
+    public void foo() {
+      I.super.foo();
+    }
+  }
+
+  public static class Main {
+
+    public static void main(String[] args) {
+      new A().foo();
+    }
+  }
+}

diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/jdk11/FilesTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/jdk11/FilesTest.java
index cef3785..e6015ad 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/jdk11/FilesTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/jdk11/FilesTest.java

@@ -25,9 +25,11 @@
 import java.nio.file.Path;
 import java.nio.file.StandardOpenOption;
 import java.nio.file.attribute.BasicFileAttributes;
+import java.nio.file.attribute.FileTime;
 import java.nio.file.attribute.PosixFileAttributeView;
 import java.nio.file.attribute.PosixFileAttributes;
 import java.nio.file.attribute.PosixFilePermission;
+import java.time.Instant;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
@@ -157,6 +159,7 @@
       readWriteThroughFilesAPI(path);
       readThroughFileChannelAPI(path);
       attributeAccess(path);
+      Files.setAttribute(path, "basic:lastModifiedTime", FileTime.from(Instant.EPOCH));
       fspMethodsWithGeneric(path);
       pathGeneric();
     }

diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/jdk11/InputStreamTransferToTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/jdk11/InputStreamTransferToTest.java
index 70d445d..130cce2 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/jdk11/InputStreamTransferToTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/jdk11/InputStreamTransferToTest.java

@@ -13,6 +13,7 @@
 import com.android.tools.r8.desugar.desugaredlibrary.DesugaredLibraryTestBase;
 import com.android.tools.r8.desugar.desugaredlibrary.test.CompilationSpecification;
 import com.android.tools.r8.desugar.desugaredlibrary.test.LibraryDesugaringSpecification;
+import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.StringUtils;
 import com.google.common.collect.ImmutableList;
 import java.nio.file.Path;
@@ -67,4 +68,23 @@
         .run(parameters.getRuntime(), MAIN_CLASS)
         .assertSuccessWithOutput(EXPECTED_OUTPUT);
   }
+
+  /**
+   * See b/248200357, in T an override or transferTo was introduced in android.jar changing
+   * resolution.
+   */
+  @Test
+  public void testWithAndroidJarFromT() throws Exception {
+    // The method is not present on JDK8 so if we don't desugar that won't work.
+    Assume.assumeFalse(
+        parameters.isCfRuntime(CfVm.JDK8)
+            && !libraryDesugaringSpecification.hasNioFileDesugaring(parameters)
+            && compilationSpecification.isCfToCf());
+    testForDesugaredLibrary(parameters, libraryDesugaringSpecification, compilationSpecification)
+        .addProgramFiles(INPUT_JAR)
+        .addKeepMainRule(MAIN_CLASS)
+        .overrideLibraryFiles(ToolHelper.getAndroidJar(AndroidApiLevel.T))
+        .run(parameters.getRuntime(), MAIN_CLASS)
+        .assertSuccessWithOutput(EXPECTED_OUTPUT);
+  }
 }

diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/jdk11/PathOfTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/jdk11/PathOfTest.java
new file mode 100644
index 0000000..33fa6ab
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/jdk11/PathOfTest.java

@@ -0,0 +1,61 @@
+// Copyright (c) 2022, 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.desugar.desugaredlibrary.jdk11;
+
+import static com.android.tools.r8.desugar.desugaredlibrary.test.CompilationSpecification.DEFAULT_SPECIFICATIONS;
+import static com.android.tools.r8.desugar.desugaredlibrary.test.LibraryDesugaringSpecification.JDK11_PATH;
+
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.desugar.desugaredlibrary.DesugaredLibraryTestBase;
+import com.android.tools.r8.desugar.desugaredlibrary.test.CompilationSpecification;
+import com.android.tools.r8.desugar.desugaredlibrary.test.LibraryDesugaringSpecification;
+import com.android.tools.r8.utils.StringUtils;
+import com.google.common.collect.ImmutableList;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.List;
+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 PathOfTest extends DesugaredLibraryTestBase {
+
+  private final TestParameters parameters;
+  private final LibraryDesugaringSpecification libraryDesugaringSpecification;
+  private final CompilationSpecification compilationSpecification;
+
+  private static final Path INPUT_JAR = Paths.get(ToolHelper.EXAMPLES_JAVA11_JAR_DIR + "path.jar");
+  private static final String EXPECTED_OUTPUT = StringUtils.lines("foo/bar", "bar");
+  private static final String MAIN_CLASS = "path.PathExample";
+
+  @Parameters(name = "{0}, spec: {1}, {2}")
+  public static List<Object[]> data() {
+    return buildParameters(
+        getTestParameters().withDexRuntimes().withAllApiLevels().build(),
+        ImmutableList.of(JDK11_PATH),
+        DEFAULT_SPECIFICATIONS);
+  }
+
+  public PathOfTest(
+      TestParameters parameters,
+      LibraryDesugaringSpecification libraryDesugaringSpecification,
+      CompilationSpecification compilationSpecification) {
+    this.parameters = parameters;
+    this.libraryDesugaringSpecification = libraryDesugaringSpecification;
+    this.compilationSpecification = compilationSpecification;
+  }
+
+  @Test
+  public void test() throws Exception {
+    testForDesugaredLibrary(parameters, libraryDesugaringSpecification, compilationSpecification)
+        .addProgramFiles(INPUT_JAR)
+        .addKeepMainRule(MAIN_CLASS)
+        .run(parameters.getRuntime(), MAIN_CLASS)
+        .assertSuccessWithOutput(EXPECTED_OUTPUT);
+  }
+}

diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/specification/ConvertExportReadTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/specification/ConvertExportReadTest.java
index 2a07cfb..a66e6b4 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/specification/ConvertExportReadTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/specification/ConvertExportReadTest.java

@@ -293,7 +293,8 @@
     assertEquals(
         humanRewritingFlags1.getEmulatedInterfaces(), humanRewritingFlags2.getEmulatedInterfaces());
     assertEquals(
-        humanRewritingFlags1.getRetargetMethod(), humanRewritingFlags2.getRetargetMethod());
+        humanRewritingFlags1.getRetargetMethodToType(),
+        humanRewritingFlags2.getRetargetMethodToType());
 
     assertEquals(humanRewritingFlags1.getDontRetarget(), humanRewritingFlags2.getDontRetarget());
     assertEquals(

diff --git a/src/test/java/com/android/tools/r8/keepanno/asm/KeepEdgeAsmTest.java b/src/test/java/com/android/tools/r8/keepanno/asm/KeepEdgeAsmTest.java
new file mode 100644
index 0000000..b9ebfa2
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/keepanno/asm/KeepEdgeAsmTest.java

@@ -0,0 +1,84 @@
+// Copyright (c) 2022, 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.keepanno.asm;
+
+import static org.junit.Assert.assertEquals;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.keepanno.ast.KeepEdge;
+import com.android.tools.r8.keepanno.testsource.KeepClassAndDefaultConstructorSource;
+import com.android.tools.r8.keepanno.testsource.KeepSourceEdges;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.transformers.ClassTransformer;
+import java.util.Collections;
+import java.util.Set;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.objectweb.asm.AnnotationVisitor;
+
+@RunWith(Parameterized.class)
+public class KeepEdgeAsmTest extends TestBase {
+
+  private static final Class<?> SOURCE = KeepClassAndDefaultConstructorSource.class;
+
+  @Parameterized.Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withNoneRuntime().build();
+  }
+
+  public KeepEdgeAsmTest(TestParameters parameters) {
+    parameters.assertNoneRuntime();
+  }
+
+  @Test
+  public void testAsmReader() throws Exception {
+    Set<KeepEdge> expectedEdges = KeepSourceEdges.getExpectedEdges(SOURCE);
+    ClassReference clazz = Reference.classFromClass(SOURCE);
+    // Original bytes of the test class.
+    byte[] original = ToolHelper.getClassAsBytes(SOURCE);
+    // Strip out all the annotations to ensure they are actually added again.
+    byte[] stripped =
+        transformer(SOURCE)
+            .addClassTransformer(
+                new ClassTransformer() {
+                  @Override
+                  public AnnotationVisitor visitAnnotation(String descriptor, boolean visible) {
+                    // Ignore all input annotations.
+                    return null;
+                  }
+                })
+            .transform();
+    // Manually add in the expected edges again.
+    byte[] readded =
+        transformer(stripped, clazz)
+            .addClassTransformer(
+                new ClassTransformer() {
+
+                  @Override
+                  public void visitEnd() {
+                    for (KeepEdge edge : expectedEdges) {
+                      KeepEdgeWriter.writeEdge(edge, super::visitAnnotation);
+                    }
+                    super.visitEnd();
+                  }
+                })
+            .transform();
+
+    // Read the edges from each version.
+    Set<KeepEdge> originalEdges = KeepEdgeReader.readKeepEdges(original);
+    Set<KeepEdge> strippedEdges = KeepEdgeReader.readKeepEdges(stripped);
+    Set<KeepEdge> readdedEdges = KeepEdgeReader.readKeepEdges(readded);
+
+    // The edges are compared to the "expected" ast to ensure we don't hide failures in reading or
+    // writing.
+    assertEquals(Collections.emptySet(), strippedEdges);
+    assertEquals(expectedEdges, originalEdges);
+    assertEquals(expectedEdges, readdedEdges);
+  }
+}

diff --git a/src/test/java/com/android/tools/r8/experimental/keepanno/ast/KeepEdgeApiTest.java b/src/test/java/com/android/tools/r8/keepanno/ast/KeepEdgeAstTest.java
similarity index 87%
rename from src/test/java/com/android/tools/r8/experimental/keepanno/ast/KeepEdgeApiTest.java
rename to src/test/java/com/android/tools/r8/keepanno/ast/KeepEdgeAstTest.java
index d69d055..bcdb8ed 100644
--- a/src/test/java/com/android/tools/r8/experimental/keepanno/ast/KeepEdgeApiTest.java
+++ b/src/test/java/com/android/tools/r8/keepanno/ast/KeepEdgeAstTest.java

@@ -1,22 +1,22 @@
 // Copyright (c) 2022, 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.experimental.keepanno.ast;
+package com.android.tools.r8.keepanno.ast;
 
 import static org.junit.Assert.assertEquals;
 
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
-import com.android.tools.r8.experimental.keepanno.ast.KeepOptions.KeepOption;
-import com.android.tools.r8.experimental.keepanno.keeprules.KeepRuleExtractor;
+import com.android.tools.r8.keepanno.ast.KeepOptions.KeepOption;
+import com.android.tools.r8.keepanno.keeprules.KeepRuleExtractor;
 import com.android.tools.r8.utils.StringUtils;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
 
 @RunWith(Parameterized.class)
-public class KeepEdgeApiTest extends TestBase {
+public class KeepEdgeAstTest extends TestBase {
 
   private static String CLASS = "com.example.Foo";
 
@@ -25,7 +25,7 @@
     return getTestParameters().withNoneRuntime().build();
   }
 
-  public KeepEdgeApiTest(TestParameters parameters) {
+  public KeepEdgeAstTest(TestParameters parameters) {
     parameters.assertNoneRuntime();
   }
 
@@ -102,10 +102,7 @@
         KeepEdge.builder()
             .setPreconditions(
                 KeepPreconditions.builder()
-                    .addCondition(
-                        KeepCondition.builder()
-                            .setItem(classItem(CLASS))
-                            .build())
+                    .addCondition(KeepCondition.builder().setItem(classItem(CLASS)).build())
                     .build())
             .setConsequences(
                 KeepConsequences.builder()
@@ -127,10 +124,7 @@
         KeepEdge.builder()
             .setPreconditions(
                 KeepPreconditions.builder()
-                    .addCondition(
-                        KeepCondition.builder()
-                            .setItem(classItem(CLASS))
-                            .build())
+                    .addCondition(KeepCondition.builder().setItem(classItem(CLASS)).build())
                     .build())
             .setConsequences(KeepConsequences.builder().addTarget(target(classItem(CLASS))).build())
             .build();
@@ -144,10 +138,7 @@
         KeepEdge.builder()
             .setPreconditions(
                 KeepPreconditions.builder()
-                    .addCondition(
-                        KeepCondition.builder()
-                            .setItem(classItem(CLASS))
-                            .build())
+                    .addCondition(KeepCondition.builder().setItem(classItem(CLASS)).build())
                     .build())
             .setConsequences(
                 KeepConsequences.builder()

diff --git a/src/test/java/com/android/tools/r8/keepanno/processor/KeepEdgeProcessorTest.java b/src/test/java/com/android/tools/r8/keepanno/processor/KeepEdgeProcessorTest.java
new file mode 100644
index 0000000..eb7b616
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/keepanno/processor/KeepEdgeProcessorTest.java

@@ -0,0 +1,101 @@
+// Copyright (c) 2022, 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.keepanno.processor;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+
+import com.android.tools.r8.JavaCompilerTool;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.keepanno.annotations.KeepConstants.Edge;
+import com.android.tools.r8.keepanno.asm.KeepEdgeReader;
+import com.android.tools.r8.keepanno.ast.KeepEdge;
+import com.android.tools.r8.keepanno.testsource.KeepClassAndDefaultConstructorSource;
+import com.android.tools.r8.keepanno.testsource.KeepSourceEdges;
+import com.android.tools.r8.utils.ZipUtils;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Collections;
+import java.util.Set;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class KeepEdgeProcessorTest extends TestBase {
+
+  private static final Path KEEP_ANNO_PATH =
+      Paths.get(ToolHelper.BUILD_DIR, "classes", "java", "keepanno");
+  private static final Class<?> SOURCE = KeepClassAndDefaultConstructorSource.class;
+
+  private final TestParameters parameters;
+
+  @Parameterized.Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withDefaultCfRuntime().build();
+  }
+
+  public KeepEdgeProcessorTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void testClassfile() throws Exception {
+    Path out =
+        JavaCompilerTool.create(parameters.getRuntime().asCf(), temp)
+            .addAnnotationProcessors(typeName(KeepEdgeProcessor.class))
+            .addClasspathFiles(KEEP_ANNO_PATH)
+            .addClassNames(Collections.singletonList(typeName(SOURCE)))
+            .addClasspathFiles(Paths.get(ToolHelper.BUILD_DIR, "classes", "java", "test"))
+            .addClasspathFiles(ToolHelper.DEPS)
+            .compile();
+
+    CodeInspector inspector = new CodeInspector(out);
+    checkSynthesizedKeepEdgeClass(inspector, out);
+    // The source is added as a classpath name but not part of the compilation unit output.
+    assertThat(inspector.clazz(SOURCE), isAbsent());
+  }
+
+  @Test
+  public void testJavaSource() throws Exception {
+    Path out =
+        JavaCompilerTool.create(parameters.getRuntime().asCf(), temp)
+            .addSourceFiles(ToolHelper.getSourceFileForTestClass(SOURCE))
+            .addAnnotationProcessors(typeName(KeepEdgeProcessor.class))
+            .addClasspathFiles(KEEP_ANNO_PATH)
+            .addClasspathFiles(ToolHelper.DEPS)
+            .compile();
+
+    testForJvm()
+        .addProgramFiles(out)
+        .run(parameters.getRuntime(), SOURCE)
+        .assertSuccessWithOutputLines("A is alive!")
+        .inspect(
+            inspector -> {
+              assertThat(inspector.clazz(SOURCE), isPresent());
+              checkSynthesizedKeepEdgeClass(inspector, out);
+            });
+  }
+
+  private void checkSynthesizedKeepEdgeClass(CodeInspector inspector, Path data)
+      throws IOException {
+    String synthesizedEdgesClassName =
+        KeepEdgeProcessor.getClassTypeNameForSynthesizedEdges(SOURCE.getTypeName());
+    ClassSubject synthesizedEdgesClass = inspector.clazz(synthesizedEdgesClassName);
+    assertThat(synthesizedEdgesClass, isPresent());
+    assertThat(synthesizedEdgesClass.annotation(Edge.CLASS.getTypeName()), isPresent());
+    String entry = ZipUtils.zipEntryNameForClass(synthesizedEdgesClass.getFinalReference());
+    byte[] bytes = ZipUtils.readSingleEntry(data, entry);
+    Set<KeepEdge> keepEdges = KeepEdgeReader.readKeepEdges(bytes);
+    assertEquals(KeepSourceEdges.getExpectedEdges(SOURCE), keepEdges);
+  }
+}

diff --git a/src/test/java/com/android/tools/r8/keepanno/testsource/KeepClassAndDefaultConstructorSource.java b/src/test/java/com/android/tools/r8/keepanno/testsource/KeepClassAndDefaultConstructorSource.java
new file mode 100644
index 0000000..ca83a46
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/keepanno/testsource/KeepClassAndDefaultConstructorSource.java

@@ -0,0 +1,32 @@
+// Copyright (c) 2022, 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.keepanno.testsource;
+
+import com.android.tools.r8.keepanno.annotations.KeepEdge;
+import com.android.tools.r8.keepanno.annotations.KeepTarget;
+
+@KeepEdge(
+    consequences = {
+      // Keep the class to allow lookup of it.
+      @KeepTarget(classConstant = KeepClassAndDefaultConstructorSource.class),
+      // Keep the default constructor.
+      @KeepTarget(classConstant = KeepClassAndDefaultConstructorSource.class, methodName = "<init>")
+    })
+public class KeepClassAndDefaultConstructorSource {
+
+  public static class A {
+    public A() {
+      System.out.println("A is alive!");
+    }
+  }
+
+  public static void main(String[] args) throws Exception {
+    Class<?> aClass =
+        Class.forName(
+            KeepClassAndDefaultConstructorSource.class.getPackage().getName()
+                + (args.length > 0 ? ".." : ".")
+                + "KeepClassAndDefaultConstructorSource$A");
+    aClass.getDeclaredConstructor().newInstance();
+  }
+}

diff --git a/src/test/java/com/android/tools/r8/keepanno/testsource/KeepSourceEdges.java b/src/test/java/com/android/tools/r8/keepanno/testsource/KeepSourceEdges.java
new file mode 100644
index 0000000..187a019
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/keepanno/testsource/KeepSourceEdges.java

@@ -0,0 +1,54 @@
+// Copyright (c) 2022, 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.keepanno.testsource;
+
+import com.android.tools.r8.keepanno.ast.KeepConsequences;
+import com.android.tools.r8.keepanno.ast.KeepEdge;
+import com.android.tools.r8.keepanno.ast.KeepItemPattern;
+import com.android.tools.r8.keepanno.ast.KeepMembersPattern;
+import com.android.tools.r8.keepanno.ast.KeepMethodNamePattern;
+import com.android.tools.r8.keepanno.ast.KeepMethodPattern;
+import com.android.tools.r8.keepanno.ast.KeepQualifiedClassNamePattern;
+import com.android.tools.r8.keepanno.ast.KeepTarget;
+import java.util.Collections;
+import java.util.Set;
+
+/**
+ * Utility to get the AST edges for the various annotation test sources.
+ *
+ * <p>This makes it easier to share the test sources among tests (e.g., processor and asm tests).
+ */
+public class KeepSourceEdges {
+
+  public static Set<KeepEdge> getExpectedEdges(Class<?> clazz) {
+    if (clazz.equals(KeepClassAndDefaultConstructorSource.class)) {
+      return getKeepClassAndDefaultConstructorSourceEdges();
+    }
+    throw new RuntimeException();
+  }
+
+  public static Set<KeepEdge> getKeepClassAndDefaultConstructorSourceEdges() {
+    Class<?> clazz = KeepClassAndDefaultConstructorSource.class;
+    // Build the class target.
+    KeepQualifiedClassNamePattern name = KeepQualifiedClassNamePattern.exact(clazz.getTypeName());
+    KeepItemPattern classItem = KeepItemPattern.builder().setClassPattern(name).build();
+    KeepTarget classTarget = KeepTarget.builder().setItem(classItem).build();
+    // Build the constructor target.
+    KeepMethodPattern constructorMethod =
+        KeepMethodPattern.builder().setNamePattern(KeepMethodNamePattern.exact("<init>")).build();
+    KeepMembersPattern constructorMembers =
+        KeepMembersPattern.builder().addMethodPattern(constructorMethod).build();
+    KeepItemPattern constructorItem =
+        KeepItemPattern.builder()
+            .setClassPattern(name)
+            .setMembersPattern(constructorMembers)
+            .build();
+    KeepTarget constructorTarget = KeepTarget.builder().setItem(constructorItem).build();
+    // The consequet set is the class an its constructor.
+    KeepConsequences consequences =
+        KeepConsequences.builder().addTarget(classTarget).addTarget(constructorTarget).build();
+    KeepEdge edge = KeepEdge.builder().setConsequences(consequences).build();
+    return Collections.singleton(edge);
+  }
+}

diff --git a/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingRemoveInterfaceBridgeTest.java b/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingRemoveInterfaceBridgeTest.java
index d569899..6d96680 100644
--- a/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingRemoveInterfaceBridgeTest.java
+++ b/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingRemoveInterfaceBridgeTest.java

@@ -5,9 +5,8 @@
 package com.android.tools.r8.memberrebinding;
 
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.isSynthetic;
 import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
 
 import com.android.tools.r8.NeverInline;
 import com.android.tools.r8.NoHorizontalClassMerging;
@@ -16,7 +15,6 @@
 import com.android.tools.r8.TestParametersCollection;
 import com.android.tools.r8.utils.DescriptorUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
-import com.android.tools.r8.utils.codeinspector.FoundMethodSubject;
 import com.android.tools.r8.utils.codeinspector.HorizontallyMergedClassesInspector;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -58,10 +56,7 @@
             inspector -> {
               ClassSubject clazz = inspector.clazz(J.class);
               assertThat(clazz, isPresent());
-              // TODO(b/197490164): We should remove the bridge inserted here.
-              assertEquals(1, clazz.allMethods().size());
-              FoundMethodSubject foundMethodSubject = clazz.allMethods().get(0);
-              assertThat(foundMethodSubject, isSynthetic());
+              assertTrue(clazz.allMethods().isEmpty());
             });
   }
 

diff --git a/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingRemoveInterfaceBridgeWithSubTypeTest.java b/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingRemoveInterfaceBridgeWithSubTypeTest.java
index 4551dbe..dd2f0c1 100644
--- a/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingRemoveInterfaceBridgeWithSubTypeTest.java
+++ b/src/test/java/com/android/tools/r8/memberrebinding/MemberRebindingRemoveInterfaceBridgeWithSubTypeTest.java

@@ -5,9 +5,8 @@
 package com.android.tools.r8.memberrebinding;
 
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
-import static com.android.tools.r8.utils.codeinspector.Matchers.isSynthetic;
 import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
 
 import com.android.tools.r8.NeverInline;
 import com.android.tools.r8.NoHorizontalClassMerging;
@@ -18,7 +17,6 @@
 import com.android.tools.r8.TestParametersCollection;
 import com.android.tools.r8.utils.DescriptorUtils;
 import com.android.tools.r8.utils.codeinspector.ClassSubject;
-import com.android.tools.r8.utils.codeinspector.FoundMethodSubject;
 import com.android.tools.r8.utils.codeinspector.HorizontallyMergedClassesInspector;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -63,10 +61,7 @@
             inspector -> {
               ClassSubject clazz = inspector.clazz(A.class);
               assertThat(clazz, isPresent());
-              // TODO(b/197490164): We should remove the bridge inserted here.
-              assertEquals(1, clazz.virtualMethods().size());
-              FoundMethodSubject foundMethodSubject = clazz.virtualMethods().get(0);
-              assertThat(foundMethodSubject, isSynthetic());
+              assertTrue(clazz.virtualMethods().isEmpty());
             });
   }
 

diff --git a/src/test/java/com/android/tools/r8/shaking/b136195382/AbstractBridgeInheritTest.java b/src/test/java/com/android/tools/r8/shaking/b136195382/AbstractBridgeInheritTest.java
index f1fc012..58faf90 100644
--- a/src/test/java/com/android/tools/r8/shaking/b136195382/AbstractBridgeInheritTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/b136195382/AbstractBridgeInheritTest.java

@@ -4,7 +4,6 @@
 
 package com.android.tools.r8.shaking.b136195382;
 
-import com.android.tools.r8.CompilationFailedException;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
@@ -13,8 +12,6 @@
 import com.android.tools.r8.shaking.b136195382.package2.Main;
 import com.android.tools.r8.shaking.b136195382.package2.SubFactory;
 import com.android.tools.r8.shaking.b136195382.package2.SubService;
-import java.io.IOException;
-import java.util.concurrent.ExecutionException;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
@@ -35,8 +32,7 @@
   }
 
   @Test
-  public void testRemovingBridge()
-      throws ExecutionException, CompilationFailedException, IOException {
+  public void testRemovingBridge() throws Exception {
     testForR8(parameters.getBackend())
         .addProgramClasses(
             Service.class, Factory.class, SubService.class, SubFactory.class, Main.class)
@@ -44,7 +40,6 @@
         .enableInliningAnnotations()
         .setMinApi(parameters.getApiLevel())
         .run(parameters.getRuntime(), Main.class)
-        .assertSuccessWithOutputLines("Hello World!")
-        .inspector();
+        .assertSuccessWithOutputLines("Hello World!");
   }
 }