IssueTracker

Summary

There is a problem with the R8 shrinker in versions 8.6., 8.7., and 8.8.0, where it improperly strips code related to Java Service Provider Interface (SPI) usage. This issue occurs when a class is provided via the Java SPI API using ServiceLoader.load(SomeInterface.class) without direct references from other code. While the service provider class is retained, some of its code is stripped, leading to runtime errors.

Affected Versions

• R8 versions: 8.6., 8.7., 8.8.0 (latest release at the time of reporting)

Description

The issue arises when using Java SPI to load service providers. Specifically, when a class is loaded using ServiceLoader.load(SomeInterface.class) and there are no direct references to it from other parts of the code, R8 retains the service provider class but strips some of its code. This results in a NullPointerException (NPE) during runtime.

Reproduction Steps

1. Set up a project with the following module structure:

   .
   ├── app
   ├── api
   └── provider
   

2. Implement the following code:

   • MainActivity.kt in the :app module:

     import ...
     import com.example.api.Spi
     
     class MainActivity : Activity() {
         ...
         private fun testApi() {
             val api = Spi.instance.createApi() // Got null in the release build
             Log.d("MainActivity", "api: $api")
             api.querySomething() // Crashes here due to a NPE
         }
     }
     

   • Api.kt in the :api module:

     pacakge com.example.api
     ...
     interface Spi {
         fun createApi(): Api
         companion object {
             @JvmStatic
             val instance: Spi by lazy {
                 ServiceLoader.load(Spi::class.java).firstOrNull() ?: error("Missing Api provider")
             }
         }
     }
     interface Api {
         fun querySomething(): String
     }
     

   • MyApi.kt in the :provider module:

     pacakge com.example.provider
     import com.example.api.Api
     import com.example.api.Spi
     class MySpi : Spi {
         @Volatile
         private var myApi: Api? = null
     
         /**
          * The dex byte code of this method is when obfuscated:
          * ```
          * .method public a()Lz/a;
          *     .registers 2
          *
          *     .line 1
          *     const/4 v0, 0x0
          *
          *     .line 2
          *     return-object v0
          * .end method
          * ```
          */
         override fun createApi(): Api {
             return myApi ?: synchronized(this) {
                 myApi ?: MyApi().also { myApi = it }
             }
         }
     }
     class MyApi : Api {
         override fun querySomething(): String {
             return "Hello from MyApi"
         }
     }
     

   • add the service provider file (named com.example.api.Spi) in src/main/resources/META-INF/service/ in the provider:

     com.example.provider.MySpi
     

3. Configure the build.gradle.kts in the :app module as follows:

   dependencies {
       api(project(":api"))
       runtimeOnly(project(":provider"))
   }
   

4. Build the project in release mode with R8 enabled.

5. Run the application and observe the NullPointerException when testApi() is called.

Expected Behavior

The service provider class and its methods should be fully retained by R8, allowing the application to run without errors.

Actual Behavior

The service provider class is retained, but some of its code is stripped, leading to a NullPointerException during runtime.

Additional Information

The full source code for reproducing this issue can be found at: https://github.com/zhcnxf/testagp87