Add Wire Binary Compatibility plugin

gradle/libs.versions.toml

@@ -50,9 +50,11 @@ jmh-generator = { module = "org.openjdk.jmh:jmh-generator-annprocess", version.r
 jsr305 = { module = "com.google.code.findbugs:jsr305", version.ref = "jsr305" }
 junit = { module = "junit:junit", version.ref = "junit" }
 kaml = { module = "com.charleskorn.kaml:kaml", version = "0.72.0" }
+kotlin-compile-testing = { module = "dev.zacsweers.kctfork:core", version = "0.7.0" }
 kotlin-coroutines-android = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-android", version.ref = "coroutines" }
 kotlin-coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "coroutines" }
 kotlin-gradleApi = { module = "org.jetbrains.kotlin:kotlin-gradle-plugin-api", version.ref = "kotlin" }
+kotlin-gradlePlugin = { module = "org.jetbrains.kotlin:kotlin-gradle-plugin", version.ref = "kotlin" }
 kotlin-jsr223 = { module = "org.jetbrains.kotlin:kotlin-scripting-jsr223", version.ref = "kotlin" }
 kotlin-reflect = { module = "org.jetbrains.kotlin:kotlin-reflect", version.ref = "kotlin" }
 kotlin-serialization = { module = "org.jetbrains.kotlinx:kotlinx-serialization-core", version = "1.8.0" }

settings.gradle.kts

@@ -83,3 +83,6 @@ include(":samples:wire-codegen-sample")
 include(":samples:wire-grpc-sample:client")
 include(":samples:wire-grpc-sample:protos")
 include(":samples:wire-grpc-sample:server")
+include(":wire-binary-compatibility-gradle-plugin")
+include(":wire-binary-compatibility-kotlin-plugin")
+include(":wire-binary-compatibility-kotlin-plugin-tests")

wire-binary-compatibility-gradle-plugin/README.md

@@ -0,0 +1,43 @@
+# Wire Binary Compatibility Plugin
+
+The Wire Binary Compatibility Kotlin compiler plugin adapts Wire-generated callsites to be more resilient
+to schema changes.
+
+## Current Support
+Generated constructor callsites are rewritten at compile-time to instead use the Builder.
+Generated copy() callsites are not yet supported.
+
+## Example
+Given a generated class, Dinosaur, from a proto defintion:
+```protobuf
+package com.squareup.dinosaurs;
+
+message Dinosaur {
+  optional string name = 1;
+  optional double avg_length_meters = 2;
+}
+```
+
+With existing usage:
+```kotlin
+val newDinosaur = Dinosaur(
+  name = "triceratops",
+  avg_length_meters = 9.0,
+)
+```
+
+When a new field is added to the Dinosaur schema, if there are competing versions of the compiled class and the new
+version is resolved at runtime, the usage above may encounter an error:
+```
+java.lang.NoSuchMethodError: 'void com.squareup.dinosaurs.Dinosaur<init>(java.lang.String, java.lang.Double,
+{new_field})'
+```
+
+Using the Wire Binary Compatibility Plugin will adapt the compiled binary to use the equivalent Builder:
+```kotlin
+val newDinosaur = Dinosaur.Builder()
+  .name("triceratops")
+  .avg_length_meters(9.0)
+  .build()
+```
+The rewritten, compiled code is backwards compatible with the new field.

wire-binary-compatibility-gradle-plugin/build.gradle.kts

@@ -0,0 +1,50 @@
+import com.vanniktech.maven.publish.GradlePlugin
+import com.vanniktech.maven.publish.JavadocJar
+import com.vanniktech.maven.publish.MavenPublishBaseExtension
+
+plugins {
+  id("java-gradle-plugin")
+  `kotlin-dsl`
+  kotlin("jvm")
+  id("com.github.gmazzo.buildconfig")
+  id("org.jetbrains.dokka")
+  id("com.vanniktech.maven.publish.base")
+}
+
+dependencies {
+  compileOnly(kotlin("gradle-plugin-api"))
+  compileOnly(libs.kotlin.gradlePlugin)
+  implementation(projects.wireBinaryCompatibilityKotlinPlugin)
+}
+
+buildConfig {
+  useKotlinOutput {
+    internalVisibility = true
+  }
+  val compilerPlugin = projects.wireBinaryCompatibilityKotlinPlugin
+  val packageName = "com.squareup.wire.binarycompatibility.gradle"
+  packageName(packageName)
+  buildConfigField("String", "KOTLIN_PLUGIN_ID", "\"${packageName}\"")
+  buildConfigField("String", "KOTLIN_PLUGIN_GROUP", "\"${compilerPlugin.group}\"")
+  buildConfigField("String", "KOTLIN_PLUGIN_NAME", "\"${compilerPlugin.name}\"")
+  buildConfigField("String", "KOTLIN_PLUGIN_VERSION", "\"${compilerPlugin.version}\"")
+}
+
+gradlePlugin {
+  plugins {
+    create("wireBinaryCompatibility") {
+      id = "com.squareup.wire.binarycompatibility"
+      displayName = "Wire Binary Compatibility"
+      description = "Rewrites Wire callsites to be resilient to API changes"
+      implementationClass = "com.squareup.wire.binarycompatibility.gradle.WireBinaryCompatibility"
+    }
+  }
+}
+
+configure<MavenPublishBaseExtension> {
+  configure(
+    GradlePlugin(
+      javadocJar = JavadocJar.Empty()
+    )
+  )
+}

