Update kotlin compile testing to 0.3.1

compiler-utils/src/testFixtures/java/com/squareup/anvil/compiler/internal/testing/AnvilCompilation.kt

@@ -5,8 +5,8 @@ import com.squareup.anvil.annotations.ExperimentalAnvilApi
 import com.squareup.anvil.compiler.AnvilCommandLineProcessor
 import com.squareup.anvil.compiler.AnvilComponentRegistrar
 import com.squareup.anvil.compiler.api.CodeGenerator
+import com.tschuchort.compiletesting.JvmCompilationResult
 import com.tschuchort.compiletesting.KotlinCompilation
-import com.tschuchort.compiletesting.KotlinCompilation.Result
 import com.tschuchort.compiletesting.PluginOption
 import com.tschuchort.compiletesting.SourceFile
 import com.tschuchort.compiletesting.addPreviousResultToClasspath
@@ -112,7 +112,7 @@ public class AnvilCompilation internal constructor(
     }
   }
 
-  public fun addPreviousCompilationResult(result: Result) = apply {
+  public fun addPreviousCompilationResult(result: JvmCompilationResult) = apply {
     checkNotCompiled()
     kotlinCompilation.addPreviousResultToClasspath(result)
   }
@@ -156,8 +156,8 @@ public class AnvilCompilation internal constructor(
    */
   public fun compile(
     @Language("kotlin") vararg sources: String,
-    block: Result.() -> Unit = {}
-  ): Result {
+    block: JvmCompilationResult.() -> Unit = {}
+  ): JvmCompilationResult {
     checkNotCompiled()
     if (!anvilConfigured) {
       // Configure with default behaviors
@@ -201,12 +201,12 @@ public fun compileAnvil(
   messageOutputStream: OutputStream = System.out,
   workingDir: File? = null,
   enableExperimentalAnvilApis: Boolean = true,
-  previousCompilationResult: Result? = null,
+  previousCompilationResult: JvmCompilationResult? = null,
   codeGenerators: List<CodeGenerator> = emptyList(),
   moduleName: String? = null,
   jvmTarget: JvmTarget? = null,
-  block: Result.() -> Unit = { },
-): Result {
+  block: JvmCompilationResult.() -> Unit = { },
+): JvmCompilationResult {
   return AnvilCompilation()
     .apply {
       kotlinCompilation.apply {

compiler/src/test/java/com/squareup/anvil/compiler/TestUtils.kt

@@ -9,22 +9,22 @@ import com.squareup.anvil.compiler.internal.testing.compileAnvil
 import com.squareup.anvil.compiler.internal.testing.generatedClassesString
 import com.squareup.anvil.compiler.internal.testing.packageName
 import com.squareup.anvil.compiler.internal.testing.use
+import com.tschuchort.compiletesting.JvmCompilationResult
 import com.tschuchort.compiletesting.KotlinCompilation.ExitCode
 import com.tschuchort.compiletesting.KotlinCompilation.ExitCode.COMPILATION_ERROR
 import com.tschuchort.compiletesting.KotlinCompilation.ExitCode.INTERNAL_ERROR
-import com.tschuchort.compiletesting.KotlinCompilation.Result
 import org.intellij.lang.annotations.Language
 import org.junit.Assume.assumeTrue
 import kotlin.reflect.KClass
 
 internal fun compile(
   @Language("kotlin") vararg sources: String,
-  previousCompilationResult: Result? = null,
+  previousCompilationResult: JvmCompilationResult? = null,
   enableDaggerAnnotationProcessor: Boolean = false,
   codeGenerators: List<CodeGenerator> = emptyList(),
   allWarningsAsErrors: Boolean = WARNINGS_AS_ERRORS,
-  block: Result.() -> Unit = { }
-): Result = compileAnvil(
+  block: JvmCompilationResult.() -> Unit = { }
+): JvmCompilationResult = compileAnvil(
   sources = sources,
   allWarningsAsErrors = allWarningsAsErrors,
   previousCompilationResult = previousCompilationResult,
@@ -33,62 +33,62 @@ internal fun compile(
   block = block
 )
 
-internal val Result.contributingInterface: Class<*>
+internal val JvmCompilationResult.contributingInterface: Class<*>
   get() = classLoader.loadClass("com.squareup.test.ContributingInterface")
 
-internal val Result.secondContributingInterface: Class<*>
+internal val JvmCompilationResult.secondContributingInterface: Class<*>
   get() = classLoader.loadClass("com.squareup.test.SecondContributingInterface")
 
-internal val Result.innerInterface: Class<*>
+internal val JvmCompilationResult.innerInterface: Class<*>
   get() = classLoader.loadClass("com.squareup.test.SomeClass\$InnerInterface")
 
-internal val Result.parentInterface: Class<*>
+internal val JvmCompilationResult.parentInterface: Class<*>
   get() = classLoader.loadClass("com.squareup.test.ParentInterface")
 
-internal val Result.parentInterface1: Class<*>
+internal val JvmCompilationResult.parentInterface1: Class<*>
   get() = classLoader.loadClass("com.squareup.test.ParentInterface1")
 
-internal val Result.parentInterface2: Class<*>
+internal val JvmCompilationResult.parentInterface2: Class<*>
   get() = classLoader.loadClass("com.squareup.test.ParentInterface2")
 
-internal val Result.componentInterface: Class<*>
+internal val JvmCompilationResult.componentInterface: Class<*>
   get() = classLoader.loadClass("com.squareup.test.ComponentInterface")
 
-internal val Result.subcomponentInterface: Class<*>
+internal val JvmCompilationResult.subcomponentInterface: Class<*>
   get() = classLoader.loadClass("com.squareup.test.SubcomponentInterface")
 
-internal val Result.daggerModule1: Class<*>
+internal val JvmCompilationResult.daggerModule1: Class<*>
   get() = classLoader.loadClass("com.squareup.test.DaggerModule1")
 
-internal val Result.assistedService: Class<*>
+internal val JvmCompilationResult.assistedService: Class<*>
   get() = classLoader.loadClass("com.squareup.test.AssistedService")
 
-internal val Result.assistedServiceFactory: Class<*>
+internal val JvmCompilationResult.assistedServiceFactory: Class<*>
   get() = classLoader.loadClass("com.squareup.test.AssistedServiceFactory")
 
-internal val Result.daggerModule2: Class<*>
+internal val JvmCompilationResult.daggerModule2: Class<*>
   get() = classLoader.loadClass("com.squareup.test.DaggerModule2")
 
-internal val Result.daggerModule3: Class<*>
+internal val JvmCompilationResult.daggerModule3: Class<*>
   get() = classLoader.loadClass("com.squareup.test.DaggerModule3")
 
-internal val Result.daggerModule4: Class<*>
+internal val JvmCompilationResult.daggerModule4: Class<*>
   get() = classLoader.loadClass("com.squareup.test.DaggerModule4")
 
-internal val Result.innerModule: Class<*>
+internal val JvmCompilationResult.innerModule: Class<*>
   get() = classLoader.loadClass("com.squareup.test.ComponentInterface\$InnerModule")
 
-internal val Result.nestedInjectClass: Class<*>
+internal val JvmCompilationResult.nestedInjectClass: Class<*>
   get() = classLoader.loadClass("com.squareup.test.ParentClass\$NestedInjectClass")
 
-internal val Result.injectClass: Class<*>
+internal val JvmCompilationResult.injectClass: Class<*>
   get() = classLoader.loadClass("com.squareup.test.InjectClass")
 
-internal val Result.anyQualifier: Class<*>
+internal val JvmCompilationResult.anyQualifier: Class<*>
   get() = classLoader.loadClass("com.squareup.test.AnyQualifier")
 
 @Suppress("UNCHECKED_CAST")
-internal val Result.bindingKey: Class<out Annotation>
+internal val JvmCompilationResult.bindingKey: Class<out Annotation>
   get() = classLoader.loadClass("com.squareup.test.BindingKey") as Class<out Annotation>
 
 internal val Class<*>.hintContributes: KClass<*>?

compiler/src/test/java/com/squareup/anvil/compiler/codegen/ContributesSubcomponentGeneratorTest.kt

@@ -7,7 +7,7 @@ import com.squareup.anvil.compiler.hintSubcomponent
 import com.squareup.anvil.compiler.hintSubcomponentParentScope
 import com.squareup.anvil.compiler.isError
 import com.squareup.anvil.compiler.subcomponentInterface
-import com.tschuchort.compiletesting.KotlinCompilation.Result
+import com.tschuchort.compiletesting.JvmCompilationResult
 import org.junit.Test
 import java.io.File
 
@@ -527,9 +527,9 @@ class ContributesSubcomponentGeneratorTest {
   private val Class<*>.parentComponentInterface: Class<*>
     get() = classLoader.loadClass("$canonicalName\$AnyParentComponent")
 
-  private val Result.subcomponentInterface1: Class<*>
+  private val JvmCompilationResult.subcomponentInterface1: Class<*>
     get() = classLoader.loadClass("com.squareup.test.SubcomponentInterface1")
 
-  private val Result.subcomponentInterface2: Class<*>
+  private val JvmCompilationResult.subcomponentInterface2: Class<*>
     get() = classLoader.loadClass("com.squareup.test.SubcomponentInterface2")
 }

compiler/src/test/java/com/squareup/anvil/compiler/codegen/ContributesSubcomponentHandlerGeneratorTest.kt

@@ -20,8 +20,8 @@ import com.squareup.anvil.compiler.isError
 import com.squareup.anvil.compiler.mergeComponentFqName
 import com.squareup.anvil.compiler.secondContributingInterface
 import com.squareup.anvil.compiler.subcomponentInterface
+import com.tschuchort.compiletesting.JvmCompilationResult
 import com.tschuchort.compiletesting.KotlinCompilation.ExitCode.OK
-import com.tschuchort.compiletesting.KotlinCompilation.Result
 import dagger.Component
 import org.junit.Test
 import javax.inject.Singleton
@@ -1980,18 +1980,18 @@ class ContributesSubcomponentHandlerGeneratorTest {
   private val Class<*>.daggerComponent: Class<*>
     get() = classLoader.loadClass("$packageName.Dagger$simpleName")
 
-  private val Result.componentInterface1: Class<*>
+  private val JvmCompilationResult.componentInterface1: Class<*>
     get() = classLoader.loadClass("com.squareup.test.ComponentInterface1")
 
-  private val Result.componentInterface2: Class<*>
+  private val JvmCompilationResult.componentInterface2: Class<*>
     get() = classLoader.loadClass("com.squareup.test.ComponentInterface2")
 
-  private val Result.subcomponentInterface1: Class<*>
+  private val JvmCompilationResult.subcomponentInterface1: Class<*>
     get() = classLoader.loadClass("com.squareup.test.SubcomponentInterface1")
 
-  private val Result.subcomponentInterface2: Class<*>
+  private val JvmCompilationResult.subcomponentInterface2: Class<*>
     get() = classLoader.loadClass("com.squareup.test.SubcomponentInterface2")
 
-  private val Result.subcomponentInterface3: Class<*>
+  private val JvmCompilationResult.subcomponentInterface3: Class<*>
     get() = classLoader.loadClass("com.squareup.test.SubcomponentInterface3")
 }

compiler/src/test/java/com/squareup/anvil/compiler/dagger/AnvilAnnotationDetectorCheckTest.kt

@@ -4,8 +4,8 @@ import com.google.common.truth.Truth.assertThat
 import com.squareup.anvil.compiler.WARNINGS_AS_ERRORS
 import com.squareup.anvil.compiler.internal.testing.compileAnvil
 import com.squareup.anvil.compiler.isError
+import com.tschuchort.compiletesting.JvmCompilationResult
 import com.tschuchort.compiletesting.KotlinCompilation.ExitCode.OK
-import com.tschuchort.compiletesting.KotlinCompilation.Result
 import org.intellij.lang.annotations.Language
 import org.junit.Test
 
@@ -129,7 +129,7 @@ class AnvilAnnotationDetectorCheckTest {
     }
   }
 
-  private fun Result.assertError() {
+  private fun JvmCompilationResult.assertError() {
     assertThat(exitCode).isError()
     assertThat(messages).contains("Source0.kt:6:7")
     assertThat(messages).contains(
@@ -141,8 +141,8 @@ class AnvilAnnotationDetectorCheckTest {
 
   private fun compile(
     @Language("kotlin") vararg sources: String,
-    block: Result.() -> Unit = { }
-  ): Result = compileAnvil(
+    block: JvmCompilationResult.() -> Unit = { }
+  ): JvmCompilationResult = compileAnvil(
     sources = sources,
     generateDaggerFactories = true,
     generateDaggerFactoriesOnly = true,

compiler/src/test/java/com/squareup/anvil/compiler/dagger/AnvilMergeAnnotationDetectorCheckTest.kt

@@ -4,8 +4,8 @@ import com.google.common.truth.Truth.assertThat
 import com.squareup.anvil.compiler.WARNINGS_AS_ERRORS
 import com.squareup.anvil.compiler.internal.testing.compileAnvil
 import com.squareup.anvil.compiler.isError
+import com.tschuchort.compiletesting.JvmCompilationResult
 import com.tschuchort.compiletesting.KotlinCompilation.ExitCode.OK
-import com.tschuchort.compiletesting.KotlinCompilation.Result
 import org.intellij.lang.annotations.Language
 import org.junit.Test
 
@@ -102,7 +102,7 @@ class AnvilMergeAnnotationDetectorCheckTest {
     }
   }
 
-  private fun Result.assertError() {
+  private fun JvmCompilationResult.assertError() {
     assertThat(exitCode).isError()
     assertThat(messages).contains("Source0.kt:6:7")
     assertThat(messages).contains(
@@ -114,8 +114,8 @@ class AnvilMergeAnnotationDetectorCheckTest {
 
   private fun compile(
     @Language("kotlin") vararg sources: String,
-    block: Result.() -> Unit = { }
-  ): Result = compileAnvil(
+    block: JvmCompilationResult.() -> Unit = { }
+  ): JvmCompilationResult = compileAnvil(
     sources = sources,
     disableComponentMerging = true,
     allWarningsAsErrors = WARNINGS_AS_ERRORS,

compiler/src/test/java/com/squareup/anvil/compiler/dagger/AssistedFactoryGeneratorTest.kt

@@ -15,8 +15,8 @@ import com.squareup.anvil.compiler.internal.testing.moduleFactoryClass
 import com.squareup.anvil.compiler.internal.testing.use
 import com.squareup.anvil.compiler.isError
 import com.squareup.anvil.compiler.isFullTestRun
+import com.tschuchort.compiletesting.JvmCompilationResult
 import com.tschuchort.compiletesting.KotlinCompilation.ExitCode.OK
-import com.tschuchort.compiletesting.KotlinCompilation.Result
 import org.intellij.lang.annotations.Language
 import org.junit.Test
 import org.junit.runner.RunWith
@@ -2026,8 +2026,8 @@ public final class AssistedServiceFactory_Impl implements AssistedServiceFactory
 
   private fun compile(
     @Language("kotlin") vararg sources: String,
-    block: Result.() -> Unit = { }
-  ): Result {
+    block: JvmCompilationResult.() -> Unit = { }
+  ): JvmCompilationResult {
     return prepareCompilation()
       .compile(*sources)
       .apply(block)

compiler/src/test/java/com/squareup/anvil/compiler/dagger/AssistedInjectGeneratorTest.kt

@@ -9,7 +9,7 @@ import com.squareup.anvil.compiler.internal.testing.invokeGet
 import com.squareup.anvil.compiler.internal.testing.isStatic
 import com.squareup.anvil.compiler.isError
 import com.squareup.anvil.compiler.isFullTestRun
-import com.tschuchort.compiletesting.KotlinCompilation.Result
+import com.tschuchort.compiletesting.JvmCompilationResult
 import org.intellij.lang.annotations.Language
 import org.junit.Test
 import org.junit.runner.RunWith
@@ -642,8 +642,8 @@ public final class AssistedService_Factory {
 
   private fun compile(
     @Language("kotlin") vararg sources: String,
-    block: Result.() -> Unit = { }
-  ): Result = compileAnvil(
+    block: JvmCompilationResult.() -> Unit = { }
+  ): JvmCompilationResult = compileAnvil(
     sources = sources,
     enableDaggerAnnotationProcessor = useDagger,
     generateDaggerFactories = !useDagger,

compiler/src/test/java/com/squareup/anvil/compiler/dagger/BindsMethodValidatorTest.kt

@@ -5,8 +5,8 @@ import com.squareup.anvil.compiler.WARNINGS_AS_ERRORS
 import com.squareup.anvil.compiler.internal.testing.compileAnvil
 import com.squareup.anvil.compiler.isError
 import com.squareup.anvil.compiler.isFullTestRun
+import com.tschuchort.compiletesting.JvmCompilationResult
 import com.tschuchort.compiletesting.KotlinCompilation.ExitCode.OK
-import com.tschuchort.compiletesting.KotlinCompilation.Result
 import org.intellij.lang.annotations.Language
 import org.junit.Test
 import org.junit.runner.RunWith
@@ -377,10 +377,10 @@ class BindsMethodValidatorTest(
 
   private fun compile(
     @Language("kotlin") vararg sources: String,
-    previousCompilationResult: Result? = null,
+    previousCompilationResult: JvmCompilationResult? = null,
     enableDagger: Boolean = useDagger,
-    block: Result.() -> Unit = { }
-  ): Result = compileAnvil(
+    block: JvmCompilationResult.() -> Unit = { }
+  ): JvmCompilationResult = compileAnvil(
     sources = sources,
     enableDaggerAnnotationProcessor = enableDagger,
     generateDaggerFactories = !enableDagger,

compiler/src/test/java/com/squareup/anvil/compiler/dagger/ComponentDetectorCheckTest.kt

@@ -4,8 +4,8 @@ import com.google.common.truth.Truth.assertThat
 import com.squareup.anvil.compiler.WARNINGS_AS_ERRORS
 import com.squareup.anvil.compiler.internal.testing.compileAnvil
 import com.squareup.anvil.compiler.isError
+import com.tschuchort.compiletesting.JvmCompilationResult
 import com.tschuchort.compiletesting.KotlinCompilation.ExitCode.OK
-import com.tschuchort.compiletesting.KotlinCompilation.Result
 import org.intellij.lang.annotations.Language
 import org.junit.Test
 
@@ -93,8 +93,8 @@ class ComponentDetectorCheckTest {
 
   private fun compile(
     @Language("kotlin") vararg sources: String,
-    block: Result.() -> Unit = { }
-  ): Result = compileAnvil(
+    block: JvmCompilationResult.() -> Unit = { }
+  ): JvmCompilationResult = compileAnvil(
     sources = sources,
     generateDaggerFactories = true,
     allWarningsAsErrors = WARNINGS_AS_ERRORS,

compiler/src/test/java/com/squareup/anvil/compiler/dagger/InjectConstructorFactoryGeneratorTest.kt

@@ -9,8 +9,8 @@ import com.squareup.anvil.compiler.internal.testing.getPropertyValue
 import com.squareup.anvil.compiler.internal.testing.isStatic
 import com.squareup.anvil.compiler.isError
 import com.squareup.anvil.compiler.isFullTestRun
+import com.tschuchort.compiletesting.JvmCompilationResult
 import com.tschuchort.compiletesting.KotlinCompilation.ExitCode.OK
-import com.tschuchort.compiletesting.KotlinCompilation.Result
 import dagger.Lazy
 import dagger.internal.Factory
 import org.intellij.lang.annotations.Language
@@ -2707,9 +2707,9 @@ public final class InjectClass_Factory implements Factory<InjectClass> {
 
   private fun compile(
     @Language("kotlin") vararg sources: String,
-    previousCompilationResult: Result? = null,
-    block: Result.() -> Unit = { }
-  ): Result = compileAnvil(
+    previousCompilationResult: JvmCompilationResult? = null,
+    block: JvmCompilationResult.() -> Unit = { }
+  ): JvmCompilationResult = compileAnvil(
     sources = sources,
     enableDaggerAnnotationProcessor = useDagger,
     generateDaggerFactories = !useDagger,

compiler/src/test/java/com/squareup/anvil/compiler/dagger/MapKeyCreatorGeneratorTest.kt

@@ -5,7 +5,7 @@ import com.squareup.anvil.compiler.WARNINGS_AS_ERRORS
 import com.squareup.anvil.compiler.internal.testing.compileAnvil
 import com.squareup.anvil.compiler.internal.testing.isStatic
 import com.squareup.anvil.compiler.isFullTestRun
-import com.tschuchort.compiletesting.KotlinCompilation.Result
+import com.tschuchort.compiletesting.JvmCompilationResult
 import org.intellij.lang.annotations.Language
 import org.jetbrains.kotlin.descriptors.runtime.components.tryLoadClass
 import org.junit.Ignore
@@ -217,8 +217,8 @@ class MapKeyCreatorGeneratorTest(
 
   private fun compile(
     @Language("kotlin") vararg sources: String,
-    block: Result.() -> Unit = { }
-  ): Result = compileAnvil(
+    block: JvmCompilationResult.() -> Unit = { }
+  ): JvmCompilationResult = compileAnvil(
     sources = sources,
     enableDaggerAnnotationProcessor = useDagger,
     generateDaggerFactories = !useDagger,