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 7104c92..88b07f1 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
@@ -21,6 +21,7 @@
 import com.android.tools.r8.keepanno.ast.AnnotationConstants.MethodAccess;
 import com.android.tools.r8.keepanno.ast.AnnotationConstants.Target;
 import com.android.tools.r8.keepanno.ast.AnnotationConstants.UsedByReflection;
+import com.android.tools.r8.keepanno.ast.AnnotationConstants.UsesReflectionToConstruct;
 import com.android.tools.r8.keepanno.ast.KeepAnnotationPattern;
 import com.android.tools.r8.keepanno.ast.KeepBindingReference;
 import com.android.tools.r8.keepanno.ast.KeepBindings;
@@ -29,6 +30,7 @@
 import com.android.tools.r8.keepanno.ast.KeepCheck.KeepCheckKind;
 import com.android.tools.r8.keepanno.ast.KeepClassBindingReference;
 import com.android.tools.r8.keepanno.ast.KeepClassItemPattern;
+import com.android.tools.r8.keepanno.ast.KeepClassPattern;
 import com.android.tools.r8.keepanno.ast.KeepCondition;
 import com.android.tools.r8.keepanno.ast.KeepConsequences;
 import com.android.tools.r8.keepanno.ast.KeepConstraint;
@@ -102,6 +104,7 @@
   private static boolean isEmbeddedAnnotation(String descriptor) {
     if (AnnotationConstants.Edge.isDescriptor(descriptor)
         || AnnotationConstants.UsesReflection.isDescriptor(descriptor)
+        || AnnotationConstants.UsesReflectionToConstruct.isDescriptor(descriptor)
         || AnnotationConstants.ForApi.isDescriptor(descriptor)
         || AnnotationConstants.UsedByReflection.isDescriptor(descriptor)
         || AnnotationConstants.UsedByNative.isDescriptor(descriptor)
@@ -356,6 +359,16 @@
                     .setClassNamePattern(KeepQualifiedClassNamePattern.exact(className))
                     .build());
       }
+      if (AnnotationConstants.UsesReflectionToConstruct.isDescriptor(descriptor)) {
+        return new UsesReflectionToConstructVisitor(
+            parsingContext,
+            parent::accept,
+            setContext,
+            bindingsHelper ->
+                KeepClassItemPattern.builder()
+                    .setClassNamePattern(KeepQualifiedClassNamePattern.exact(className))
+                    .build());
+      }
       if (ForApi.isDescriptor(descriptor)) {
         return new ForApiClassVisitor(parsingContext, parent::accept, setContext, className);
       }
@@ -498,6 +511,23 @@
             bindingsHelper ->
                 createMethodItemContext(className, methodName, methodDescriptor, bindingsHelper));
       }
+      if (AnnotationConstants.UsesReflectionToConstruct.isDescriptor(descriptor)) {
+        return new UsesReflectionToConstructVisitor(
+            parsingContext,
+            parent::accept,
+            setContext,
+            bindingsHelper ->
+                createMethodItemContext(className, methodName, methodDescriptor, bindingsHelper));
+      }
+      if (AnnotationConstants.UsesReflectionToConstruct.isKotlinRepeatableContainerDescriptor(
+          descriptor)) {
+        return new UsesReflectionForInstantiationContainerVisitor(
+            parsingContext,
+            parent::accept,
+            setContext,
+            bindingsHelper ->
+                createMethodItemContext(className, methodName, methodDescriptor, bindingsHelper));
+      }
       if (AnnotationConstants.ForApi.isDescriptor(descriptor)) {
         return new ForApiMemberVisitor(
             parsingContext,
@@ -1340,6 +1370,226 @@
     }
   }
 
