diff --git a/src/main/java/com/android/tools/r8/kotlin/Kotlin.java b/src/main/java/com/android/tools/r8/kotlin/Kotlin.java
index 07f6b0b..b16b8b6 100644
--- a/src/main/java/com/android/tools/r8/kotlin/Kotlin.java
+++ b/src/main/java/com/android/tools/r8/kotlin/Kotlin.java
@@ -43,6 +43,7 @@
 
     public static final String arrayBinaryName = NAME + "/Array";
     public static final String anyDescriptor = "L" + NAME + "/Any;";
+    public static final String anyName = NAME + "/Any";
   }
 
   // Mappings from JVM types to Kotlin types (of type DexType)
diff --git a/src/main/java/com/android/tools/r8/kotlin/KotlinAnnotationArgumentInfo.java b/src/main/java/com/android/tools/r8/kotlin/KotlinAnnotationArgumentInfo.java
new file mode 100644
index 0000000..6a9b23d
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/kotlin/KotlinAnnotationArgumentInfo.java
@@ -0,0 +1,210 @@
+// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.kotlin;
+
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexDefinitionSupplier;
+import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.kotlin.Kotlin.ClassClassifiers;
+import com.android.tools.r8.naming.NamingLens;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.android.tools.r8.shaking.EnqueuerMetadataTraceable;
+import com.android.tools.r8.utils.Box;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import kotlinx.metadata.KmAnnotation;
+import kotlinx.metadata.KmAnnotationArgument;
+import kotlinx.metadata.KmAnnotationArgument.AnnotationValue;
+import kotlinx.metadata.KmAnnotationArgument.ArrayValue;
+import kotlinx.metadata.KmAnnotationArgument.EnumValue;
+import kotlinx.metadata.KmAnnotationArgument.KClassValue;
+
+abstract class KotlinAnnotationArgumentInfo implements EnqueuerMetadataTraceable {
+
+  private static final Map<String, KotlinAnnotationArgumentInfo> EMPTY_ARGUMENTS =
+      ImmutableMap.of();
+
+  abstract KmAnnotationArgument<?> rewrite(
+      AppView<AppInfoWithLiveness> appView, NamingLens namingLens);
+
+  private static KotlinAnnotationArgumentInfo createArgument(
+      KmAnnotationArgument<?> arg, DexItemFactory factory) {
+    if (arg instanceof KClassValue) {
+      return KotlinAnnotationClassValueInfo.create((KClassValue) arg, factory);
+    } else if (arg instanceof EnumValue) {
+      return KotlinAnnotationEnumValueInfo.create((EnumValue) arg, factory);
+    } else if (arg instanceof AnnotationValue) {
+      return KotlinAnnotationAnnotationValueInfo.create((AnnotationValue) arg, factory);
+    } else if (arg instanceof ArrayValue) {
+      return KotlinAnnotationArrayValueInfo.create((ArrayValue) arg, factory);
+    } else {
+      return KotlinAnnotationPrimitiveArgumentInfo.create(arg);
+    }
+  }
+
+  static Map<String, KotlinAnnotationArgumentInfo> create(
+      Map<String, KmAnnotationArgument<?>> arguments, DexItemFactory factory) {
+    if (arguments.isEmpty()) {
+      return EMPTY_ARGUMENTS;
+    }
+    LinkedHashMap<String, KotlinAnnotationArgumentInfo> modeled = new LinkedHashMap<>();
+    arguments.forEach((key, arg) -> modeled.put(key, createArgument(arg, factory)));
+    return modeled;
+  }
+
+  private static class KotlinAnnotationClassValueInfo extends KotlinAnnotationArgumentInfo {
+
+    private final KotlinTypeReference value;
+
+    private KotlinAnnotationClassValueInfo(KotlinTypeReference value) {
+      this.value = value;
+    }
+
+    private static KotlinAnnotationClassValueInfo create(KClassValue arg, DexItemFactory factory) {
+      return new KotlinAnnotationClassValueInfo(
+          KotlinTypeReference.fromBinaryName(arg.getValue(), factory));
+    }
+
+    @Override
+    public void trace(DexDefinitionSupplier definitionSupplier) {
+      value.trace(definitionSupplier);
+    }
+
+    @Override
+    KmAnnotationArgument<?> rewrite(AppView<AppInfoWithLiveness> appView, NamingLens namingLens) {
+      return new KClassValue(
+          value.toRenamedBinaryNameOrDefault(appView, namingLens, ClassClassifiers.anyName));
+    }
+  }
+
+  private static class KotlinAnnotationEnumValueInfo extends KotlinAnnotationArgumentInfo {
+
+    private final KotlinTypeReference enumClassName;
+    private final String enumEntryName;
+
+    private KotlinAnnotationEnumValueInfo(KotlinTypeReference enumClassName, String enumEntryName) {
+      this.enumClassName = enumClassName;
+      this.enumEntryName = enumEntryName;
+    }
+
+    private static KotlinAnnotationEnumValueInfo create(EnumValue arg, DexItemFactory factory) {
+      return new KotlinAnnotationEnumValueInfo(
+          KotlinTypeReference.fromBinaryName(arg.getEnumClassName(), factory),
+          arg.getEnumEntryName());
+    }
+
+    @Override
+    public void trace(DexDefinitionSupplier definitionSupplier) {
+      enumClassName.trace(definitionSupplier);
+    }
+
+    @Override
+    KmAnnotationArgument<?> rewrite(AppView<AppInfoWithLiveness> appView, NamingLens namingLens) {
+      return new EnumValue(
+          enumClassName.toRenamedBinaryNameOrDefault(appView, namingLens, ClassClassifiers.anyName),
+          enumEntryName);
+    }
+  }
+
+  private static class KotlinAnnotationAnnotationValueInfo extends KotlinAnnotationArgumentInfo {
+
+    private final KotlinAnnotationInfo value;
+
+    private KotlinAnnotationAnnotationValueInfo(KotlinAnnotationInfo value) {
+      this.value = value;
+    }
+
+    private static KotlinAnnotationAnnotationValueInfo create(
+        AnnotationValue arg, DexItemFactory factory) {
+      return new KotlinAnnotationAnnotationValueInfo(
+          KotlinAnnotationInfo.create(arg.getValue(), factory));
+    }
+
+    @Override
+    public void trace(DexDefinitionSupplier definitionSupplier) {
+      value.trace(definitionSupplier);
+    }
+
+    @Override
+    KmAnnotationArgument<?> rewrite(AppView<AppInfoWithLiveness> appView, NamingLens namingLens) {
+      Box<KmAnnotation> rewrittenAnnotation = new Box<>();
+      value.rewrite(rewrittenAnnotation::set, appView, namingLens);
+      if (rewrittenAnnotation.isSet()) {
+        return new AnnotationValue(rewrittenAnnotation.get());
+      }
+      return null;
+    }
+  }
+
+  private static class KotlinAnnotationArrayValueInfo extends KotlinAnnotationArgumentInfo {
+
+    private static final KotlinAnnotationArrayValueInfo EMPTY =
+        new KotlinAnnotationArrayValueInfo(ImmutableList.of());
+
+    private final List<KotlinAnnotationArgumentInfo> value;
+
+    private KotlinAnnotationArrayValueInfo(List<KotlinAnnotationArgumentInfo> value) {
+      this.value = value;
+    }
+
+    private static KotlinAnnotationArrayValueInfo create(ArrayValue arg, DexItemFactory factory) {
+      if (arg.getValue().isEmpty()) {
+        return EMPTY;
+      }
+      ImmutableList.Builder<KotlinAnnotationArgumentInfo> builder = ImmutableList.builder();
+      for (KmAnnotationArgument<?> argument : arg.getValue()) {
+        builder.add(createArgument(argument, factory));
+      }
+      return new KotlinAnnotationArrayValueInfo(builder.build());
+    }
+
+    @Override
+    public void trace(DexDefinitionSupplier definitionSupplier) {
+      for (KotlinAnnotationArgumentInfo kotlinAnnotationArgumentInfo : value) {
+        kotlinAnnotationArgumentInfo.trace(definitionSupplier);
+      }
+    }
+
+    @Override
+    KmAnnotationArgument<?> rewrite(AppView<AppInfoWithLiveness> appView, NamingLens namingLens) {
+      List<KmAnnotationArgument<?>> rewrittenArguments = new ArrayList<>();
+      for (KotlinAnnotationArgumentInfo kotlinAnnotationArgumentInfo : value) {
+        KmAnnotationArgument<?> rewrittenArg =
+            kotlinAnnotationArgumentInfo.rewrite(appView, namingLens);
+        if (rewrittenArg != null) {
+          rewrittenArguments.add(rewrittenArg);
+        }
+      }
+      return new ArrayValue(rewrittenArguments);
+    }
+  }
+
+  private static class KotlinAnnotationPrimitiveArgumentInfo extends KotlinAnnotationArgumentInfo {
+
+    private final KmAnnotationArgument<?> argument;
+
+    private KotlinAnnotationPrimitiveArgumentInfo(KmAnnotationArgument<?> argument) {
+      this.argument = argument;
+    }
+
+    private static KotlinAnnotationPrimitiveArgumentInfo create(KmAnnotationArgument<?> argument) {
+      return new KotlinAnnotationPrimitiveArgumentInfo(argument);
+    }
+
+    @Override
+    public void trace(DexDefinitionSupplier definitionSupplier) {
+      // Nothing to trace
+    }
+
+    @Override
+    KmAnnotationArgument<?> rewrite(AppView<AppInfoWithLiveness> appView, NamingLens namingLens) {
+      return argument;
+    }
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/kotlin/KotlinAnnotationInfo.java b/src/main/java/com/android/tools/r8/kotlin/KotlinAnnotationInfo.java
index 90ed44a..fd4d087 100644
--- a/src/main/java/com/android/tools/r8/kotlin/KotlinAnnotationInfo.java
+++ b/src/main/java/com/android/tools/r8/kotlin/KotlinAnnotationInfo.java
@@ -12,6 +12,7 @@
 import com.android.tools.r8.shaking.EnqueuerMetadataTraceable;
 import com.android.tools.r8.utils.DescriptorUtils;
 import com.google.common.collect.ImmutableList;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import kotlinx.metadata.KmAnnotation;
@@ -23,19 +24,18 @@
   private static final List<KotlinAnnotationInfo> EMPTY_ANNOTATIONS = ImmutableList.of();
 
   private final KotlinTypeReference annotationType;
-  // TODO(b/155053894): Model KmAnnotationArgument.
-  private final Map<String, KmAnnotationArgument<?>> arguments;
+  private final Map<String, KotlinAnnotationArgumentInfo> arguments;
 
   private KotlinAnnotationInfo(
-      KotlinTypeReference annotationType, Map<String, KmAnnotationArgument<?>> arguments) {
+      KotlinTypeReference annotationType, Map<String, KotlinAnnotationArgumentInfo> arguments) {
     this.annotationType = annotationType;
     this.arguments = arguments;
   }
 
-  private static KotlinAnnotationInfo create(KmAnnotation annotation, DexItemFactory factory) {
+  static KotlinAnnotationInfo create(KmAnnotation annotation, DexItemFactory factory) {
     return new KotlinAnnotationInfo(
         KotlinTypeReference.fromBinaryName(annotation.getClassName(), factory),
-        annotation.getArguments());
+        KotlinAnnotationArgumentInfo.create(annotation.getArguments(), factory));
   }
 
   static List<KotlinAnnotationInfo> create(List<KmAnnotation> annotations, DexItemFactory factory) {
@@ -60,13 +60,20 @@
       return;
     }
     String classifier = DescriptorUtils.descriptorToKotlinClassifier(renamedDescriptor);
-    KmAnnotation annotation = new KmAnnotation(classifier, arguments);
-    visitorProvider.get(annotation);
+    Map<String, KmAnnotationArgument<?>> rewrittenArguments = new LinkedHashMap<>();
+    arguments.forEach(
+        (key, arg) -> {
+          KmAnnotationArgument<?> rewrittenArg = arg.rewrite(appView, namingLens);
+          if (rewrittenArg != null) {
+            rewrittenArguments.put(key, rewrittenArg);
+          }
+        });
+    visitorProvider.get(new KmAnnotation(classifier, rewrittenArguments));
   }
 
   @Override
   public void trace(DexDefinitionSupplier definitionSupplier) {
     annotationType.trace(definitionSupplier);
-    // TODO(b/155053894): Trace annotation arguments.
+    arguments.forEach((ignored, arg) -> arg.trace(definitionSupplier));
   }
 }
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteAnnotationTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteAnnotationTest.java
index 6fae341..11c47de 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteAnnotationTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteAnnotationTest.java
@@ -8,7 +8,6 @@
 import static com.android.tools.r8.utils.codeinspector.Matchers.isNotRenamed;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isRenamed;
