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
index 85f651f..05f103b 100644
--- a/src/keepanno/java/com/android/tools/r8/keepanno/asm/KeepEdgeReader.java
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/asm/KeepEdgeReader.java
@@ -89,6 +89,37 @@
 
   public static int ASM_VERSION = ASM9;
 
+  public static boolean isClassKeepAnnotation(String descriptor, boolean visible) {
+    return !visible && (isExtractedAnnotation(descriptor) || isEmbeddedAnnotation(descriptor));
+  }
+
+  public static boolean isFieldKeepAnnotation(String descriptor, boolean visible) {
+    return !visible && isEmbeddedAnnotation(descriptor);
+  }
+
+  public static boolean isMethodKeepAnnotation(String descriptor, boolean visible) {
+    return !visible && isEmbeddedAnnotation(descriptor);
+  }
+
+  private static boolean isExtractedAnnotation(String descriptor) {
+    return ExtractedAnnotations.DESCRIPTOR.equals(descriptor);
+  }
+
+  private static boolean isEmbeddedAnnotation(String descriptor) {
+    switch (descriptor) {
+      case AnnotationConstants.Edge.DESCRIPTOR:
+      case AnnotationConstants.UsesReflection.DESCRIPTOR:
+      case AnnotationConstants.ForApi.DESCRIPTOR:
+      case AnnotationConstants.UsedByReflection.DESCRIPTOR:
+      case AnnotationConstants.UsedByNative.DESCRIPTOR:
+      case AnnotationConstants.CheckRemoved.DESCRIPTOR:
+      case AnnotationConstants.CheckOptimizedOut.DESCRIPTOR:
+        return true;
+      default:
+        return false;
+    }
+  }
+
   public static List<KeepDeclaration> readKeepEdges(byte[] classFileBytes) {
     return internalReadKeepEdges(classFileBytes, true, false);
   }
@@ -107,6 +138,84 @@
     return declarations;
   }
 