+  private static class ParametersClassVisitor extends AnnotationVisitorBase {
+    private final ParsingContext parsingContext;
+    private final Consumer<KeepMethodParametersPattern> consumer;
+    private final KeepMethodParametersPattern.Builder builder =
+        KeepMethodParametersPattern.builder();
+
+    public ParametersClassVisitor(
+        PropertyParsingContext parsingContext, Consumer<KeepMethodParametersPattern> consumer) {
+      super(parsingContext);
+      this.parsingContext = parsingContext;
+      this.consumer = consumer;
+    }
+
+    @Override
+    public void visit(String name, Object value) {
+      assert name == null;
+      if (value instanceof String) {
+        builder.addParameterTypePattern(KeepTypePattern.fromDescriptor("L" + value + ";"));
+      } else if (value instanceof Type) {
+        builder.addParameterTypePattern(
+            KeepTypePattern.fromDescriptor(((Type) value).getDescriptor()));
+      } else {
+        super.visit(name, value);
+      }
+    }
+
+    @Override
+    public void visitEnd() {
+      consumer.accept(builder.build());
+    }
+  }
+
+  private static class ParametersClassNamesVisitor extends AnnotationVisitorBase {
+    private final ParsingContext parsingContext;
+    private final Consumer<KeepMethodParametersPattern> consumer;
+    private final KeepMethodParametersPattern.Builder builder =
+        KeepMethodParametersPattern.builder();
+
+    public ParametersClassNamesVisitor(
+        PropertyParsingContext parsingContext, Consumer<KeepMethodParametersPattern> consumer) {
+      super(parsingContext);
+      this.parsingContext = parsingContext;
+      this.consumer = consumer;
+    }
+
+    @Override
+    public void visit(String name, Object value) {
+      assert name == null;
+      if (value instanceof String) {
+        builder.addParameterTypePattern(KeepTypePattern.fromDescriptor("L" + value + ";"));
+      } else {
+        super.visit(name, value);
+      }
+    }
+
+    @Override
+    public void visitEnd() {
+      consumer.accept(builder.build());
+    }
+  }
+
+  private static class UsesReflectionForInstantiationContainerVisitor
+      extends AnnotationVisitorBase {
+
+    private final AnnotationParsingContext parsingContext;
+    private final Parent<KeepEdge> parent;
+    Consumer<KeepEdgeMetaInfo.Builder> addContext;
+    Function<UserBindingsHelper, KeepItemPattern> contextBuilder;
+
+    UsesReflectionForInstantiationContainerVisitor(
+        AnnotationParsingContext parsingContext,
+        Parent<KeepEdge> parent,
+        Consumer<KeepEdgeMetaInfo.Builder> addContext,
+        Function<UserBindingsHelper, KeepItemPattern> contextBuilder) {
+      super(parsingContext);
+      this.parsingContext = parsingContext;
+      this.parent = parent;
+      this.addContext = addContext;
+      this.contextBuilder = contextBuilder;
+    }
+
+    @Override
+    public AnnotationVisitor visitArray(String name) {
+      if (name.equals("value")) {
+        return new UsesReflectionForInstantiationsVisitor(
+            parsingContext, parent, addContext, contextBuilder);
+      }
+      return super.visitArray(name);
+    }
+
+    @Override
+    public void visitEnd() {
+      super.visitEnd();
+    }
+  }
+
+  private static class UsesReflectionForInstantiationsVisitor extends AnnotationVisitorBase {
+    private final AnnotationParsingContext parsingContext;
+    private final Parent<KeepEdge> parent;
+    Consumer<KeepEdgeMetaInfo.Builder> addContext;
+    Function<UserBindingsHelper, KeepItemPattern> contextBuilder;
+
+    public UsesReflectionForInstantiationsVisitor(
+        AnnotationParsingContext parsingContext,
+        Parent<KeepEdge> parent,
+        Consumer<KeepEdgeMetaInfo.Builder> addContext,
+        Function<UserBindingsHelper, KeepItemPattern> contextBuilder) {
+      super(parsingContext);
+      this.parsingContext = parsingContext;
+      this.parent = parent;
+      this.addContext = addContext;
+      this.contextBuilder = contextBuilder;
+    }
+
+    @Override
+    public AnnotationVisitor visitAnnotation(String name, String descriptor) {
+      assert name == null;
+      if (AnnotationConstants.UsesReflectionToConstruct.isDescriptor(descriptor)) {
+        return new UsesReflectionToConstructVisitor(
+            parsingContext, parent, addContext, contextBuilder);
+      }
+      return super.visitAnnotation(name, descriptor);
+    }
+  }
+
+  private static class UsesReflectionToConstructVisitor extends AnnotationVisitorBase {
+
+    private final ParsingContext parsingContext;
+    private final Parent<KeepEdge> parent;
+    private final KeepEdge.Builder builder = KeepEdge.builder();
+    private final KeepPreconditions.Builder preconditions = KeepPreconditions.builder();
+    private final KeepEdgeMetaInfo.Builder metaInfoBuilder = KeepEdgeMetaInfo.builder();
+    private KeepMethodParametersPattern parameters = KeepMethodParametersPattern.any();
+    private final UserBindingsHelper bindingsHelper = new UserBindingsHelper();
+
+    private KeepQualifiedClassNamePattern qualifiedName;
+
+    UsesReflectionToConstructVisitor(
+        AnnotationParsingContext parsingContext,
+        Parent<KeepEdge> parent,
+        Consumer<KeepEdgeMetaInfo.Builder> addContext,
+        Function<UserBindingsHelper, KeepItemPattern> contextBuilder) {
+      super(parsingContext);
+      this.parsingContext = parsingContext;
+      this.parent = parent;
+      KeepItemPattern context = contextBuilder.apply(bindingsHelper);
+      KeepBindingReference contextBinding =
+          bindingsHelper.defineFreshItemBinding("CONTEXT", context);
+      preconditions.addCondition(KeepCondition.builder().setItemReference(contextBinding).build());
+      addContext.accept(metaInfoBuilder);
+    }
+
+    @Override
+    public void visit(String name, Object value) {
+      if (name.equals(UsesReflectionToConstruct.classConstant) && value instanceof Type) {
+        qualifiedName =
+            KeepQualifiedClassNamePattern.exactFromDescriptor(((Type) value).getDescriptor());
+        return;
+      }
+      if (name.equals(AnnotationConstants.UsesReflectionToConstruct.className)
+          && value instanceof String) {
+        qualifiedName = KeepQualifiedClassNamePattern.exact((String) value);
+        return;
+      }
+      super.visit(name, value);
+    }
+
+    @Override
+    public AnnotationVisitor visitArray(String name) {
+      PropertyParsingContext propertyParsingContext = parsingContext.property(name);
+      if (name.equals(UsesReflectionToConstruct.params)) {
+        return new ParametersClassVisitor(
+            propertyParsingContext, parameters -> this.parameters = parameters);
+      }
+      if (name.equals(UsesReflectionToConstruct.paramClassNames)) {
+        return new ParametersClassNamesVisitor(
+            propertyParsingContext, parameters -> this.parameters = parameters);
+      }
+      return super.visitArray(name);
+    }
+
+    @Override
+    public void visitEnd() {
+      KeepClassItemPattern classItemPattern =
+          KeepClassItemPattern.builder()
+              .setClassPattern(
+                  KeepClassPattern.builder().setClassNamePattern(qualifiedName).build())
+              .build();
+      KeepClassBindingReference classBinding =
+          bindingsHelper.defineFreshClassBinding(classItemPattern);
+      KeepMemberItemPattern keepMemberItemPattern =
+          KeepMemberItemPattern.builder()
+              .setClassReference(classBinding)
+              .setMemberPattern(
+                  KeepMethodPattern.builder()
+                      .setNamePattern(KeepMethodNamePattern.instanceInitializer())
+                      .setParametersPattern(parameters)
+                      .setReturnTypeVoid()
+                      .build())
+              .build();
+      KeepMemberBindingReference memberBinding =
+          bindingsHelper.defineFreshMemberBinding(keepMemberItemPattern);
+      builder.setConsequences(
+          KeepConsequences.builder()
+              .addTarget(
+                  KeepTarget.builder()
+                      .setItemReference(classBinding)
+                      .setItemReference(memberBinding)
+                      .build())
+              .addTarget(KeepTarget.builder().setItemReference(classBinding).build())
+              .build());
+      parent.accept(
+          builder
+              .setMetaInfo(metaInfoBuilder.build())
+              .setBindings(bindingsHelper.build())
+              .setPreconditions(preconditions.build())
+              .build());
+    }
+  }
+
   private static class KeepBindingsVisitor extends AnnotationVisitorBase {
     private final ParsingContext parsingContext;
     private final UserBindingsHelper helper;
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 45b8aa6..515c37d 100644
--- a/src/test/java/com/android/tools/r8/keepanno/KeepAnnoTestBase.java
+++ b/src/test/java/com/android/tools/r8/keepanno/KeepAnnoTestBase.java
@@ -7,13 +7,17 @@
 import static com.android.tools.r8.R8TestBuilder.KeepAnnotationLibrary.ANDROIDX;
 import static com.android.tools.r8.R8TestBuilder.KeepAnnotationLibrary.LEGACY;
 
+import com.android.tools.r8.KotlinCompileMemoizer;
 import com.android.tools.r8.R8TestBuilder.KeepAnnotationLibrary;
 import com.android.tools.r8.TestBase;
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
 import com.android.tools.r8.keepanno.KeepAnnoParameters.KeepAnnoConfig;
 import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.nio.file.Path;
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.List;
 
 public abstract class KeepAnnoTestBase extends TestBase {
@@ -44,4 +48,17 @@
   public KeepAnnoTestBuilder testForKeepAnnoAndroidX(KeepAnnoParameters params) throws IOException {
     return testForKeepAnno(params, ANDROIDX);
   }
+
+  protected static KotlinCompileMemoizer getCompileMemoizerWithKeepAnnoLib(
+      Collection<Path> sources) {
+    assert sources.size() > 0;
+    Path keepAnnoLib;
+    try {
+      keepAnnoLib = KeepAnnoTestUtils.getKeepAnnoLib(getStaticTemp());
+    } catch (IOException e) {
+      throw new UncheckedIOException(e);
+    }
+    return new KotlinCompileMemoizer(sources)
+        .configure(kotlinCompilerTool -> kotlinCompilerTool.addClasspathFiles(keepAnnoLib));
+  }
 }
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 b9baff4..1f9fb46 100644
--- a/src/test/java/com/android/tools/r8/keepanno/KeepAnnoTestBuilder.java
+++ b/src/test/java/com/android/tools/r8/keepanno/KeepAnnoTestBuilder.java
@@ -5,6 +5,9 @@
 package com.android.tools.r8.keepanno;
 
 import static com.android.tools.r8.R8TestBuilder.KeepAnnotationLibrary.ANDROIDX;
+import static com.android.tools.r8.utils.FileUtils.isClassFile;
+import static com.android.tools.r8.utils.FileUtils.isJarFile;
+import static com.android.tools.r8.utils.FileUtils.isZipFile;
 
 import com.android.tools.r8.ExternalR8TestBuilder;
 import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
@@ -33,6 +36,8 @@
 import com.android.tools.r8.keepanno.proto.KeepSpecProtos.KeepSpec;
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.partial.R8PartialCompilationConfiguration.Builder;
+import com.android.tools.r8.utils.ZipUtils;
+import com.google.common.io.ByteStreams;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
@@ -100,6 +105,9 @@
   public abstract KeepAnnoTestBuilder addProgramClassFileData(List<byte[]> programClasses)
       throws IOException;
 
+  public abstract KeepAnnoTestBuilder addProgramFilesWithoutAnnotations(List<Path> programFiles)
+      throws IOException;
+
   public final KeepAnnoTestBuilder addKeepMainRule(Class<?> mainClass) {
     return applyIfShrinker(b -> b.addKeepMainRule(mainClass));
   }
@@ -108,8 +116,16 @@
     return applyIfShrinker(b -> b.addKeepClassRules(classes));
   }
 
