diff --git a/lint-checks/integration-tests/src/main/java/replacewith/MethodWithImportsJava.java b/lint-checks/integration-tests/src/main/java/replacewith/MethodWithImportsJava.java
new file mode 100644
index 0000000..973ad52
--- /dev/null
+++ b/lint-checks/integration-tests/src/main/java/replacewith/MethodWithImportsJava.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package replacewith;
+
+import androidx.annotation.ReplaceWith;
+
+/**
+ * Usage with implicit "this" receiver.
+ */
+@SuppressWarnings({"deprecation", "unused"})
+class MethodWithImportsJava {
+    @Deprecated
+    @ReplaceWith(expression = "newMethod(obj)", imports = "androidx.annotation.Deprecated")
+    void oldMethodSingleImport(Object obj) {}
+
+    @Deprecated
+    @ReplaceWith(expression = "newMethod(obj)", imports = {"androidx.annotation.Deprecated",
+            "androidx.annotation.NonNull"})
+    void oldMethodMultiImport(Object obj) {}
+
+    void newMethod(Object obj) {}
+
+    void usageSingleImport() {
+        oldMethodSingleImport(null);
+    }
+
+    void usageMultiImport() {
+        oldMethodMultiImport(null);
+    }
+}
diff --git a/lint-checks/integration-tests/src/main/java/replacewith/MethodWithImportsKotlin.kt b/lint-checks/integration-tests/src/main/java/replacewith/MethodWithImportsKotlin.kt
new file mode 100644
index 0000000..a8dccc3
--- /dev/null
+++ b/lint-checks/integration-tests/src/main/java/replacewith/MethodWithImportsKotlin.kt
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package replacewith
+
+import androidx.annotation.AnyThread
+
+/**
+ * Usage of replacement with imports.
+ */
+@Suppress("deprecation", "unused")
+internal class MethodWithImportsKotlin {
+    @AnyThread
+    fun usageSingleImport() {
+        ReplaceWithUsageJava.toStringWithImport("hello")
+    }
+
+    @AnyThread
+    fun usageMultiImport() {
+        ReplaceWithUsageJava.toStringWithImports("world")
+    }
+}
diff --git a/lint-checks/integration-tests/src/main/java/replacewith/MethodWithNoImportsJava.java b/lint-checks/integration-tests/src/main/java/replacewith/MethodWithNoImportsJava.java
new file mode 100644
index 0000000..fbba87e
--- /dev/null
+++ b/lint-checks/integration-tests/src/main/java/replacewith/MethodWithNoImportsJava.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package replacewith;
+
+/**
+ * Usage with implicit "this" receiver.
+ */
+@SuppressWarnings({"deprecation", "unused"})
+class MethodWithNoImportsJava {
+    @Deprecated
+    @androidx.annotation.ReplaceWith(expression = "newMethod(obj)",
+            imports = "androidx.annotation.Deprecated")
+    void oldMethodSingleImport(Object obj) {}
+
+    @Deprecated
+    @androidx.annotation.ReplaceWith(expression = "newMethod(obj)",
+            imports = {"androidx.annotation.Deprecated", "androidx.annotation.NonNull"})
+    void oldMethodMultiImport(Object obj) {}
+
+    void newMethod(Object obj) {}
+
+    void usageSingleImport() {
+        oldMethodSingleImport(null);
+    }
+
+    void usageMultiImport() {
+        oldMethodMultiImport(null);
+    }
+}
diff --git a/lint-checks/integration-tests/src/main/java/replacewith/MethodWithNoImportsKotlin.kt b/lint-checks/integration-tests/src/main/java/replacewith/MethodWithNoImportsKotlin.kt
new file mode 100644
index 0000000..5063755
--- /dev/null
+++ b/lint-checks/integration-tests/src/main/java/replacewith/MethodWithNoImportsKotlin.kt
@@ -0,0 +1,30 @@
+/*
+ * Copyright 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package replacewith
+
+/**
+ * Usage of replacement with imports.
+ */
+@Suppress("deprecation", "unused")
+internal class MethodWithNoImportsKotlin {
+    fun usageSingleImport() {
+        ReplaceWithUsageJava.toStringWithImport("hello")
+    }
+
+    fun usageMultiImport() {
+        ReplaceWithUsageJava.toStringWithImports("world")
+    }
+}
diff --git a/lint-checks/integration-tests/src/main/java/replacewith/MethodWithNoImportsOrPackage.java b/lint-checks/integration-tests/src/main/java/replacewith/MethodWithNoImportsOrPackage.java
new file mode 100644
index 0000000..5be7377
--- /dev/null
+++ b/lint-checks/integration-tests/src/main/java/replacewith/MethodWithNoImportsOrPackage.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Usage with implicit "this" receiver.
+ */
+@SuppressWarnings({"deprecation", "unused", "WrongPackageStatement", "DefaultPackage"})
+class MethodWithNoImportsOrPackage {
+    @Deprecated
+    @androidx.annotation.ReplaceWith(expression = "newMethod(obj)",
+            imports = "androidx.annotation.Deprecated")
+    void oldMethodSingleImport(Object obj) {}
+
+    @Deprecated
+    @androidx.annotation.ReplaceWith(expression = "newMethod(obj)",
+            imports = {"androidx.annotation.Deprecated", "androidx.annotation.NonNull"})
+    void oldMethodMultiImport(Object obj) {}
+
+    void newMethod(Object obj) {}
+
+    void usageSingleImport() {
+        oldMethodSingleImport(null);
+    }
+
+    void usageMultiImport() {
+        oldMethodMultiImport(null);
+    }
+}
diff --git a/lint-checks/integration-tests/src/main/java/replacewith/ReplaceWithUsageJava.java b/lint-checks/integration-tests/src/main/java/replacewith/ReplaceWithUsageJava.java
index 7afdee3..053663f 100644
--- a/lint-checks/integration-tests/src/main/java/replacewith/ReplaceWithUsageJava.java
+++ b/lint-checks/integration-tests/src/main/java/replacewith/ReplaceWithUsageJava.java
@@ -36,6 +36,31 @@
     }
 
     /**
+     * Calls the method on the object.
+     *
+     * @param obj The object on which to call the method.
+     * @deprecated Use {@link Object#toString()} directly.
+     */
+    @Deprecated
+    @ReplaceWith(expression = "obj.toString()", imports = "androidx.annotation.Deprecated")
+    public static void toStringWithImport(Object obj) {
+        // Stub.
+    }
+
+    /**
+     * Calls the method on the object.
+     *
+     * @param obj The object on which to call the method.
+     * @deprecated Use {@link Object#toString()} directly.
+     */
+    @Deprecated
+    @ReplaceWith(expression = "obj.toString()",
+            imports = {"androidx.annotation.Deprecated", "androidx.annotation.NonNull"})
+    public static void toStringWithImports(Object obj) {
+        // Stub.
+    }
+
+    /**
      * Returns a new object.
      */
     public static ReplaceWithUsageJava obtain(int param) {
diff --git a/lint-checks/src/main/java/androidx/build/lint/ReplaceWithDetector.kt b/lint-checks/src/main/java/androidx/build/lint/ReplaceWithDetector.kt
index 0d8d683..10df47d 100644
--- a/lint-checks/src/main/java/androidx/build/lint/ReplaceWithDetector.kt
+++ b/lint-checks/src/main/java/androidx/build/lint/ReplaceWithDetector.kt
@@ -32,14 +32,19 @@
 import com.android.tools.lint.detector.api.Scope
 import com.android.tools.lint.detector.api.Severity
 import com.android.tools.lint.detector.api.SourceCodeScanner
+import com.android.tools.lint.detector.api.isKotlin
 import com.intellij.psi.PsiField
+import com.intellij.psi.PsiJavaFile
 import com.intellij.psi.PsiMethod
 import com.intellij.psi.impl.source.tree.TreeElement
 import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.KtLiteralStringTemplateEntry
 import org.jetbrains.kotlin.psi.psiUtil.endOffset
+import org.jetbrains.uast.UAnnotation
 import org.jetbrains.uast.UCallExpression
 import org.jetbrains.uast.UElement
+import org.jetbrains.uast.ULiteralExpression
 import org.jetbrains.uast.UQualifiedReferenceExpression
 import org.jetbrains.uast.USimpleNameReferenceExpression
 import org.jetbrains.uast.java.JavaConstructorUCallExpression
@@ -72,16 +77,16 @@
                 var expression = annotation.findAttributeValue("expression") ?.let { expr ->
                     ConstantEvaluator.evaluate(context, expr)
                 } as? String ?: return
-
                 val includeReceiver = Regex("^\\w+\\.\\w+.*\$").matches(expression)
                 val includeArguments = Regex("^.*\\w+\\(.*\\)$").matches(expression)
+                val imports = annotation.getAttributeValueVarargLiteral("imports")
 
                 if (referenced is PsiMethod && usage is UCallExpression) {
                     // Per Kotlin documentation for ReplaceWith: For function calls, the replacement
                     // expression may contain argument names of the deprecated function, which will
                     // be substituted with actual parameters used in the call being updated.
                     val argsToParams = referenced.parameters.mapIndexed { index, param ->
-                        param.name to usage.getArgumentForParameter(index)?.sourcePsi?.text
+                        param.name to usage.getArgumentForParameter(index)?.asSourceString()
                     }.associate { it }
 
                     // Tokenize the replacement expression using a regex, replacing as we go. This
@@ -126,7 +131,7 @@
                     }
                 }
 