+  public static AnnotationVisitor createClassKeepAnnotationVisitor(
+      String descriptor,
+      boolean visible,
+      boolean readEmbedded,
+      boolean readExtracted,
+      String className,
+      AnnotationParsingContext parsingContext,
+      Consumer<KeepDeclaration> callback) {
+    return KeepEdgeClassVisitor.createAnnotationVisitor(
+        descriptor,
+        visible,
+        readEmbedded,
+        readExtracted,
+        callback,
+        parsingContext,
+        className,
+        builder -> {
+          builder.setContextFromClassDescriptor(
+              KeepEdgeReaderUtils.getDescriptorFromClassTypeName(className));
+        });
+  }
+
+  public static AnnotationVisitor createFieldKeepAnnotationVisitor(
+      String descriptor,
+      boolean visible,
+      boolean readEmbedded,
+      boolean readExtracted,
+      String className,
+      String fieldName,
+      String fieldTypeDescriptor,
+      AnnotationParsingContext parsingContext,
+      Consumer<KeepDeclaration> callback) {
+    return KeepEdgeFieldVisitor.createAnnotationVisitor(
+        descriptor,
+        visible,
+        readEmbedded,
+        readExtracted,
+        callback::accept,
+        parsingContext,
+        className,
+        fieldName,
+        fieldTypeDescriptor,
+        builder -> {
+          builder.setContextFromFieldDescriptor(
+              KeepEdgeReaderUtils.getDescriptorFromClassTypeName(className),
+              fieldName,
+              fieldTypeDescriptor);
+        });
+  }
+
+  public static AnnotationVisitor createMethodKeepAnnotationVisitor(
+      String descriptor,
+      boolean visible,
+      boolean readEmbedded,
+      boolean readExtracted,
+      String className,
+      String methodName,
+      String methodDescriptor,
+      AnnotationParsingContext parsingContext,
+      Consumer<KeepDeclaration> callback) {
+    return KeepEdgeMethodVisitor.createAnnotationVisitor(
+        descriptor,
+        visible,
+        readEmbedded,
+        readExtracted,
+        callback::accept,
+        parsingContext,
+        className,
+        methodName,
+        methodDescriptor,
+        (KeepEdgeMetaInfo.Builder builder) -> {
+          builder.setContextFromMethodDescriptor(
+              KeepEdgeReaderUtils.getDescriptorFromClassTypeName(className),
+              methodName,
+              methodDescriptor);
+        });
+  }
+
   private static KeepClassItemReference classReferenceFromName(String className) {
     return KeepClassItemReference.fromClassNamePattern(
         KeepQualifiedClassNamePattern.exact(className));
@@ -223,7 +332,7 @@
         String[] interfaces) {
       super.visit(version, access, name, signature, superName, interfaces);
       className = binaryNameToTypeName(name);
-      parsingContext = new ClassParsingContext(className);
+      parsingContext = ClassParsingContext.fromName(className);
     }
 
     private AnnotationParsingContext annotationParsingContext(String descriptor) {
@@ -232,56 +341,62 @@
 
     @Override
     public AnnotationVisitor visitAnnotation(String descriptor, boolean visible) {
+      return createAnnotationVisitor(
+          descriptor,
+          visible,
+          readEmbedded,
+          readExtracted,
+          parent::accept,
+          annotationParsingContext(descriptor),
+          className,
+          this::setContext);
+    }
+
+    private static AnnotationVisitorBase createAnnotationVisitor(
+        String descriptor,
+        boolean visible,
+        boolean readEmbedded,
+        boolean readExtracted,
+        Consumer<KeepDeclaration> parent,
+        AnnotationParsingContext parsingContext,
+        String className,
+        Consumer<KeepEdgeMetaInfo.Builder> setContext) {
       // Skip any visible annotations as @KeepEdge is not runtime visible.
       if (visible) {
         return null;
       }
-      if (readExtracted && descriptor.equals(ExtractedAnnotations.DESCRIPTOR)) {
-        return new ExtractedAnnotationsVisitor(
-            annotationParsingContext(descriptor), parent::accept);
+
+      if (readExtracted && isExtractedAnnotation(descriptor)) {
+        return new ExtractedAnnotationsVisitor(parsingContext, parent::accept);
       }
-      if (!readEmbedded) {
+      if (!readEmbedded || !isEmbeddedAnnotation(descriptor)) {
         return null;
       }
       if (descriptor.equals(Edge.DESCRIPTOR)) {
-        return new KeepEdgeVisitor(
-            annotationParsingContext(descriptor), parent::accept, this::setContext);
+        return new KeepEdgeVisitor(parsingContext, parent::accept, setContext);
       }
       if (descriptor.equals(AnnotationConstants.UsesReflection.DESCRIPTOR)) {
         KeepClassItemPattern classItem =
             KeepClassItemPattern.builder()
                 .setClassNamePattern(KeepQualifiedClassNamePattern.exact(className))
                 .build();
-        return new UsesReflectionVisitor(
-            annotationParsingContext(descriptor), parent::accept, this::setContext, classItem);
+        return new UsesReflectionVisitor(parsingContext, parent::accept, setContext, classItem);
       }
-      if (descriptor.equals(AnnotationConstants.ForApi.DESCRIPTOR)) {
-        return new ForApiClassVisitor(
-            annotationParsingContext(descriptor), parent::accept, this::setContext, className);
+      if (descriptor.equals(ForApi.DESCRIPTOR)) {
+        return new ForApiClassVisitor(parsingContext, parent::accept, setContext, className);
       }
-      if (descriptor.equals(AnnotationConstants.UsedByReflection.DESCRIPTOR)
+      if (descriptor.equals(UsedByReflection.DESCRIPTOR)
           || descriptor.equals(AnnotationConstants.UsedByNative.DESCRIPTOR)) {
         return new UsedByReflectionClassVisitor(
-            annotationParsingContext(descriptor),
-            parent::accept,
-            this::setContext,
-            className);
+            parsingContext, parent::accept, setContext, className);
       }
       if (descriptor.equals(AnnotationConstants.CheckRemoved.DESCRIPTOR)) {
         return new CheckRemovedClassVisitor(
-            annotationParsingContext(descriptor),
-            parent::accept,
-            this::setContext,
-            className,
-            KeepCheckKind.REMOVED);
+            parsingContext, parent::accept, setContext, className, KeepCheckKind.REMOVED);
       }
       if (descriptor.equals(AnnotationConstants.CheckOptimizedOut.DESCRIPTOR)) {
         return new CheckRemovedClassVisitor(
-            annotationParsingContext(descriptor),
-            parent::accept,
-            this::setContext,
-            className,
-            KeepCheckKind.OPTIMIZED_OUT);
+            parsingContext, parent::accept, setContext, className, KeepCheckKind.OPTIMIZED_OUT);
       }
       return null;
     }
@@ -334,7 +449,8 @@
           new MethodParsingContext(classParsingContext, methodName, methodDescriptor);
     }
 
-    private KeepMemberItemPattern createMethodItemContext() {
+    private static KeepMemberItemPattern createMethodItemContext(
+        String className, String methodName, String methodDescriptor) {
       String returnTypeDescriptor = Type.getReturnType(methodDescriptor).getDescriptor();
       Type[] argumentTypes = Type.getArgumentTypes(methodDescriptor);
       KeepMethodParametersPattern.Builder builder = KeepMethodParametersPattern.builder();
@@ -363,50 +479,77 @@
 
     @Override
     public AnnotationVisitor visitAnnotation(String descriptor, boolean visible) {
+      return createAnnotationVisitor(
+          descriptor,
+          visible,
+          true,
+          false,
+          parent::accept,
+          annotationParsingContext(descriptor),
+          className,
+          methodName,
+          methodDescriptor,
+          this::setContext);
+    }
+
+    public static AnnotationVisitor createAnnotationVisitor(
+        String descriptor,
+        boolean visible,
+        boolean readEmbedded,
+        boolean readExtracted,
+        Consumer<KeepDeclaration> parent,
+        AnnotationParsingContext parsingContext,
+        String className,
+        String methodName,
+        String methodDescriptor,
+        Consumer<KeepEdgeMetaInfo.Builder> setContext) {
       // Skip any visible annotations as @KeepEdge is not runtime visible.
       if (visible) {
         return null;
       }
+      if (!readEmbedded) {
+        // Only the embedded annotations can be on fields.
+        return null;
+      }
       if (descriptor.equals(Edge.DESCRIPTOR)) {
-        return new KeepEdgeVisitor(
-            annotationParsingContext(descriptor), parent::accept, this::setContext);
+        return new KeepEdgeVisitor(parsingContext, parent::accept, setContext);
       }
       if (descriptor.equals(AnnotationConstants.UsesReflection.DESCRIPTOR)) {
         return new UsesReflectionVisitor(
-            annotationParsingContext(descriptor),
+            parsingContext,
             parent::accept,
-            this::setContext,
-            createMethodItemContext());
+            setContext,
+            createMethodItemContext(className, methodName, methodDescriptor));
       }
       if (descriptor.equals(AnnotationConstants.ForApi.DESCRIPTOR)) {
         return new ForApiMemberVisitor(
-            annotationParsingContext(descriptor),
+            parsingContext,
             parent::accept,
-            this::setContext,
-            createMethodItemContext());
+            setContext,
+            createMethodItemContext(className, methodName, methodDescriptor));
       }
       if (descriptor.equals(AnnotationConstants.UsedByReflection.DESCRIPTOR)
           || descriptor.equals(AnnotationConstants.UsedByNative.DESCRIPTOR)) {
         return new UsedByReflectionMemberVisitor(
-            annotationParsingContext(descriptor),
+            parsingContext,
             parent::accept,
-            this::setContext,
-            createMethodItemContext());
+            setContext,
+            createMethodItemContext(className, methodName, methodDescriptor));
       }
       if (descriptor.equals(AnnotationConstants.CheckRemoved.DESCRIPTOR)) {
         return new CheckRemovedMemberVisitor(
-            annotationParsingContext(descriptor),
+            parsingContext,
             parent::accept,
-            this::setContext,
-            createMethodItemContext(),
+            setContext,
+            createMethodItemContext(className, methodName, methodDescriptor),
             KeepCheckKind.REMOVED);
       }
       if (descriptor.equals(AnnotationConstants.CheckOptimizedOut.DESCRIPTOR)) {
         return new CheckRemovedMemberVisitor(
-            annotationParsingContext(descriptor),
+            parsingContext,
             parent::accept,
-            this::setContext,
-            createMethodItemContext(),
+            setContext,
+            createMethodItemContext(className, methodName, methodDescriptor),
             KeepCheckKind.OPTIMIZED_OUT);
       }
       return null;
@@ -422,7 +565,7 @@
     private final Parent<KeepEdge> parent;
     private final String className;
     private final String fieldName;
-    private final String fieldDescriptor;
+    private final String fieldTypeDescriptor;
     private final FieldParsingContext parsingContext;
 
     KeepEdgeFieldVisitor(
@@ -430,23 +573,24 @@
         Parent<KeepEdge> parent,
         String className,
         String fieldName,
-        String fieldDescriptor) {
+        String fieldTypeDescriptor) {
       super(ASM_VERSION);
       this.parent = parent;
       this.className = className;
       this.fieldName = fieldName;
-      this.fieldDescriptor = fieldDescriptor;
+      this.fieldTypeDescriptor = fieldTypeDescriptor;
       this.parsingContext =
-          new FieldParsingContext(classParsingContext, fieldName, fieldDescriptor);
+          new FieldParsingContext(classParsingContext, fieldName, fieldTypeDescriptor);
     }
 
     private AnnotationParsingContext annotationParsingContext(String descriptor) {
       return parsingContext.annotation(descriptor);
     }
 
-    private KeepMemberItemPattern createMemberItemContext() {
+    private static KeepMemberItemPattern createMemberItemContext(
+        String className, String fieldName, String fieldTypeDescriptor) {
       KeepFieldTypePattern typePattern =
-          KeepFieldTypePattern.fromType(KeepTypePattern.fromDescriptor(fieldDescriptor));
+          KeepFieldTypePattern.fromType(KeepTypePattern.fromDescriptor(fieldTypeDescriptor));
       return KeepMemberItemPattern.builder()
           .setClassReference(classReferenceFromName(className))
           .setMemberPattern(
@@ -459,39 +603,67 @@
 
     private void setContext(KeepEdgeMetaInfo.Builder builder) {
       builder.setContextFromFieldDescriptor(
-          KeepEdgeReaderUtils.getDescriptorFromJavaType(className), fieldName, fieldDescriptor);
+          KeepEdgeReaderUtils.getDescriptorFromJavaType(className), fieldName, fieldTypeDescriptor);
     }
 
     @Override
     public AnnotationVisitor visitAnnotation(String descriptor, boolean visible) {
+      return createAnnotationVisitor(
+          descriptor,
+          visible,
+          true,
+          false,
+          parent::accept,
+          annotationParsingContext(descriptor),
+          className,
+          fieldName,
+          fieldTypeDescriptor,
+          this::setContext);
+    }
+
+    public static AnnotationVisitorBase createAnnotationVisitor(
+        String descriptor,
+        boolean visible,
+        boolean readEmbedded,
+        boolean readExtracted,
+        Consumer<KeepEdge> parent,
+        AnnotationParsingContext parsingContext,
+        String className,
+        String fieldName,
+        String fieldTypeDescriptor,
+        Consumer<KeepEdgeMetaInfo.Builder> setContext) {
       // Skip any visible annotations as @KeepEdge is not runtime visible.
       if (visible) {
         return null;
       }
+      if (!readEmbedded) {
+        // Only the embedded annotations can be on fields.
+        return null;
+      }
       if (descriptor.equals(Edge.DESCRIPTOR)) {
-        return new KeepEdgeVisitor(annotationParsingContext(descriptor), parent, this::setContext);
+        return new KeepEdgeVisitor(parsingContext, parent::accept, setContext);
       }
       if (descriptor.equals(AnnotationConstants.UsesReflection.DESCRIPTOR)) {
         return new UsesReflectionVisitor(
-            annotationParsingContext(descriptor),
-            parent,
-            this::setContext,
-            createMemberItemContext());
+            parsingContext,
+            parent::accept,
+            setContext,
+            createMemberItemContext(className, fieldName, fieldTypeDescriptor));
       }
-      if (descriptor.equals(AnnotationConstants.ForApi.DESCRIPTOR)) {
+      if (descriptor.equals(ForApi.DESCRIPTOR)) {
         return new ForApiMemberVisitor(
-            annotationParsingContext(descriptor),
-            parent,
-            this::setContext,
-            createMemberItemContext());
+            parsingContext,
+            parent::accept,
+            setContext,
+            createMemberItemContext(className, fieldName, fieldTypeDescriptor));
       }
-      if (descriptor.equals(AnnotationConstants.UsedByReflection.DESCRIPTOR)
+      if (descriptor.equals(UsedByReflection.DESCRIPTOR)
           || descriptor.equals(AnnotationConstants.UsedByNative.DESCRIPTOR)) {
         return new UsedByReflectionMemberVisitor(
-            annotationParsingContext(descriptor),
-            parent,
-            this::setContext,
-            createMemberItemContext());
+            parsingContext,
+            parent::accept,
+            setContext,
+            createMemberItemContext(className, fieldName, fieldTypeDescriptor));
       }
       return null;
     }
diff --git a/src/keepanno/java/com/android/tools/r8/keepanno/asm/KeepEdgeReaderUtils.java b/src/keepanno/java/com/android/tools/r8/keepanno/asm/KeepEdgeReaderUtils.java
index 21645d5..78eddd6 100644
--- a/src/keepanno/java/com/android/tools/r8/keepanno/asm/KeepEdgeReaderUtils.java
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/asm/KeepEdgeReaderUtils.java
@@ -20,7 +20,11 @@
   }
 
   public static String getDescriptorFromClassTypeName(String classTypeName) {
-    return "L" + getBinaryNameFromClassTypeName(classTypeName) + ";";
+    return getDescriptorFromBinaryName(getBinaryNameFromClassTypeName(classTypeName));
+  }
+
+  public static String getDescriptorFromBinaryName(String binaryName) {
+    return "L" + binaryName + ";";
   }
 
   public static String getJavaTypeFromDescriptor(String descriptor) {
diff --git a/src/keepanno/java/com/android/tools/r8/keepanno/ast/ParsingContext.java b/src/keepanno/java/com/android/tools/r8/keepanno/ast/ParsingContext.java
index 5f6bb55..11eefa5 100644
--- a/src/keepanno/java/com/android/tools/r8/keepanno/ast/ParsingContext.java
+++ b/src/keepanno/java/com/android/tools/r8/keepanno/ast/ParsingContext.java
@@ -6,6 +6,7 @@
 
 import static com.android.tools.r8.keepanno.asm.KeepEdgeReaderUtils.getJavaTypeFromDescriptor;
 
+import com.android.tools.r8.keepanno.asm.KeepEdgeReaderUtils;
 import org.objectweb.asm.Type;
 
 public abstract class ParsingContext {
@@ -62,10 +63,19 @@
   public static class ClassParsingContext extends ParsingContext {
     private final String className;
 
-    public ClassParsingContext(String className) {
+    private ClassParsingContext(String className) {
       this.className = className;
     }
 
+    public static ClassParsingContext fromName(String className) {
+      return new ClassParsingContext(className);
+    }
+
+    public static ClassParsingContext fromDescriptor(String descriptor) {
+      return ClassParsingContext.fromName(
+          KeepEdgeReaderUtils.getJavaTypeFromDescriptor(descriptor));
+    }
+
     @Override
     public String getHolderName() {
       return className;
diff --git a/src/main/java/com/android/tools/r8/graph/JarClassFileReader.java b/src/main/java/com/android/tools/r8/graph/JarClassFileReader.java
index 978932d..4941b96 100644
--- a/src/main/java/com/android/tools/r8/graph/JarClassFileReader.java
+++ b/src/main/java/com/android/tools/r8/graph/JarClassFileReader.java
@@ -35,9 +35,11 @@
 import com.android.tools.r8.graph.GenericSignature.FieldTypeSignature;
 import com.android.tools.r8.graph.GenericSignature.MethodTypeSignature;
 import com.android.tools.r8.jar.CfApplicationWriter;
-import com.android.tools.r8.keepanno.asm.KeepEdgeReader.ExtractedAnnotationsVisitor;
-import com.android.tools.r8.keepanno.ast.AnnotationConstants.ExtractedAnnotations;
+import com.android.tools.r8.keepanno.asm.KeepEdgeReader;
+import com.android.tools.r8.keepanno.ast.ParsingContext.AnnotationParsingContext;
 import com.android.tools.r8.keepanno.ast.ParsingContext.ClassParsingContext;
+import com.android.tools.r8.keepanno.ast.ParsingContext.FieldParsingContext;
+import com.android.tools.r8.keepanno.ast.ParsingContext.MethodParsingContext;
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.synthesis.SyntheticMarker;
 import com.android.tools.r8.utils.AsmUtils;
@@ -453,17 +455,25 @@
       return new CreateMethodVisitor(access, name, desc, signature, exceptions, this);
     }
 
+    public boolean shouldSkipKeepAnnotations() {
+      return classKind != ClassKind.PROGRAM
+          || !application.options.testing.isKeepAnnotationsEnabled();
+    }
+
     @Override
     public AnnotationVisitor visitAnnotation(String desc, boolean visible) {
-      if (!visible && ExtractedAnnotations.DESCRIPTOR.equals(desc)) {
-        if (!application.options.testing.enableExtractedKeepAnnotations) {
+      if (KeepEdgeReader.isClassKeepAnnotation(desc, visible)) {
+        if (shouldSkipKeepAnnotations()) {
           return null;
         }
-        if (classKind != ClassKind.PROGRAM) {
-          return null;
-        }
-        return new ExtractedAnnotationsVisitor(
-            new ClassParsingContext(type.getName()).annotation(desc),
+        String className = type.getTypeName();
+        return KeepEdgeReader.createClassKeepAnnotationVisitor(
+            desc,
+            visible,
+            application.options.testing.enableEmbeddedKeepAnnotations,
+            application.options.testing.enableExtractedKeepAnnotations,
+            className,
+            ClassParsingContext.fromName(className).annotation(desc),
             application::addKeepDeclaration);
       }
       return createAnnotationVisitor(
@@ -660,7 +670,7 @@
     private final CreateDexClassVisitor<?> parent;
     private final int access;
     private final String name;
-    private final String desc;
+    private final String fieldTypeDescriptor;
     private final Object value;
     private final FieldTypeSignature fieldSignature;
     private List<DexAnnotation> annotations = null;
@@ -676,7 +686,7 @@
       this.parent = parent;
       this.access = access;
       this.name = name;
-      this.desc = desc;
+      this.fieldTypeDescriptor = desc;
       this.value = value;
       this.fieldSignature =
           parent.application.options.parseSignatureAttribute()
@@ -691,6 +701,26 @@
 
     @Override
     public AnnotationVisitor visitAnnotation(String desc, boolean visible) {
+      if (KeepEdgeReader.isFieldKeepAnnotation(desc, visible)) {
+        if (parent.shouldSkipKeepAnnotations()) {
+          return null;
+        }
+        String className = parent.type.getTypeName();
+        AnnotationParsingContext parsingContext =
+            new FieldParsingContext(
+                    ClassParsingContext.fromName(className), name, fieldTypeDescriptor)
+                .annotation(desc);
+        return KeepEdgeReader.createFieldKeepAnnotationVisitor(
+            desc,
+            visible,
+            parent.application.options.testing.enableEmbeddedKeepAnnotations,
+            parent.application.options.testing.enableExtractedKeepAnnotations,
+            className,
+            name,
+            fieldTypeDescriptor,
+            parsingContext,
+            parent.application::addKeepDeclaration);
+      }
       return createAnnotationVisitor(
           desc, visible, getAnnotations(), parent.application, DexAnnotation::new);
     }
@@ -705,7 +735,7 @@
     @Override
     public void visitEnd() {
       FieldAccessFlags flags = createFieldAccessFlags(access);
-      DexField dexField = parent.application.getField(parent.type, name, desc);
+      DexField dexField = parent.application.getField(parent.type, name, fieldTypeDescriptor);
       parent.application.checkFieldForRecord(dexField, parent.classKind);
       parent.application.checkFieldForMethodHandlesLookup(dexField, parent.classKind);
       parent.application.checkFieldForVarHandle(dexField, parent.classKind);
@@ -785,6 +815,7 @@
   private static class CreateMethodVisitor extends MethodVisitor {
 
     private final String name;
+    private final String methodDescriptor;
     final CreateDexClassVisitor<?> parent;
     private final int parameterCount;
     private List<DexAnnotation> annotations = null;
@@ -808,6 +839,7 @@
         CreateDexClassVisitor<?> parent) {
       super(ASM_VERSION);
       this.name = name;
+      this.methodDescriptor = desc;
       this.parent = parent;
       this.method = parent.application.getMethod(parent.type, name, desc);
       this.flags = createMethodAccessFlags(name, access);
@@ -834,6 +866,26 @@
 
     @Override
     public AnnotationVisitor visitAnnotation(String desc, boolean visible) {
+      if (KeepEdgeReader.isMethodKeepAnnotation(desc, visible)) {
+        if (parent.shouldSkipKeepAnnotations()) {
+          return null;
+        }
+        String className = parent.type.getTypeName();
+        AnnotationParsingContext parsingContext =
+            new MethodParsingContext(
+                    ClassParsingContext.fromName(className), name, methodDescriptor)
+                .annotation(desc);
+        return KeepEdgeReader.createMethodKeepAnnotationVisitor(
+            desc,
+            visible,
+            parent.application.options.testing.enableEmbeddedKeepAnnotations,
+            parent.application.options.testing.enableExtractedKeepAnnotations,
+            className,
+            name,
+            methodDescriptor,
+            parsingContext,
+            parent.application::addKeepDeclaration);
+      }
       return createAnnotationVisitor(
           desc, visible, getAnnotations(), parent.application, DexAnnotation::new);
     }
diff --git a/src/main/java/com/android/tools/r8/shaking/Enqueuer.java b/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
index 760cede..fdc9cbd 100644
--- a/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
+++ b/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
@@ -1637,7 +1637,7 @@
   }
 
   void traceMethodPosition(com.android.tools.r8.ir.code.Position position, ProgramMethod context) {
-    if (!options.testing.enableExtractedKeepAnnotations) {
+    if (!options.testing.isKeepAnnotationsEnabled()) {
       // Currently inlining is only intended for the evaluation of keep annotation edges.
       return;
     }
@@ -3452,6 +3452,7 @@
   }
 
   public boolean isOriginalReferenceEffectivelyLive(DexReference reference) {
+    assert options.testing.isKeepAnnotationsEnabled();
     // The effectively-live original set contains types, fields and methods witnessed by
     // instructions, such as method inlining positions.
     return effectivelyLiveOriginalReferences.contains(reference);
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 8e9e3e1..f284b2c 100644
--- a/src/main/java/com/android/tools/r8/utils/InternalOptions.java
+++ b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
@@ -2184,6 +2184,11 @@
   public static class TestingOptions {
 
     public boolean enableExtractedKeepAnnotations = false;
+    public boolean enableEmbeddedKeepAnnotations = false;
+
+    public boolean isKeepAnnotationsEnabled() {
+      return enableExtractedKeepAnnotations || enableEmbeddedKeepAnnotations;
+    }
 
     public boolean enableNumberUnboxer = false;
     public boolean printNumberUnboxed = false;
diff --git a/src/test/java/com/android/tools/r8/keepanno/CheckOptimizedOutAnnotationTest.java b/src/test/java/com/android/tools/r8/keepanno/CheckOptimizedOutAnnotationTest.java
index 59915bc9..656bb6b 100644
--- a/src/test/java/com/android/tools/r8/keepanno/CheckOptimizedOutAnnotationTest.java
+++ b/src/test/java/com/android/tools/r8/keepanno/CheckOptimizedOutAnnotationTest.java
@@ -10,6 +10,7 @@
 import static org.hamcrest.CoreMatchers.containsString;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 import static org.junit.Assume.assumeFalse;
 import static org.junit.Assume.assumeTrue;
@@ -54,12 +55,12 @@
   }
 
   @Test
-  public void testR8Native() throws Throwable {
-    assumeTrue(parameters.isR8() && parameters.isNative());
+  public void testCurrentR8() throws Throwable {
+    assumeTrue(parameters.isR8() && parameters.isCurrentR8());
     testForKeepAnno(parameters)
         .addProgramClasses(getInputClasses())
         .addKeepMainRule(TestClass.class)
-        .applyIfR8Native(
+        .applyIfR8Current(
             b ->
                 b.allowDiagnosticWarningMessages()
                     .setDiagnosticsLevelModifier(
@@ -86,8 +87,9 @@
   }
 
   @Test
-  public void testR8Extract() throws Throwable {
-    assumeTrue(parameters.isR8() && !parameters.isNative());
+  public void testLegacyR8() throws Throwable {
+    assumeTrue(parameters.isR8() && !parameters.isCurrentR8());
+    assertTrue(parameters.isLegacyR8());
     try {
       testForKeepAnno(parameters)
           .addProgramClasses(getInputClasses())
diff --git a/src/test/java/com/android/tools/r8/keepanno/CheckRemovedAnnotationTest.java b/src/test/java/com/android/tools/r8/keepanno/CheckRemovedAnnotationTest.java
index b3bedf1..4010ef8 100644
--- a/src/test/java/com/android/tools/r8/keepanno/CheckRemovedAnnotationTest.java
+++ b/src/test/java/com/android/tools/r8/keepanno/CheckRemovedAnnotationTest.java
@@ -10,6 +10,7 @@
 import static org.hamcrest.CoreMatchers.containsString;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 import static org.junit.Assume.assumeFalse;
 import static org.junit.Assume.assumeTrue;
@@ -53,12 +54,12 @@
   }
 
   @Test
-  public void testR8Native() throws Exception {
-    assumeTrue(parameters.isR8() && parameters.isNative());
+  public void testCurrentR8() throws Exception {
+    assumeTrue(parameters.isR8() && parameters.isCurrentR8());
     testForKeepAnno(parameters)
         .addProgramClasses(getInputClasses())
         .addKeepMainRule(TestClass.class)
-        .applyIfR8Native(
+        .applyIfR8Current(
             b ->
                 b.allowDiagnosticWarningMessages()
                     .setDiagnosticsLevelModifier(
@@ -89,8 +90,9 @@
   }
 
   @Test
-  public void testR8Extract() throws Throwable {
-    assumeTrue(parameters.isR8() && !parameters.isNative());
+  public void testLegacyR8() throws Throwable {
+    assumeTrue(parameters.isR8() && !parameters.isCurrentR8());
+    assertTrue(parameters.isLegacyR8());
     try {
       testForKeepAnno(parameters)
           .addProgramClasses(getInputClasses())
diff --git a/src/test/java/com/android/tools/r8/keepanno/KeepAnnoParameters.java b/src/test/java/com/android/tools/r8/keepanno/KeepAnnoParameters.java
index 53c7634..04e7bf8 100644
--- a/src/test/java/com/android/tools/r8/keepanno/KeepAnnoParameters.java
+++ b/src/test/java/com/android/tools/r8/keepanno/KeepAnnoParameters.java
@@ -13,7 +13,8 @@
   public enum KeepAnnoConfig {
     REFERENCE,
     R8_DIRECT,
-    R8_EXTRACT,
+    R8_NORMALIZED,
+    R8_RULES,
     R8_LEGACY,
     PG;
   }
@@ -56,21 +57,27 @@
   }
 
   public boolean isR8() {
-    return config == KeepAnnoConfig.R8_DIRECT
-        || config == KeepAnnoConfig.R8_EXTRACT
-        || config == KeepAnnoConfig.R8_LEGACY;
+    return isCurrentR8() || isLegacyR8();
   }
 
   public boolean isPG() {
     return config == KeepAnnoConfig.PG;
   }
 
-  public boolean isNative() {
-    return config == KeepAnnoConfig.R8_DIRECT || config == KeepAnnoConfig.R8_EXTRACT;
+  public boolean isCurrentR8() {
+    return isNativeR8() || config == KeepAnnoConfig.R8_RULES;
   }
 
-  public boolean isExtract() {
-    return config == KeepAnnoConfig.R8_EXTRACT
+  public boolean isLegacyR8() {
+    return config == KeepAnnoConfig.R8_LEGACY;
+  }
+
+  public boolean isNativeR8() {
+    return config == KeepAnnoConfig.R8_DIRECT || config == KeepAnnoConfig.R8_NORMALIZED;
+  }
+
+  public boolean isExtractRules() {
+    return config == KeepAnnoConfig.R8_RULES
         || config == KeepAnnoConfig.R8_LEGACY
         || config == KeepAnnoConfig.PG;
   }
diff --git a/src/test/java/com/android/tools/r8/keepanno/KeepAnnoTestBase.java b/src/test/java/com/android/tools/r8/keepanno/KeepAnnoTestBase.java
index 86d9529..35c00ff 100644
--- a/src/test/java/com/android/tools/r8/keepanno/KeepAnnoTestBase.java
+++ b/src/test/java/com/android/tools/r8/keepanno/KeepAnnoTestBase.java
@@ -22,7 +22,9 @@
       keepAnnoParams.add(
           new KeepAnnoParameters(parameters, KeepAnnoParameters.KeepAnnoConfig.R8_DIRECT));
       keepAnnoParams.add(
-          new KeepAnnoParameters(parameters, KeepAnnoParameters.KeepAnnoConfig.R8_EXTRACT));
+          new KeepAnnoParameters(parameters, KeepAnnoParameters.KeepAnnoConfig.R8_NORMALIZED));
+      keepAnnoParams.add(
+          new KeepAnnoParameters(parameters, KeepAnnoParameters.KeepAnnoConfig.R8_RULES));
       keepAnnoParams.add(
           new KeepAnnoParameters(parameters, KeepAnnoParameters.KeepAnnoConfig.R8_LEGACY));
       if (parameters.isCfRuntime()) {
diff --git a/src/test/java/com/android/tools/r8/keepanno/KeepAnnoTestBuilder.java b/src/test/java/com/android/tools/r8/keepanno/KeepAnnoTestBuilder.java
index 9a3c1e8..1105bd3 100644
--- a/src/test/java/com/android/tools/r8/keepanno/KeepAnnoTestBuilder.java
+++ b/src/test/java/com/android/tools/r8/keepanno/KeepAnnoTestBuilder.java
@@ -17,6 +17,7 @@
 import com.android.tools.r8.ThrowableConsumer;
 import com.android.tools.r8.ToolHelper;
 import com.android.tools.r8.graph.ClassAccessFlags;
+import com.android.tools.r8.keepanno.KeepAnnoParameters.KeepAnnoConfig;
 import com.android.tools.r8.keepanno.asm.KeepEdgeReader;
 import com.android.tools.r8.keepanno.asm.KeepEdgeWriter;
 import com.android.tools.r8.keepanno.ast.KeepDeclaration;
@@ -41,9 +42,9 @@
       case REFERENCE:
         return new ReferenceBuilder(params, temp);
       case R8_DIRECT:
-        return new R8NativeBuilder(false, params, temp);
-      case R8_EXTRACT:
-        return new R8NativeBuilder(true, params, temp);
+      case R8_NORMALIZED:
+      case R8_RULES:
+        return new R8NativeBuilder(params, temp);
       case R8_LEGACY:
         return new R8LegacyBuilder(params, temp);
       case PG:
@@ -96,7 +97,7 @@
     return this;
   }
 
-  public KeepAnnoTestBuilder applyIfR8Native(ThrowableConsumer<R8TestBuilder<?>> builderConsumer) {
+  public KeepAnnoTestBuilder applyIfR8Current(ThrowableConsumer<R8TestBuilder<?>> builderConsumer) {
     return this;
   }
 
@@ -113,7 +114,7 @@
   }
 
   public final KeepAnnoTestBuilder allowUnusedProguardConfigurationRules() {
-    return applyIfR8Native(R8TestBuilder::allowUnusedProguardConfigurationRules);
+    return applyIfR8Current(R8TestBuilder::allowUnusedProguardConfigurationRules);
   }
 
   public final KeepAnnoTestBuilder allowAccessModification() {
@@ -167,17 +168,18 @@
 
     private final R8FullTestBuilder builder;
     private List<Consumer<R8TestCompileResult>> compileResultConsumers = new ArrayList<>();
-    private final boolean useEdgeExtraction;
+    private final boolean normalizeEdges;
+    private final boolean extractRules;
 
-    private R8NativeBuilder(
-        boolean useEdgeExtraction, KeepAnnoParameters params, TemporaryFolder temp) {
+    private R8NativeBuilder(KeepAnnoParameters params, TemporaryFolder temp) {
       super(params, temp);
       builder =
           TestBase.testForR8(temp, parameters().getBackend())
               .enableExperimentalKeepAnnotations()
               .setMinApi(parameters());
-      this.useEdgeExtraction = useEdgeExtraction;
-      if (useEdgeExtraction) {
+      extractRules = params.config() == KeepAnnoConfig.R8_RULES;
+      normalizeEdges = params.config() == KeepAnnoConfig.R8_NORMALIZED;
+      if (normalizeEdges) {
         builder.getBuilder().setEnableExperimentalKeepAnnotations(false);
         builder.getBuilder().setEnableExperimentalExtractedKeepAnnotations(true);
       } else {
@@ -188,12 +190,18 @@
 
     @Override
     public KeepAnnoTestBuilder enableNativeInterpretation() {
-      if (useEdgeExtraction) {
-        // This enables native interpretation of the extracted edges.
-        builder.addOptionsModification(o -> o.testing.enableExtractedKeepAnnotations = true);
-        // This disables converting the extracted edges to PG rules in the command reader.
-        builder.getBuilder().setEnableExperimentalExtractedKeepAnnotations(false);
+      if (extractRules) {
+        return this;
       }
+      // This enables native interpretation of all keep annotations.
+      builder.addOptionsModification(
+          o -> {
+            o.testing.enableExtractedKeepAnnotations = true;
+            o.testing.enableEmbeddedKeepAnnotations = true;
+          });
+      // This disables all reading of annotations in the command reader.
+      builder.getBuilder().setEnableExperimentalKeepAnnotations(false);
+      builder.getBuilder().setEnableExperimentalExtractedKeepAnnotations(false);
       return this;
     }
 
@@ -205,7 +213,7 @@
     }
 
     @Override
-    public KeepAnnoTestBuilder applyIfR8Native(
+    public KeepAnnoTestBuilder applyIfR8Current(
         ThrowableConsumer<R8TestBuilder<?>> builderConsumer) {
       builderConsumer.acceptWithRuntimeException(builder);
       return this;
@@ -237,7 +245,7 @@
 
     private void extractAndAdd(byte[] classFileData) {
       builder.addProgramClassFileData(classFileData);
-      if (useEdgeExtraction) {
+      if (normalizeEdges) {
         List<KeepDeclaration> declarations = KeepEdgeReader.readKeepEdges(classFileData);
         if (!declarations.isEmpty()) {
           String binaryName =
diff --git a/src/test/java/com/android/tools/r8/keepanno/KeepEmptyClassTest.java b/src/test/java/com/android/tools/r8/keepanno/KeepEmptyClassTest.java
index 44306ed..a80be3c 100644
--- a/src/test/java/com/android/tools/r8/keepanno/KeepEmptyClassTest.java
+++ b/src/test/java/com/android/tools/r8/keepanno/KeepEmptyClassTest.java
@@ -3,8 +3,11 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.keepanno;
 
+import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndNotRenamed;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndRenamed;
 import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertTrue;
 
 import com.android.tools.r8.keepanno.annotations.KeepItemKind;
 import com.android.tools.r8.keepanno.annotations.KeepTarget;
@@ -13,6 +16,7 @@
 import com.android.tools.r8.transformers.ClassFileTransformer.MethodPredicate;
 import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import com.google.common.collect.ImmutableList;
 import java.util.List;
@@ -53,6 +57,18 @@
 
   private void checkOutput(CodeInspector inspector) {
     assertThat(inspector.clazz(B.class), isPresentAndNotRenamed());
+    ClassSubject classA = inspector.clazz(A.class);
+    if (parameters.isNativeR8()) {
+      assertThat(classA, isAbsent());
+    } else {
+      assertTrue(parameters.isExtractRules());
+      // PG and R8 with keep rules will keep the residual class.
+      assertThat(classA, isPresentAndRenamed());
+      // R8 using keep rules will soft-pin the precondition method too.
+      assertThat(
+          classA.uniqueMethodWithOriginalName("foo"),
+          parameters.isPG() ? isAbsent() : isPresentAndRenamed());
+    }
   }
 
   static class A {
@@ -60,7 +76,7 @@
     // Pattern includes any members
     @UsesReflection(@KeepTarget(classConstant = B.class, kind = KeepItemKind.CLASS_AND_MEMBERS))
     public void foo() throws Exception {
-      String typeName = B.class.getTypeName();
+      String typeName = B.class.getName();
       int memberCount = B.class.getDeclaredMethods().length + B.class.getDeclaredFields().length;
       System.out.println(typeName.substring(typeName.length() - 1) + ", #members: " + memberCount);
     }