+  public final KeepAnnoTestBuilder addKeepRules(String... classes) {
+    return applyIfShrinker(b -> b.addKeepRules(classes));
+  }
+
+  public abstract void compile() throws Exception;
+
   public abstract SingleTestRunResult<?> run(Class<?> mainClass) throws Exception;
 
+  public abstract SingleTestRunResult<?> run(String mainClass) throws Exception;
+
   public KeepAnnoTestBuilder applyIfShrinker(
       ThrowableConsumer<TestShrinkerBuilder<?, ?, ?, ?, ?>> builderConsumer) {
     applyIfR8(builderConsumer);
@@ -132,6 +148,12 @@
     return this;
   }
 
+  public KeepAnnoTestBuilder applyIfR8OrR8Partial(
+      ThrowableConsumer<TestShrinkerBuilder<?, ?, ?, ?, ?>> r8BuilderConsumer,
+      ThrowableConsumer<R8PartialTestBuilder> r8PartialBuilderConsumer) {
+    return this;
+  }
+
   public KeepAnnoTestBuilder applyIfPG(ThrowableConsumer<ProguardTestBuilder> builderConsumer) {
     return this;
   }
@@ -213,6 +235,14 @@
     }
 
     @Override
+    public KeepAnnoTestBuilder addProgramFilesWithoutAnnotations(List<Path> programFiles)
+        throws IOException {
+      // TODO(b/392865072): Ensure annotations are not processed.
+      builder.addProgramFiles(programFiles);
+      return this;
+    }
+
+    @Override
     public KeepAnnoTestBuilder inspectOutputRules(Consumer<String> configConsumer) {
       // Ignore the consumer.
       return this;
@@ -225,9 +255,19 @@
     }
 
     @Override
+    public void compile() throws Exception {
+      // Do nothing.
+    }
+
+    @Override
     public SingleTestRunResult<?> run(Class<?> mainClass) throws Exception {
       return builder.run(parameters().getRuntime(), mainClass);
     }
+
+    @Override
+    public SingleTestRunResult<?> run(String mainClass) throws Exception {
+      return builder.run(parameters().getRuntime(), mainClass);
+    }
   }
 
   private abstract static class R8NativeBuilderBase<