-                reportLintFix(context, usage, location, expression)
+                reportLintFix(context, usage, location, expression, imports)
             }
         }
     }
@@ -136,13 +141,71 @@
         usage: UElement,
         location: Location,
         expression: String,
+        imports: List<String>,
     ) {
         context.report(ISSUE, usage, location, "Replacement available",
-            createLintFix(location, expression))
+            createLintFix(context, location, expression, imports))
     }
 
-    private fun createLintFix(location: Location, expression: String): LintFix =
-        fix().replace().range(location).name("Replace with `$expression`").with(expression).build()
+    private fun createLintFix(
+        context: JavaContext,
+        location: Location,
+        expression: String,
+        imports: List<String>
+    ): LintFix {
+        val lintFixBuilder = fix().composite()
+        lintFixBuilder.add(
+            fix()
+                .replace()
+                .range(location)
+                .name("Replace with `$expression`")
+                .with(expression)
+                .build()
+        )
+        if (imports.isNotEmpty()) {
+            lintFixBuilder.add(fix().import(context, add = imports).build())
+        }
+        return lintFixBuilder.build()
+    }
+
+    /**
+     * Add imports.
+     *
+     * @return a string replace builder
+     */
+    fun LintFix.Builder.import(
+        context: JavaContext,
+        add: List<String>
+    ): LintFix.ReplaceStringBuilder {
+        val isKotlin = isKotlin(context.uastFile!!.lang)
+        val lastImport = context.uastFile?.imports?.lastOrNull()
+        val packageElem = when (val psiFile = context.psiFile) {
+            is PsiJavaFile -> psiFile.packageStatement
+            is KtFile -> psiFile.packageDirective?.psiOrParent
+            else -> null
+        }
+
+        // Build the imports block. Leave any ordering or formatting up to the client.
+        val prependImports = when {
+            lastImport != null -> "\n"
+            packageElem != null -> "\n\n"
+            else -> ""
+        }
+        val appendImports = when {
+            lastImport != null -> ""
+            packageElem != null -> ""
+            else -> "\n"
+        }
+        val formattedImports = add.joinToString("\n") { "import " + if (isKotlin) it else "$it;" }
+        val importsText = prependImports + formattedImports + appendImports
+
+        // Append after any existing imports, after the package declaration, or at the beginning of
+        // the file if there are no imports and no package declaration.
+        val appendLocation = (lastImport ?: packageElem) ?.let { context.getLocation(it) }
+            ?: Location.create(context.file, context.getContents(), 0, 0)
+        val replaceBuilder = replace().range(appendLocation).end().with(importsText)
+        return replaceBuilder.autoFix()
+    }
 
     companion object {
         private val IMPLEMENTATION = Implementation(
@@ -230,3 +293,16 @@
 
     return getLocation(call)
 }
+
+/**
+ * @return the value of the specified vararg attribute as a list of String literals, or an empty
+ * list if not specified
+ */
+fun UAnnotation.getAttributeValueVarargLiteral(name: String): List<String> =
+    when (val attributeValue = findDeclaredAttributeValue(name)) {
+        is ULiteralExpression -> listOf(attributeValue.value.toString())
+        is UCallExpression -> attributeValue.valueArguments.mapNotNull { argument ->
+            (argument as? ULiteralExpression)?.value?.toString()
+        }
+        else -> emptyList()
+    }
diff --git a/lint-checks/src/test/java/androidx/build/lint/replacewith/ReplaceWithDetectorImportsTest.kt b/lint-checks/src/test/java/androidx/build/lint/replacewith/ReplaceWithDetectorImportsTest.kt
new file mode 100644
index 0000000..6788668
--- /dev/null
+++ b/lint-checks/src/test/java/androidx/build/lint/replacewith/ReplaceWithDetectorImportsTest.kt
@@ -0,0 +1,216 @@
+/*
+ * Copyright 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.build.lint.replacewith
+
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+
+@RunWith(JUnit4::class)
+class ReplaceWithDetectorImportsTest {
+
+    @Test
+    fun methodWithImportsJava() {
+        val input = arrayOf(
+            javaSample("replacewith.MethodWithImportsJava")
+        )
+
+        /* ktlint-disable max-line-length */
+        val expected = """
+src/replacewith/MethodWithImportsJava.java:38: Information: Replacement available [ReplaceWith]
+        oldMethodSingleImport(null);
+        ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+src/replacewith/MethodWithImportsJava.java:42: Information: Replacement available [ReplaceWith]
+        oldMethodMultiImport(null);
+        ~~~~~~~~~~~~~~~~~~~~~~~~~~
+0 errors, 0 warnings
+        """.trimIndent()
+
+        val expectedFixDiffs = """
+Fix for src/replacewith/MethodWithImportsJava.java line 38: Replace with `newMethod(null)`:
+@@ -20 +20
++ import androidx.annotation.Deprecated;
+@@ -38 +39
+-         oldMethodSingleImport(null);
++         newMethod(null);
+Fix for src/replacewith/MethodWithImportsJava.java line 42: Replace with `newMethod(null)`:
+@@ -20 +20
++ import androidx.annotation.Deprecated;
++ import androidx.annotation.NonNull;
+@@ -42 +44
+-         oldMethodMultiImport(null);
++         newMethod(null);
+        """.trimIndent()
+        /* ktlint-enable max-line-length */
+
+        check(*input).expect(expected).expectFixDiffs(expectedFixDiffs)
+    }
+
+    @Test
+    fun methodWithImportsKotlin() {
+        val input = arrayOf(
+            ktSample("replacewith.MethodWithImportsKotlin"),
+            javaSample("replacewith.ReplaceWithUsageJava")
+        )
+
+        /* ktlint-disable max-line-length */
+        val expected = """
+src/replacewith/MethodWithImportsKotlin.kt:27: Information: Replacement available [ReplaceWith]
+        ReplaceWithUsageJava.toStringWithImport("hello")
+        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+src/replacewith/MethodWithImportsKotlin.kt:32: Information: Replacement available [ReplaceWith]
+        ReplaceWithUsageJava.toStringWithImports("world")
+        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+0 errors, 0 warnings
+        """.trimIndent()
+
+        val expectedFixDiffs = """
+Fix for src/replacewith/MethodWithImportsKotlin.kt line 27: Replace with `"hello".toString()`:
+@@ -19 +19
++ import androidx.annotation.Deprecated
+@@ -27 +28
+-         ReplaceWithUsageJava.toStringWithImport("hello")
++         "hello".toString()
+Fix for src/replacewith/MethodWithImportsKotlin.kt line 32: Replace with `"world".toString()`:
+@@ -19 +19
++ import androidx.annotation.Deprecated
++ import androidx.annotation.NonNull
+@@ -32 +34
+-         ReplaceWithUsageJava.toStringWithImports("world")
++         "world".toString()
+        """.trimIndent()
+        /* ktlint-enable max-line-length */
+
+        check(*input).expect(expected).expectFixDiffs(expectedFixDiffs)
+    }
+
+    @Test
+    fun methodWithNoImportsJava() {
+        val input = arrayOf(
+            javaSample("replacewith.MethodWithNoImportsJava")
+        )
+
+        /* ktlint-disable max-line-length */
+        val expected = """
+src/replacewith/MethodWithNoImportsJava.java:37: Information: Replacement available [ReplaceWith]
+        oldMethodSingleImport(null);
+        ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+src/replacewith/MethodWithNoImportsJava.java:41: Information: Replacement available [ReplaceWith]
+        oldMethodMultiImport(null);
+        ~~~~~~~~~~~~~~~~~~~~~~~~~~
+0 errors, 0 warnings
+        """.trimIndent()
+
+        val expectedFixDiffs = """
+Fix for src/replacewith/MethodWithNoImportsJava.java line 37: Replace with `newMethod(null)`:
+@@ -19 +19
++ import androidx.annotation.Deprecated;
++
+@@ -37 +39
+-         oldMethodSingleImport(null);
++         newMethod(null);
+Fix for src/replacewith/MethodWithNoImportsJava.java line 41: Replace with `newMethod(null)`:
+@@ -19 +19
++ import androidx.annotation.Deprecated;
++ import androidx.annotation.NonNull;
++
+@@ -41 +44
+-         oldMethodMultiImport(null);
++         newMethod(null);
+        """.trimIndent()
+        /* ktlint-enable max-line-length */
+
+        check(*input).expect(expected).expectFixDiffs(expectedFixDiffs)
+    }
+
+    @Test
+    fun methodWithNoImportsKotlin() {
+        val input = arrayOf(
+            ktSample("replacewith.MethodWithNoImportsKotlin"),
+            javaSample("replacewith.ReplaceWithUsageJava")
+        )
+
+        /* ktlint-disable max-line-length */
+        val expected = """
+src/replacewith/MethodWithNoImportsKotlin.kt:24: Information: Replacement available [ReplaceWith]
+        ReplaceWithUsageJava.toStringWithImport("hello")
+        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+src/replacewith/MethodWithNoImportsKotlin.kt:28: Information: Replacement available [ReplaceWith]
+        ReplaceWithUsageJava.toStringWithImports("world")
+        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+0 errors, 0 warnings
+        """.trimIndent()
+
+        val expectedFixDiffs = """
+Fix for src/replacewith/MethodWithNoImportsKotlin.kt line 24: Replace with `"hello".toString()`:
+@@ -18 +18
++ import androidx.annotation.Deprecated
++
+@@ -24 +26
+-         ReplaceWithUsageJava.toStringWithImport("hello")
++         "hello".toString()
+Fix for src/replacewith/MethodWithNoImportsKotlin.kt line 28: Replace with `"world".toString()`:
+@@ -18 +18
++ import androidx.annotation.Deprecated
++ import androidx.annotation.NonNull
++
+@@ -28 +31
+-         ReplaceWithUsageJava.toStringWithImports("world")
++         "world".toString()
+        """.trimIndent()
+        /* ktlint-enable max-line-length */
+
+        check(*input).expect(expected).expectFixDiffs(expectedFixDiffs)
+    }
+
+    @Test
+    fun methodWithNoImportsOrPackage() {
+        val input = arrayOf(
+            javaSample("replacewith.MethodWithNoImportsOrPackage")
+        )
+
+        /* ktlint-disable max-line-length */
+        val expected = """
+src/MethodWithNoImportsOrPackage.java:35: Information: Replacement available [ReplaceWith]
+        oldMethodSingleImport(null);
+        ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+src/MethodWithNoImportsOrPackage.java:39: Information: Replacement available [ReplaceWith]
+        oldMethodMultiImport(null);
+        ~~~~~~~~~~~~~~~~~~~~~~~~~~
+0 errors, 0 warnings
+        """.trimIndent()
+
+        val expectedFixDiffs = """
+Fix for src/MethodWithNoImportsOrPackage.java line 35: Replace with `newMethod(null)`:
+@@ -1 +1
++ import androidx.annotation.Deprecated;
+@@ -35 +36
+-         oldMethodSingleImport(null);
++         newMethod(null);
+Fix for src/MethodWithNoImportsOrPackage.java line 39: Replace with `newMethod(null)`:
+@@ -1 +1
++ import androidx.annotation.Deprecated;
++ import androidx.annotation.NonNull;
+@@ -39 +41
+-         oldMethodMultiImport(null);
++         newMethod(null);
+        """.trimIndent()
+        /* ktlint-enable max-line-length */
+
+        check(*input).expect(expected).expectFixDiffs(expectedFixDiffs)
+    }
+}
diff --git a/lint-checks/src/test/java/androidx/build/lint/replacewith/TestUtils.kt b/lint-checks/src/test/java/androidx/build/lint/replacewith/TestUtils.kt
index 15dcffb..ff498bb 100644
--- a/lint-checks/src/test/java/androidx/build/lint/replacewith/TestUtils.kt
+++ b/lint-checks/src/test/java/androidx/build/lint/replacewith/TestUtils.kt
@@ -26,6 +26,7 @@
     return TestLintTask.lint()
         .files(
             ANDROIDX_REPLACE_WITH_KT,
+            ANDROIDX_ANY_THREAD_KT,
             *testFiles
         )
         .issues(ReplaceWithDetector.ISSUE)
@@ -55,7 +56,7 @@
 }
 
 /**
- * [TestFile] containing ReplaceWith.kt from the ReplaceWith annotation library.
+ * [TestFile] containing ReplaceWith.kt from the Annotation library.
  *
  * This is a workaround for IntelliJ failing to recognize source files if they are also
  * included as resources.
@@ -87,3 +88,25 @@
             )
             """.trimIndent()
 )
+
+/**
+ * [TestFile] containing AnyThread.kt from the Annotation library.
+ */
+val ANDROIDX_ANY_THREAD_KT: TestFile = TestFiles.kotlin(
+    """
+            package androidx.annotation
+            
+            @MustBeDocumented
+            @Retention(AnnotationRetention.BINARY)
+            @Target(
+                AnnotationTarget.FUNCTION,
+                AnnotationTarget.PROPERTY_GETTER,
+                AnnotationTarget.PROPERTY_SETTER,
+                AnnotationTarget.CONSTRUCTOR,
+                AnnotationTarget.ANNOTATION_CLASS,
+                AnnotationTarget.CLASS,
+                AnnotationTarget.VALUE_PARAMETER
+            )
+            annotation class AnyThread
+            """.trimIndent()
+)