-import static org.hamcrest.CoreMatchers.containsString;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
 
@@ -36,7 +35,7 @@
 @RunWith(Parameterized.class)
 public class MetadataRewriteAnnotationTest extends KotlinMetadataTestBase {
 
-  private final String EXPECTED_SMOKE =
+  private final String EXPECTED =
       StringUtils.lines(
           "class com.android.tools.r8.kotlin.metadata.annotation_lib.Foo",
           "class com.android.tools.r8.kotlin.metadata.annotation_lib.Foo",
@@ -50,9 +49,14 @@
           "class com.android.tools.r8.kotlin.metadata.annotation_lib.Foo",
           "DOWN",
           "class com.android.tools.r8.kotlin.metadata.annotation_lib.Foo",
-          "UP");
+          "UP",
+          "Top most",
+          "class com.android.tools.r8.kotlin.metadata.annotation_lib.Foo",
+          "DOWN",
+          "com.android.tools.r8.kotlin.metadata.annotation_lib.Foo");
   private static final String PKG_LIB = PKG + ".annotation_lib";
   private static final String PKG_APP = PKG + ".annotation_app";
+  private static final String FOO_ORIGINAL_NAME = PKG_LIB + ".Foo";
   private static final String FOO_FINAL_NAME = "a.b.c";
 
   @Parameterized.Parameters(name = "{0} target: {1}")