@@ -275,9 +315,29 @@
     }
 
     @Override
+    public KeepAnnoTestBuilder applyIfR8OrR8Partial(
+        ThrowableConsumer<TestShrinkerBuilder<?, ?, ?, ?, ?>> r8BuilderConsumer,
+        ThrowableConsumer<R8PartialTestBuilder> r8PartialBuilderConsumer) {
+      r8BuilderConsumer.acceptWithRuntimeException(builder);
+      return this;
+    }
+
+    @Override
     public KeepAnnoTestBuilder addProgramFiles(List<Path> programFiles) throws IOException {
       for (Path programFile : programFiles) {
-        extractAndAdd(Files.readAllBytes(programFile));
+        if (isClassFile(programFile)) {
+          extractAndAdd(Files.readAllBytes(programFile));
+        } else if (isJarFile(programFile) || isZipFile(programFile)) {
+          ZipUtils.iter(
+              programFile,
+              (entry, input) -> {
+                if (isClassFile(entry.getName())) {
+                  extractAndAdd(ByteStreams.toByteArray(input));
+                }
+              });
+        } else {
+          assert false : "Unsupported file format";
+        }
       }
       return this;
     }
@@ -331,6 +391,14 @@
     }
 
     @Override
+    public KeepAnnoTestBuilder addProgramFilesWithoutAnnotations(List<Path> programFiles)
+        throws IOException {
+      // TODO(b/392865072): Ensure annotations are not processed.
+      builder.addProgramFiles(programFiles);
+      return this;
+    }
+
+    @Override
     public KeepAnnoTestBuilder inspectOutputRules(Consumer<String> configConsumer) {
       compileResultConsumers.add(
           result -> configConsumer.accept(result.getProguardConfiguration()));
@@ -344,11 +412,24 @@
     }
 
     @Override
+    public void compile() throws Exception {
+      R compileResult = builder.compile();
+      compileResultConsumers.forEach(fn -> fn.accept(compileResult));
+    }
+
+    @Override
     public SingleTestRunResult<?> run(Class<?> mainClass) throws Exception {
       R compileResult = builder.compile();
       compileResultConsumers.forEach(fn -> fn.accept(compileResult));
       return compileResult.run(parameters().getRuntime(), mainClass);
     }
+
+    @Override
+    public SingleTestRunResult<?> run(String mainClass) throws Exception {
+      R compileResult = builder.compile();
+      compileResultConsumers.forEach(fn -> fn.accept(compileResult));
+      return compileResult.run(parameters().getRuntime(), mainClass);
+    }
   }
 
   private static class R8NativeBuilder
@@ -410,6 +491,14 @@
     }
 
     @Override
+    public KeepAnnoTestBuilder applyIfR8OrR8Partial(
+        ThrowableConsumer<TestShrinkerBuilder<?, ?, ?, ?, ?>> r8BuilderConsumer,
+        ThrowableConsumer<R8PartialTestBuilder> r8PartialBuilderConsumer) {
+      r8PartialBuilderConsumer.acceptWithRuntimeException(builder);
+      return this;
+    }
+
+    @Override
     boolean isExtractRules() {
       return config == KeepAnnoConfig.R8_PARTIAL_RULES;
     }
@@ -455,6 +544,14 @@
     }
 
     @Override
+    public KeepAnnoTestBuilder applyIfR8OrR8Partial(
+        ThrowableConsumer<TestShrinkerBuilder<?, ?, ?, ?, ?>> r8BuilderConsumer,
+        ThrowableConsumer<R8PartialTestBuilder> r8PartialBuilderConsumer) {
+      r8BuilderConsumer.acceptWithRuntimeException(builder);
+      return this;
+    }
+
+    @Override
     public KeepAnnoTestBuilder addProgramFiles(List<Path> programFiles) throws IOException {
       List<String> rules = KeepAnnoTestUtils.extractRulesFromFiles(programFiles, extractorOptions);
       builder.addProgramFiles(programFiles);
@@ -484,6 +581,14 @@
     }
 
     @Override
+    public KeepAnnoTestBuilder addProgramFilesWithoutAnnotations(List<Path> programFiles)
+        throws IOException {
+      // TODO(b/392865072): Ensure annotations are not processed.
+      builder.addProgramFiles(programFiles);
+      return this;
+    }
+
+    @Override
     public KeepAnnoTestBuilder inspectOutputRules(Consumer<String> configConsumer) {
       configConsumers.add(lines -> configConsumer.accept(String.join("\n", lines)));
       return this;
@@ -495,11 +600,23 @@
     }
 
     @Override
+    public void compile() throws Exception {
+      builder.compile();
+    }
+
+    @Override
     public SingleTestRunResult<?> run(Class<?> mainClass) throws Exception {
       configConsumers.forEach(fn -> fn.accept(builder.getConfig()));
       extractedRulesConsumers.forEach(fn -> fn.accept(extractedRules));
       return builder.run(parameters().getRuntime(), mainClass);
     }
+
+    @Override
+    public SingleTestRunResult<?> run(String mainClass) throws Exception {
+      configConsumers.forEach(fn -> fn.accept(builder.getConfig()));
+      extractedRulesConsumers.forEach(fn -> fn.accept(extractedRules));
+      return builder.run(parameters().getRuntime(), mainClass);
+    }
   }
 
   private static class PGBuilder extends KeepAnnoTestBuilder {
@@ -521,11 +638,7 @@
       builder =
           TestBase.testForProguard(KeepAnnoTestUtils.PG_VERSION, temp)
               .applyIf(
-                  keepAnnotationLibrary == ANDROIDX,
-                  b ->
-                      b.addDefaultRuntimeLibrary(parameters())
-                          .addLibraryFiles(
-                              kotlinc.getKotlinStdlibJar(), kotlinc.getKotlinAnnotationJar()))
+                  keepAnnotationLibrary == ANDROIDX, b -> b.addDefaultRuntimeLibrary(parameters()))
               .addProgramFiles(KeepAnnoTestUtils.getKeepAnnoLib(temp, keepAnnotationLibrary))
               .setMinApi(parameters());
     }