wire-binary-compatibility-gradle-plugin/src/main/kotlin/com/squareup/wire/binarycompatibility/gradle/WireBinaryCompatibilityPlugin.kt

@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2025 Square, Inc.
+ *
+ * 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
+ *
+ *      https://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 com.squareup.wire.binarycompatibility.gradle
+
+import org.gradle.api.provider.Provider
+import org.jetbrains.kotlin.gradle.plugin.KotlinCompilation
+import org.jetbrains.kotlin.gradle.plugin.KotlinCompilerPluginSupportPlugin
+import org.jetbrains.kotlin.gradle.plugin.SubpluginArtifact
+import org.jetbrains.kotlin.gradle.plugin.SubpluginOption
+
+@Suppress("unused") // Created reflectively by Gradle.
+class WireBinaryCompatibilityPlugin : KotlinCompilerPluginSupportPlugin {
+  override fun isApplicable(kotlinCompilation: KotlinCompilation<*>): Boolean = true
+
+  override fun getCompilerPluginId(): String = "com.squareup.wire.binarycompatibility.kotlin"
+
+  override fun getPluginArtifact(): SubpluginArtifact = SubpluginArtifact(
+    groupId = BuildConfig.KOTLIN_PLUGIN_GROUP,
+    artifactId = BuildConfig.KOTLIN_PLUGIN_NAME,
+    version = BuildConfig.KOTLIN_PLUGIN_VERSION,
+  )
+
+  override fun applyToCompilation(
+    kotlinCompilation: KotlinCompilation<*>,
+  ): Provider<List<SubpluginOption>> {
+    return kotlinCompilation.target.project.provider {
+      listOf() // No options.
+    }
+  }
+}

wire-binary-compatibility-kotlin-plugin-tests/build.gradle.kts

@@ -0,0 +1,13 @@
+plugins {
+  kotlin("jvm")
+  id("org.jetbrains.dokka")
+}
+
+dependencies {
+  testImplementation(kotlin("gradle-plugin-api"))
+  testImplementation(project(":wire-binary-compatibility-kotlin-plugin"))
+  testImplementation(kotlin("compiler-embeddable"))
+  testImplementation(kotlin("test-junit"))
+  testImplementation(libs.assertk)
+  testImplementation(libs.kotlin.compile.testing)
+}

wire-binary-compatibility-kotlin-plugin-tests/src/test/kotlin/com/squareup/wire/binarycompatibility/WireBinaryCompatibilityKotlinPluginTest.kt