@@ -97,21 +101,23 @@
             ToolHelper.getKotlinStdlibJar(), ToolHelper.getKotlinReflectJar(), libJar)
         .addClasspath(output)
         .run(parameters.getRuntime(), PKG_APP + ".MainKt")
-        .assertSuccessWithOutput(EXPECTED_SMOKE);
+        .assertSuccessWithOutput(EXPECTED);
   }
 
   @Test
   public void testMetadataForLib() throws Exception {
-    String fooTypeName = PKG_LIB + ".Foo";
     Path libJar =
         testForR8(parameters.getBackend())
             .addProgramFiles(libJars.get(targetVersion))
             /// Keep the annotations
             .addKeepClassAndMembersRules(PKG_LIB + ".AnnoWithClassAndEnum")
             .addKeepClassAndMembersRules(PKG_LIB + ".AnnoWithClassArr")
+            .addKeepRules("-keep class " + PKG_LIB + ".Nested { *** kept(); } ")
+            .addKeepRules("-keep class " + PKG_LIB + ".Nested { *** message(); } ")
+            // .addKeepRules("-keep class " + PKG_LIB + ".Nested { *** kept; *** getKept(); } ")
             // Keep Foo but rename to test arguments
-            .addKeepClassAndMembersRulesWithAllowObfuscation(fooTypeName)
-            .addApplyMapping(fooTypeName + " -> " + FOO_FINAL_NAME + ":")
+            .addKeepClassAndMembersRulesWithAllowObfuscation(FOO_ORIGINAL_NAME)
+            .addApplyMapping(FOO_ORIGINAL_NAME + " -> " + FOO_FINAL_NAME + ":")
             // Keep Direction but rename the enum
             .addKeepClassAndMembersRules(PKG_LIB + ".Direction")
             // Keep Bar and Baz and Quux because we are directly reflecting on them
@@ -120,7 +126,6 @@
             .addKeepClassAndMembersRules(PKG_LIB + ".Quux")
             // Keep the static class for the type alias
             .addKeepClassAndMembersRules(PKG_LIB + ".LibKt")
-            .addKeepRuntimeVisibleAnnotations()
             .addKeepAttributes(
                 ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS,
                 ProguardKeepAttributes.RUNTIME_VISIBLE_PARAMETER_ANNOTATIONS,
@@ -139,8 +144,7 @@
             ToolHelper.getKotlinStdlibJar(), ToolHelper.getKotlinReflectJar(), libJar)
         .addProgramFiles(output)
         .run(parameters.getRuntime(), PKG_APP + ".MainKt")
-        // TODO(b/155053894): Fails because reflect cannot find the class.
-        .assertFailureWithErrorThatMatches(containsString("KotlinReflectionInternalError"));
+        .assertSuccessWithOutput(EXPECTED.replace(FOO_ORIGINAL_NAME, FOO_FINAL_NAME));
   }
 
   private void inspect(CodeInspector inspector) {
@@ -171,9 +175,8 @@
     Map<String, KmAnnotationArgument<?>> arguments = annotation.getArguments();
     assertEquals(1, arguments.size());
     ArrayValue classes = (ArrayValue) arguments.get("classes");
-    // TODO(b/155053894): This should be renamed.
     assertEquals(
-        "KClassValue(value=" + foo.getOriginalBinaryName() + ")",
+        "KClassValue(value=" + foo.getFinalBinaryName() + ")",
         classes.getValue().get(0).toString());
     assertEquals(
         "KClassValue(value=" + bar.getFinalBinaryName() + ")",
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/annotation_app/main.kt b/src/test/java/com/android/tools/r8/kotlin/metadata/annotation_app/main.kt
index 34d39b8..d7ed237 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/annotation_app/main.kt
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/annotation_app/main.kt
@@ -8,7 +8,9 @@
 import com.android.tools.r8.kotlin.metadata.annotation_lib.AnnoWithClassArr
 import com.android.tools.r8.kotlin.metadata.annotation_lib.Bar
 import com.android.tools.r8.kotlin.metadata.annotation_lib.Baz
+import com.android.tools.r8.kotlin.metadata.annotation_lib.Nested
 import com.android.tools.r8.kotlin.metadata.annotation_lib.Quux
+import kotlin.reflect.full.memberProperties
 import kotlin.reflect.full.primaryConstructor
 import kotlin.reflect.full.valueParameters
 
@@ -23,6 +25,14 @@
   // https://youtrack.jetbrains.com/issue/KT-21489
   Quux::methodWithTypeAnnotations
       .returnType.arguments.get(0).type?.annotations?.get(0)?.printAnnoWithClassAndEnum()
+  val nested = Quux::methodWithNestedAnnotations.returnType.arguments[0].type?.annotations?.get(0) as Nested
+  println(nested.message)
+  nested.kept.printAnnoWithClassAndEnum()
+  if (nested::class::memberProperties.get().any { it.name.equals("notKept") }) {
+    println("com.android.tools.r8.kotlin.metadata.annotation_lib.Foo")
+  } else {
+    println("a.b.c")
+  }
 }
 
 fun Annotation.printAnnoWithClassArr() {
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/annotation_lib/lib.kt b/src/test/java/com/android/tools/r8/kotlin/metadata/annotation_lib/lib.kt
index 38a574c..0c6ff6c 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/annotation_lib/lib.kt
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/annotation_lib/lib.kt
@@ -17,9 +17,10 @@
 @Retention(AnnotationRetention.RUNTIME)
 annotation class AnnoWithClassAndEnum(val clazz : KClass<*>, val direction : Direction)
 
-@Target(AnnotationTarget.CLASS, AnnotationTarget.CONSTRUCTOR, AnnotationTarget.TYPEALIAS)
+@Target(AnnotationTarget.CLASS, AnnotationTarget.CONSTRUCTOR, AnnotationTarget.TYPEALIAS,
+        AnnotationTarget.TYPE)
 @Retention(AnnotationRetention.RUNTIME)
-annotation class AnnoWithClassArr(val classes : Array<KClass<*>>)
+annotation class AnnoWithClassArr(val classes: Array<KClass<*>>)
 
 class Foo
 
@@ -38,10 +39,23 @@
 @AnnoWithClassArr([Foo::class, Bar::class])
 typealias Qux = Foo
 
+annotation class AnnoNotKept
+
+@Target(AnnotationTarget.TYPE)
+annotation class Nested(
+  val message: String,
+  val kept: AnnoWithClassAndEnum,
+  val notKept: AnnoNotKept
+)
 
 class Quux {
 
   fun methodWithTypeAnnotations() : Array<@AnnoWithClassAndEnum(Foo::class, Direction.UP) Int> {
     return arrayOf(1)
   }
+
+  fun methodWithNestedAnnotations() : Array<@Nested("Top most", AnnoWithClassAndEnum(Foo::class, Direction.DOWN), AnnoNotKept()) Int> {
+    return arrayOf(1)
+  }
 }
+