@@ -566,6 +679,14 @@
     }
 
     @Override
+    public KeepAnnoTestBuilder addProgramFilesWithoutAnnotations(List<Path> programFiles)
+        throws IOException {
+      // TODO(b/392865072): Ensure annotations are not processed.
+      builder.addProgramFiles(programFiles);
+      return this;
+    }
+
+    @Override
     public KeepAnnoTestBuilder inspectOutputRules(Consumer<String> configConsumer) {
       configConsumers.add(lines -> configConsumer.accept(String.join("\n", lines)));
       return this;
@@ -577,10 +698,22 @@
     }
 
     @Override
+    public void compile() throws Exception {
+      builder.compile();
+    }
+
+    @Override
     public SingleTestRunResult<?> run(Class<?> mainClass) throws Exception {
       configConsumers.forEach(fn -> fn.accept(builder.getConfig()));
       extractedRulesConsumers.forEach(fn -> fn.accept(extractedRules));
       return builder.run(parameters().getRuntime(), mainClass);
     }
+
+    @Override
+    public SingleTestRunResult<?> run(String mainClass) throws Exception {
+      configConsumers.forEach(fn -> fn.accept(builder.getConfig()));
+      extractedRulesConsumers.forEach(fn -> fn.accept(extractedRules));
+      return builder.run(parameters().getRuntime(), mainClass);
+    }
   }
 }