@@ -0,0 +1,125 @@
+/*
+ * Copyright (C) 2025 Square, Inc.
+ *
+ * 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
+ *
+ *      https://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 com.squareup.wire.binarycompatibility.kotlin
+
+import assertk.assertThat
+import assertk.assertions.contains
+import assertk.assertions.containsExactly
+import com.tschuchort.compiletesting.JvmCompilationResult
+import com.tschuchort.compiletesting.KotlinCompilation
+import com.tschuchort.compiletesting.SourceFile
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import org.jetbrains.kotlin.compiler.plugin.CompilerPluginRegistrar
+import org.jetbrains.kotlin.compiler.plugin.ExperimentalCompilerApi
+
+@OptIn(ExperimentalCompilerApi::class)
+class WireBinaryCompatibilityKotlinPluginTest {
+  @Test
+  fun rewriteConstructorCallToBuilderCall() {
+    val result = compile(
+      sourceFile = SourceFile.kotlin(
+        "Sample.kt",
+        """
+        package com.squareup.wire
+
+        val log = mutableListOf<String>()
+
+        fun callConstructor() {
+            log += "${'$'}{Money(5, "USD")}"
+          }
+
+        fun callConstructorWithDefaultParameters() {
+            log += "${'$'}{Money(amount = 5)}"
+            log += "${'$'}{Money(currencyCode = "USD")}"
+          }
+
+        data class Money(
+          val amount: Long? = null,
+          val currencyCode: String? = null,
+        ) : Message {
+
+          class Builder : Message.Builder {
+            var amount: Long? = null
+            var currencyCode: String? = null
+
+            fun amount(amount: Long) : Builder {
+              log += "calling amount()!"
+              this.amount = amount
+              return this
+            }
+
+            fun currencyCode(currencyCode: String) : Builder {
+              log += "calling currencyCode()!"
+              this.currencyCode = currencyCode
+              return this
+            }
+            fun build() : Money = Money(amount, currencyCode)
+          }
+        }
+
+        interface Message {
+          interface Builder
+        }
+        """,
+      ),
+    )
+    assertEquals(KotlinCompilation.ExitCode.OK, result.exitCode, result.messages)
+
+    val testClass = result.classLoader.loadClass("com.squareup.wire.SampleKt")
+    val log = testClass.getMethod("getLog")
+      .invoke(null) as MutableList<String>
+
+    testClass.getMethod("callConstructor").invoke(null)
+    assertThat(log).containsExactly(
+      "calling amount()!",
+      "calling currencyCode()!",
+      "Money(amount=5, currencyCode=USD)",
+    )
+    log.clear()
+
+    testClass.getMethod("callConstructorWithDefaultParameters").invoke(null)
+    assertThat(log).containsExactly(
+      "calling amount()!",
+      "Money(amount=5, currencyCode=null)",
+      "calling currencyCode()!",
+      "Money(amount=null, currencyCode=USD)",
+    )
+    log.clear()
+  }
+}
+
+@ExperimentalCompilerApi
+fun compile(
+  sourceFiles: List<SourceFile>,
+  plugin: CompilerPluginRegistrar = WireBinaryCompatibilityCompilerPluginRegistrar(),
+): JvmCompilationResult {
+  return KotlinCompilation().apply {
+    sources = sourceFiles
+    compilerPluginRegistrars = listOf(plugin)
+    inheritClassPath = true
+    kotlincArguments += "-Xverify-ir=error"
+    kotlincArguments += "-Xverify-ir-visibility"
+  }.compile()
+}
+
+@ExperimentalCompilerApi
+fun compile(
+  sourceFile: SourceFile,
+  plugin: CompilerPluginRegistrar = WireBinaryCompatibilityCompilerPluginRegistrar(),
+): JvmCompilationResult {
+  return compile(listOf(sourceFile), plugin)
+}

wire-binary-compatibility-kotlin-plugin/build.gradle.kts

@@ -0,0 +1,31 @@
+import com.vanniktech.maven.publish.JavadocJar
+import com.vanniktech.maven.publish.KotlinJvm
+import com.vanniktech.maven.publish.MavenPublishBaseExtension
+
+plugins {
+  kotlin("jvm")
+  id("com.github.gmazzo.buildconfig")
+  id("com.vanniktech.maven.publish.base")
+}
+
+dependencies {
+  compileOnly(kotlin("compiler-embeddable"))
+  compileOnly(kotlin("stdlib"))
+}
+
+buildConfig {
+  useKotlinOutput {
+    internalVisibility = true
+  }
+
+  packageName("com.squareup.wire.binarycompatibility.kotlin")
+  buildConfigField("String", "KOTLIN_PLUGIN_ID", "\"com.squareup.wire.binarycompatibility.kotlin\"")
+}
+
+configure<MavenPublishBaseExtension> {
+  configure(
+    KotlinJvm(
+      javadocJar = JavadocJar.Empty()
+    )
+  )
+}

wire-binary-compatibility-kotlin-plugin/gradle.properties

@@ -0,0 +1,2 @@
+# We want the stdlib as a compileOnly dependency.
+kotlin.stdlib.default.dependency=false

wire-binary-compatibility-kotlin-plugin/src/main/kotlin/com/squareup/wire/binarycompatibility/kotlin/WireBinaryCompatibilityCommandLineProcessor.kt

@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2025 Square, Inc.
+ *
+ * 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
+ *
+ *      https://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 com.squareup.wire.binarycompatibility.kotlin
+
+import org.jetbrains.kotlin.compiler.plugin.CliOption
+import org.jetbrains.kotlin.compiler.plugin.CommandLineProcessor
+import org.jetbrains.kotlin.compiler.plugin.ExperimentalCompilerApi
+
+@OptIn(ExperimentalCompilerApi::class)
+class WireBinaryCompatibilityCommandLineProcessor : CommandLineProcessor {
+  override val pluginId = "com.squareup.wire.binarycompatibility.kotlin"
+
+  override val pluginOptions: List<CliOption> = listOf()
+}