diff --git a/src/test/java/com/android/tools/r8/keepanno/androidx/KeepAnnoTestExtractedRulesBase.java b/src/test/java/com/android/tools/r8/keepanno/androidx/KeepAnnoTestExtractedRulesBase.java
new file mode 100644
index 0000000..c652577
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/keepanno/androidx/KeepAnnoTestExtractedRulesBase.java
@@ -0,0 +1,201 @@
+// Copyright (c) 2025, 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.androidx;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assume.assumeFalse;
+
+import com.android.tools.r8.KotlinCompileMemoizer;
+import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.KotlinCompilerTool.KotlinCompilerVersion;
+import com.android.tools.r8.KotlinTestParameters;
+import com.android.tools.r8.R8TestBuilder;
+import com.android.tools.r8.Version;
+import com.android.tools.r8.keepanno.KeepAnnoParameters;
+import com.android.tools.r8.keepanno.KeepAnnoTestBase;
+import com.android.tools.r8.utils.SemanticVersion;
+import com.google.common.collect.ImmutableList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+import org.junit.runners.Parameterized.Parameter;
+
+public abstract class KeepAnnoTestExtractedRulesBase extends KeepAnnoTestBase {
+  @Parameter(0)
+  public KeepAnnoParameters parameters;
+
+  @Parameter(1)
+  public KotlinTestParameters kotlinParameters;
+
+  protected static KotlinCompileMemoizer compilationResults;
+  protected static KotlinCompileMemoizer compilationResultsClassName;
+
+  protected abstract String getExpectedOutput();
+
+  protected static List<String> trimRules(List<String> rules) {
+    List<String> trimmedRules =
+        rules.stream()
+            .flatMap(s -> Arrays.stream(s.split("\n")))
+            .filter(rule -> !rule.startsWith("#"))
+            .collect(Collectors.toList());
+    return trimmedRules;
+  }
+
+  public static class ExpectedRule {
+    private final String conditionClass;
+    private final String conditionMembers;
+    private final String consequentClass;
+    private final String consequentMembers;
+
+    private ExpectedRule(Builder builder) {
+      this.conditionClass = builder.conditionClass;
+      this.conditionMembers = builder.conditionMembers;
+      this.consequentClass = builder.consequentClass;
+      this.consequentMembers = builder.consequentMembers;
+    }
+
+    public String getRule(boolean r8) {
+      return "-if class "
+          + conditionClass
+          + " "
+          + conditionMembers
+          + " -keepclasseswithmembers"
+          + (r8 ? ",allowaccessmodification" : "")
+          + " class "
+          + consequentClass
+          + " "
+          + consequentMembers;
+    }
+
+    public static Builder builder() {
+      return new Builder();
+    }
+
+    public static class Builder {
+      private String conditionClass;
+      private String conditionMembers;
+      private String consequentClass;
+      private String consequentMembers;
+
+      private Builder() {}
+
+      public Builder setConditionClass(Class<?> conditionClass) {
+        this.conditionClass = conditionClass.getTypeName();
+        return this;
+      }
+
+      public Builder setConditionClass(String conditionClass) {
+        this.conditionClass = conditionClass;
+        return this;
+      }
+
+      public Builder setConditionMembers(String conditionMembers) {
+        this.conditionMembers = conditionMembers;
+        return this;
+      }
+
+      public Builder setConsequentClass(Class<?> consequentClass) {
+        this.consequentClass = consequentClass.getTypeName();
+        return this;
+      }
+
+      public Builder setConsequentClass(String consequentClass) {
+        this.consequentClass = consequentClass;
+        return this;
+      }
+
+      public Builder setConsequentMembers(String consequentMembers) {
+        this.consequentMembers = consequentMembers;
+        return this;
+      }
+
+      public ExpectedRule build() {
+        return new ExpectedRule(this);
+      }
+    }
+  }
+
+  protected void runTestExtractedRulesJava(List<Class<?>> testClasses, ExpectedRule expectedRule)
+      throws Exception {
+    Class<?> mainClass = testClasses.iterator().next();
+    testForKeepAnnoAndroidX(parameters)
+        .applyIfPG(
+            b -> {
+              KotlinCompiler kotlinc =
+                  new KotlinCompiler(KotlinCompilerVersion.MAX_SUPPORTED_VERSION);
+              b.addLibraryFiles(kotlinc.getKotlinStdlibJar(), kotlinc.getKotlinAnnotationJar());
+            })
+        .addProgramClasses(testClasses)
+        .addKeepMainRule(mainClass)
+        .setExcludedOuterClass(getClass())
+        .inspectExtractedRules(
+            rules -> {
+              if (parameters.isExtractRules()) {
+                assertEquals(
+                    ImmutableList.of(expectedRule.getRule(parameters.isR8())), trimRules(rules));
+              }
+            })
+        .run(mainClass)
+        .assertSuccessWithOutput(getExpectedOutput());
+  }
+
+  protected void runTestExtractedRulesKotlin(
+      KotlinCompileMemoizer compilation, String mainClass, ExpectedRule expectedRule)
+      throws Exception {
+    // TODO(b/392865072): Legacy R8 fails with AssertionError: Synthetic class kinds should agree.
+    assumeFalse(parameters.isLegacyR8());
+    // TODO(b/392865072): Reference fails with AssertionError: Built-in class kotlin.Any is not
+    // found (in kotlin.reflect code).
+    assumeFalse(parameters.isReference());
+    // TODO(b/392865072): Proguard 7.4.1 fails with "Encountered corrupt @kotlin/Metadata for class
+    // <binary name> (version 2.1.0)".
+    assumeFalse(parameters.isPG());
+    testForKeepAnnoAndroidX(parameters)
+        .addProgramFiles(ImmutableList.of(compilation.getForConfiguration(kotlinParameters)))
+        .addProgramFilesWithoutAnnotations(
+            ImmutableList.of(
+                kotlinParameters.getCompiler().getKotlinStdlibJar(),
+                kotlinParameters.getCompiler().getKotlinReflectJar(),
+                kotlinParameters.getCompiler().getKotlinAnnotationJar()))
+        .applyIfR8(
+            b ->
+                b.applyIf(
+                    b instanceof R8TestBuilder && Version.isMainVersion(),
+                    bb ->
+                        ((R8TestBuilder<?, ?, ?>) bb)
+                            .setFakeCompilerVersion(SemanticVersion.max())
+                            .allowDiagnosticMessages()))
+        .addKeepRules("-keepattributes RuntimeVisibleAnnotations")
+        .addKeepRules("-keep class kotlin.Metadata { *; }")
+        .addKeepRules(
+            "-keep class " + mainClass + " { public static void main(java.lang.String[]); }")
+        .applyIfR8OrR8Partial(
+            b ->
+                b.addOptionsModification(
+                    options -> {
+                      options.testing.allowedUnusedDontWarnPatterns.add(
+                          "kotlin.reflect.jvm.internal.**");
+                      options.testing.allowedUnusedDontWarnPatterns.add("java.lang.ClassValue");
+                    }),
+            b ->
+                b.addR8PartialR8OptionsModification(
+                    options -> {
+                      options.testing.allowedUnusedDontWarnPatterns.add(
+                          "kotlin.reflect.jvm.internal.**");
+                      options.testing.allowedUnusedDontWarnPatterns.add("java.lang.ClassValue");
+                    }))
+        .inspectExtractedRules(
+            rules -> {
+              if (parameters.isExtractRules()) {
+                assertEquals(
+                    ImmutableList.of(expectedRule.getRule(parameters.isR8())), trimRules(rules));
+              }
+            })
+        .run(mainClass)
+        .applyIf(
+            parameters.isExtractRules(),
+            b -> b.assertSuccessWithOutput(getExpectedOutput()),
+            b -> b.assertSuccessWithOutput(""));
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/keepanno/androidx/KeepUsesReflectionForInstantiationNoArgsConstructorTest.java b/src/test/java/com/android/tools/r8/keepanno/androidx/KeepUsesReflectionForInstantiationNoArgsConstructorTest.java
new file mode 100644
index 0000000..dfa7b78
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/keepanno/androidx/KeepUsesReflectionForInstantiationNoArgsConstructorTest.java
@@ -0,0 +1,166 @@
+// Copyright (c) 2025, 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.androidx;
+
+import static com.android.tools.r8.ToolHelper.getFilesInTestFolderRelativeToClass;
+import static org.junit.Assert.assertEquals;
+
+import androidx.annotation.keep.UsesReflectionToConstruct;
+import com.android.tools.r8.utils.StringUtils;
+import com.google.common.collect.ImmutableList;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.Collection;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class KeepUsesReflectionForInstantiationNoArgsConstructorTest
+    extends KeepAnnoTestExtractedRulesBase {
+
+  // String constant to be references from annotations.
+  static final String classNameOfKeptClass =
+      "com.android.tools.r8.keepanno.androidx.KeepUsesReflectionForInstantiationNoArgsConstructorTest$KeptClass";
+
+  @Parameterized.Parameters(name = "{0}, {1}")
+  public static Collection<Object[]> data() {
+    assertEquals(KeptClass.class.getTypeName(), classNameOfKeptClass);
+    return buildParameters(
+        createParameters(getTestParameters().withDefaultRuntimes().withMaximumApiLevel().build()),
+        getKotlinTestParameters().withLatestCompiler().build());
+  }
+
+  protected String getExpectedOutput() {
+    return StringUtils.lines("<init>()");
+  }
+
+  private static Collection<Path> getKotlinSources() {
+    try {
+      return getFilesInTestFolderRelativeToClass(
+          KeepUsesReflectionForInstantiationNoArgsConstructorTest.class,
+          "kt",
+          "OnlyNoArgsConstructor.kt",
+          "KeptClass.kt");
+    } catch (IOException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  private static Collection<Path> getKotlinSourcesClassName() {
+    try {
+      return getFilesInTestFolderRelativeToClass(
+          KeepUsesReflectionForInstantiationNoArgsConstructorTest.class,
+          "kt",
+          "OnlyNoArgsConstructorClassName.kt",
+          "KeptClass.kt");
+    } catch (IOException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  @BeforeClass
+  public static void beforeClass() throws Exception {
+    compilationResults = getCompileMemoizerWithKeepAnnoLib(getKotlinSources());
+    compilationResultsClassName = getCompileMemoizerWithKeepAnnoLib(getKotlinSourcesClassName());
+  }
+
+  @Test
+  public void testOnlyNoArgsConstructor() throws Exception {
+    runTestExtractedRulesJava(
+        ImmutableList.of(OnlyNoArgsConstructor.class, KeptClass.class),
+        ExpectedRule.builder()
+            .setConditionClass(OnlyNoArgsConstructor.class)
+            .setConditionMembers("{ void foo(java.lang.Class); }")
+            .setConsequentClass(KeptClass.class)
+            .setConsequentMembers("{ void <init>(); }")
+            .build());
+  }
+
+  static class OnlyNoArgsConstructor {
+
+    @UsesReflectionToConstruct(
+        className = classNameOfKeptClass,
+        params = {})
+    public void foo(Class<KeptClass> clazz) throws Exception {
+      if (clazz != null) {
+        clazz.getDeclaredConstructor().newInstance();
+      }
+    }
+
+    public static void main(String[] args) throws Exception {
+      new OnlyNoArgsConstructor().foo(System.nanoTime() > 0 ? KeptClass.class : null);
+    }
+  }
+
+  @Test
+  public void testOnlyNoArgsConstructorClassNames() throws Exception {
+    runTestExtractedRulesJava(
+        ImmutableList.of(OnlyNoArgsConstructorClassNames.class, KeptClass.class),
+        ExpectedRule.builder()
+            .setConditionClass(OnlyNoArgsConstructorClassNames.class)
+            .setConditionMembers("{ void foo(java.lang.Class); }")
+            .setConsequentClass(KeptClass.class)
+            .setConsequentMembers("{ void <init>(); }")
+            .build());
+  }
+
+  static class OnlyNoArgsConstructorClassNames {
+
+    @UsesReflectionToConstruct(
+        className = classNameOfKeptClass,
+        params = {})
+    public void foo(Class<KeptClass> clazz) throws Exception {
+      if (clazz != null) {
+        clazz.getDeclaredConstructor().newInstance();
+      }
+    }
+
+    public static void main(String[] args) throws Exception {
+      new OnlyNoArgsConstructorClassNames().foo(System.nanoTime() > 0 ? KeptClass.class : null);
+    }
+  }
+
+  @Test
+  public void testOnlyNoArgsConstructorKotlin() throws Exception {
+    runTestExtractedRulesKotlin(
+        compilationResults,
+        "com.android.tools.r8.keepanno.androidx.kt.OnlyNoArgsConstructorKt",
+        ExpectedRule.builder()
+            .setConditionClass("com.android.tools.r8.keepanno.androidx.kt.OnlyNoArgsConstructor")
+            .setConditionMembers("{ void foo(kotlin.reflect.KClass); }")
+            .setConsequentClass("com.android.tools.r8.keepanno.androidx.kt.KeptClass")
+            .setConsequentMembers("{ void <init>(); }")
+            .build());
+  }
+
+  @Test
+  public void testOnlyNoArgsConstructorKotlinClassName() throws Exception {
+    runTestExtractedRulesKotlin(
+        compilationResultsClassName,
+        "com.android.tools.r8.keepanno.androidx.kt.OnlyNoArgsConstructorClassNameKt",
+        ExpectedRule.builder()
+            .setConditionClass(
+                "com.android.tools.r8.keepanno.androidx.kt.OnlyNoArgsConstructorClassName")
+            .setConditionMembers("{ void foo(kotlin.reflect.KClass); }")
+            .setConsequentClass("com.android.tools.r8.keepanno.androidx.kt.KeptClass")
+            .setConsequentMembers("{ void <init>(); }")
+            .build());
+  }
+
+  static class KeptClass {
+    KeptClass() {
+      System.out.println("<init>()");
+    }
+
+    KeptClass(int i) {
+      System.out.println("<init>(int)");
+    }
+
+    KeptClass(long j) {
+      System.out.println("<init>(long)");
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/keepanno/androidx/kt/KeptClass.kt b/src/test/java/com/android/tools/r8/keepanno/androidx/kt/KeptClass.kt
new file mode 100644
index 0000000..fb55316
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/keepanno/androidx/kt/KeptClass.kt
@@ -0,0 +1,15 @@
+package com.android.tools.r8.keepanno.androidx.kt
+
+class KeptClass() {
+  init {
+    println("<init>()")
+  }
+
+  constructor(i: Int) : this() {
+    println("<init>(Int)")
+  }
+
+  constructor(l: Long) : this() {
+    println("<init>(Long)")
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/keepanno/androidx/kt/OnlyNoArgsConstructor.kt b/src/test/java/com/android/tools/r8/keepanno/androidx/kt/OnlyNoArgsConstructor.kt
new file mode 100644
index 0000000..4dd03cc
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/keepanno/androidx/kt/OnlyNoArgsConstructor.kt
@@ -0,0 +1,16 @@
+package com.android.tools.r8.keepanno.androidx.kt
+
+import androidx.annotation.keep.UsesReflectionToConstruct
+import kotlin.reflect.KClass
+import kotlin.reflect.full.primaryConstructor
+
+class OnlyNoArgsConstructor {
+  @UsesReflectionToConstruct(classConstant = KeptClass::class, params = [])
+  fun foo(clazz: KClass<KeptClass>?) {
+    clazz?.primaryConstructor?.call()
+  }
+}
+
+fun main() {
+  OnlyNoArgsConstructor().foo(if (System.nanoTime() > 0) KeptClass::class else null)
+}
diff --git a/src/test/java/com/android/tools/r8/keepanno/androidx/kt/OnlyNoArgsConstructorClassName.kt b/src/test/java/com/android/tools/r8/keepanno/androidx/kt/OnlyNoArgsConstructorClassName.kt
new file mode 100644
index 0000000..8652223
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/keepanno/androidx/kt/OnlyNoArgsConstructorClassName.kt
@@ -0,0 +1,19 @@
+package com.android.tools.r8.keepanno.androidx.kt
+
+import androidx.annotation.keep.UsesReflectionToConstruct
+import kotlin.reflect.KClass
+import kotlin.reflect.full.primaryConstructor
+
+class OnlyNoArgsConstructorClassName {
+  @UsesReflectionToConstruct(
+    className = "com.android.tools.r8.keepanno.androidx.kt.KeptClass",
+    params = [],
+  )
+  fun foo(clazz: KClass<KeptClass>?) {
+    clazz?.primaryConstructor?.call()
+  }
+}
+
+fun main() {
+  OnlyNoArgsConstructorClassName().foo(if (System.nanoTime() > 0) KeptClass::class else null)
+}
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/KotlinMetadataTestBase.java b/src/test/java/com/android/tools/r8/kotlin/metadata/KotlinMetadataTestBase.java
index c7a31d0..366f7b2 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/KotlinMetadataTestBase.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/KotlinMetadataTestBase.java
@@ -7,6 +7,8 @@
 import static com.android.tools.r8.utils.FunctionUtils.ignoreArgument;
 import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
 import static junit.framework.TestCase.assertNotNull;
+import static org.hamcrest.CoreMatchers.anyOf;
+import static org.hamcrest.CoreMatchers.containsString;
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
@@ -174,7 +176,9 @@
   public static void verifyExpectedWarningsFromKotlinReflectAndStdLib(
       TestCompileResult<?, ?> compileResult) {
     compileResult.assertAllWarningMessagesMatch(
-        equalTo("Resource 'META-INF/versions/9/module-info.class' already exists."));
+        anyOf(
+            equalTo("Resource 'META-INF/versions/9/module-info.class' already exists."),
+            containsString("-upto-")));
   }
 
   protected String unresolvedReferenceMessage(KotlinTestParameters param, String ref) {
diff --git a/src/test/testbase/java/com/android/tools/r8/ToolHelper.java b/src/test/testbase/java/com/android/tools/r8/ToolHelper.java
index a90871d..547024a 100644
--- a/src/test/testbase/java/com/android/tools/r8/ToolHelper.java
+++ b/src/test/testbase/java/com/android/tools/r8/ToolHelper.java
@@ -2712,12 +2712,16 @@
   }
 
   public static Collection<Path> getFilesInTestFolderRelativeToClass(
-      Class<?> clazz, String folderName, String endsWith) throws IOException {
+      Class<?> clazz, String folderName, String... endsWith) throws IOException {
     Path subFolder = getTestFolderForClass(clazz).resolve(folderName);
     assert Files.isDirectory(subFolder);
-    try (Stream<Path> walker = Files.walk(subFolder)) {
-      return walker.filter(path -> path.toString().endsWith(endsWith)).collect(Collectors.toList());
+    List<Path> result = new ArrayList<>();
+    for (String s : endsWith) {
+      try (Stream<Path> walker = Files.walk(subFolder)) {
+        walker.filter(path -> path.toString().endsWith(s)).forEach(result::add);
+      }
     }
+    return result;
   }
 
   /** This code only works if run with depot_tools on the path */
diff --git a/src/test/testbase/java/com/android/tools/r8/keepanno/KeepAnnoTestUtils.java b/src/test/testbase/java/com/android/tools/r8/keepanno/KeepAnnoTestUtils.java
index 53f0924..36968f6 100644
--- a/src/test/testbase/java/com/android/tools/r8/keepanno/KeepAnnoTestUtils.java
+++ b/src/test/testbase/java/com/android/tools/r8/keepanno/KeepAnnoTestUtils.java
@@ -5,6 +5,10 @@
 package com.android.tools.r8.keepanno;
 
 import static com.android.tools.r8.R8TestBuilder.KeepAnnotationLibrary.ANDROIDX;
+import static com.android.tools.r8.utils.FileUtils.isClassFile;
+import static com.android.tools.r8.utils.FileUtils.isJarFile;
+import static com.android.tools.r8.utils.FileUtils.isZipFile;
+import static com.android.tools.r8.utils.ZipUtils.isClassFile;
 import static org.junit.Assert.assertTrue;
 
 import com.android.tools.r8.ByteDataView;
@@ -18,6 +22,9 @@
 import com.android.tools.r8.keepanno.keeprules.KeepRuleExtractorOptions;
 import com.android.tools.r8.utils.FileUtils;
 import com.android.tools.r8.utils.ListUtils;
+import com.android.tools.r8.utils.ZipUtils;
+import com.google.common.collect.ImmutableList;
+import com.google.common.io.ByteStreams;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
@@ -53,7 +60,7 @@
         try (Stream<Path> paths = Files.list(annoDir)) {
           paths.forEach(
               p -> {
-                if (FileUtils.isClassFile(p)) {
+                if (isClassFile(p)) {
                   byte[] data = FileUtils.uncheckedReadAllBytes(p);
                   String fileName = p.getFileName().toString();
                   String className = fileName.substring(0, fileName.lastIndexOf('.'));
@@ -74,17 +81,31 @@
 
   public static List<String> extractRulesFromFiles(
       List<Path> inputFiles, KeepRuleExtractorOptions extractorOptions) {
-    return extractRulesFromBytes(
-        ListUtils.map(
-            inputFiles,
-            path -> {
-              try {
-                return Files.readAllBytes(path);
-              } catch (IOException e) {
-                throw new RuntimeException(e);
-              }
-            }),
-        extractorOptions);
+    List<String> result = new ArrayList<>();
+    for (Path inputFile : inputFiles) {
+      try {
+        if (isClassFile(inputFile)) {
+          result.addAll(
+              extractRulesFromBytes(
+                  ImmutableList.of(Files.readAllBytes(inputFile)), extractorOptions));
+        } else if (isJarFile(inputFile) || isZipFile(inputFile)) {
+          List<byte[]> classFilesFromArchive = new ArrayList<>();
+          ZipUtils.iter(
+              inputFile,
+              (entry, input) -> {
+                if (ZipUtils.isClassFile(entry.getName())) {
+                  classFilesFromArchive.add(ByteStreams.toByteArray(input));
+                }
+              });
+          result.addAll(extractRulesFromBytes(classFilesFromArchive, extractorOptions));
+        } else {
+          assert false : "Unsupported file format";
+        }
+      } catch (IOException e) {
+        throw new RuntimeException(e);
+      }
+    }
+    return result;
   }
 
   public static List<String> extractRules(