Convert STAR sample to KMP

.github/workflows/ci.yml

@@ -49,6 +49,11 @@ jobs:
               detektTest \
               assembleAndroidTest
 
+      - name: Verify STAR desktop builds
+        id: gradle-build-star-desktop
+        run: |
+          ./gradlew :samples:star:jvmJar -Pcircuit.buildDesktop
+
       # Defer these until after the above run, no need to waste resources running them if there are other failures first
       - name: Run instrumentation tests via emulator.wtf (main repo only)
         if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name == github.repository

build.gradle.kts

@@ -15,7 +15,7 @@ import io.gitlab.arturbosch.detekt.extensions.DetektExtension
 import java.net.URI
 import org.jetbrains.compose.ComposeExtension
 import org.jetbrains.dokka.gradle.DokkaTaskPartial
-import org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_11
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 import org.jetbrains.kotlin.gradle.dsl.KotlinJvmCompilerOptions
 import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
 import org.jetbrains.kotlin.gradle.dsl.KotlinProjectExtension
@@ -95,7 +95,13 @@ allprojects {
     format("license") {
       licenseHeaderFile(rootProject.file("spotless/spotless.kt"), "(package|@file:)")
       target("src/**/*.kt")
-      targetExclude("**/circuit/backstack/**/*.kt")
+      targetExclude(
+        "**/circuit/backstack/**/*.kt",
+        "**/HorizontalPagerIndicator.kt",
+        "**/FilterList.kt",
+        "**/Remove.kt",
+        "**/Pets.kt",
+      )
     }
   }
   configure<SpotlessExtension> {
@@ -131,6 +137,8 @@ fun Project.configureComposeBom(dependencyHandler: DependencyHandler) {
   }
 }
 
+val jvmTargetVersion = libs.versions.jvmTarget
+
 subprojects {
   pluginManager.withPlugin("java") {
     configure<JavaPluginExtension> {
@@ -141,7 +149,9 @@ subprojects {
       }
     }
 
-    tasks.withType<JavaCompile>().configureEach { options.release.set(11) }
+    tasks.withType<JavaCompile>().configureEach {
+      options.release.set(jvmTargetVersion.map(String::toInt))
+    }
 
     // This is the default base plugin applied on all projects, so safe to add this hook here
     configureComposeBom(dependencies)
@@ -154,7 +164,7 @@ subprojects {
       compilerOptions {
         allWarningsAsErrors.set(true)
         if (this is KotlinJvmCompilerOptions) {
-          jvmTarget.set(JVM_11)
+          jvmTarget.set(jvmTargetVersion.map(JvmTarget::fromTarget))
           // Stub gen copies args from the parent compilation
           if (this@configureEach !is KaptGenerateStubsTask) {
             freeCompilerArgs.addAll(
@@ -448,8 +458,19 @@ subprojects {
 
   pluginManager.withPlugin("wtf.emulator.gradle") {
     val emulatorWtfToken = providers.gradleProperty("emulatorWtfToken")
-    if (emulatorWtfToken.isPresent) {
-      configure<EwExtension> { token.set(emulatorWtfToken) }
+    configure<EwExtension> {
+      devices.set(
+        listOf(
+          mapOf(
+            "model" to "Pixel2Atd",
+            "version" to "30",
+            "atd" to "true",
+          )
+        )
+      )
+      if (emulatorWtfToken.isPresent) {
+        token.set(emulatorWtfToken)
+      }
     }
     // We don't always run emulator.wtf on CI (forks can't access it), so we add this helper
     // lifecycle task that depends on connectedCheck as an alternative. We do this only on projects

circuit-codegen/src/main/kotlin/com/slack/circuit/codegen/CircuitSymbolProcessorProvider.kt

@@ -124,6 +124,8 @@ private class CircuitSymbolProcessor(
   private val platforms: List<PlatformInfo>,
 ) : SymbolProcessor {
 
+  private val lenient = options["circuit.codegen.lenient"]?.toBoolean() ?: false
+
   override fun process(resolver: Resolver): List<KSAnnotated> {
     val symbols = CircuitSymbols.create(resolver) ?: return emptyList()
     val codegenMode =
@@ -375,23 +377,28 @@ private class CircuitSymbolProcessor(
           }
       }
       InstantiationType.CLASS -> {
-        val cd = annotatedElement as KSClassDeclaration
-        cd.checkVisibility(logger) {
+        val declaration = annotatedElement as KSClassDeclaration
+        declaration.checkVisibility(logger) {
           return null
         }
-        val isAssisted = cd.isAnnotationPresent(AssistedFactory::class)
+        val isAssisted =
+          if (lenient) {
+            declaration.annotations.any { it.shortName.asString().contains("AssistedFactory") }
+          } else {
+            declaration.isAnnotationPresent(AssistedFactory::class)
+          }
         val creatorOrConstructor: KSFunctionDeclaration?
         val targetClass: KSClassDeclaration
         if (isAssisted) {
-          val creatorFunction = cd.getAllFunctions().filter { it.isAbstract }.single()
+          val creatorFunction = declaration.getAllFunctions().filter { it.isAbstract }.single()
           creatorOrConstructor = creatorFunction
           targetClass = creatorFunction.returnType!!.resolve().declaration as KSClassDeclaration
           targetClass.checkVisibility(logger) {
             return null
           }
         } else {
-          creatorOrConstructor = cd.primaryConstructor
-          targetClass = cd
+          creatorOrConstructor = declaration.primaryConstructor
+          targetClass = declaration
         }
         val useProvider =
           !isAssisted && creatorOrConstructor?.isAnnotationPresent(Inject::class) == true
@@ -409,10 +416,16 @@ private class CircuitSymbolProcessor(
             }
             .firstOrNull()
             ?: run {
+              val annotationsString =
+                declaration.annotations.toList().joinToString {
+                  it.annotationType.resolve().toTypeName().toString()
+                }
               logger.error(
                 "Factory must be for a UI or Presenter class, but was " +
-                  "${targetClass.qualifiedName?.asString()}. " +
-                  "Supertypes: ${targetClass.getAllSuperTypes().toList()}",
+                  "${targetClass.qualifiedName?.asString()}.\n" +
+                  "Supertypes: ${targetClass.getAllSuperTypes().toList()}.\n" +
+                  "isAssisted? ${isAssisted}\n" +
+                  "Annotations: $annotationsString}",
                 targetClass
               )
               return null
@@ -442,7 +455,9 @@ private class CircuitSymbolProcessor(
             CodeBlock.of("provider.get()")
           } else if (isAssisted) {
             // Inject the target class's assisted factory that we'll call its create() on.
-            constructorParams.add(ParameterSpec.builder("factory", cd.toClassName()).build())
+            constructorParams.add(
+              ParameterSpec.builder("factory", declaration.toClassName()).build()
+            )
             CodeBlock.of(
               "factory.%L(%L)",
               creatorOrConstructor!!.simpleName.getShortName(),

circuit-codegen/src/test/kotlin/com/slack/circuit/codegen/CircuitSymbolProcessorTest.kt

@@ -1091,9 +1091,7 @@ class CircuitSymbolProcessorTest {
         )
     ) { messages ->
       assertThat(messages)
-        .contains(
-          "Factory must be for a UI or Presenter class, but was test.Favorites. Supertypes: [Any]"
-        )
+        .contains("Factory must be for a UI or Presenter class, but was test.Favorites.")
     }
   }
 

circuitx/gesture-navigation/src/commonMain/kotlin/com/slack/circuitx/gesturenavigation/OptionalLayout.kt

@@ -12,7 +12,7 @@ import androidx.compose.ui.layout.layout
  * A composable which optionally lays out the given [content], depending on what [shouldLayout]
  * returns, whilst still keeping [content] attached to composition.
  *
- * This is useful when used in conjuction with `movableContentOf`, as that will destroy the
+ * This is useful when used in conjunction with `movableContentOf`, as that will destroy the
  * content's state 'very soon' after the content is detached from composition. By using this
  * composable, the content can remain attached to composition, but can avoid being measured, laid
  * out or drawn, allowing us to reduce wasted work.

docs/code-gen.md

@@ -24,6 +24,16 @@ ksp {
 }
 ```
 
+If using Kotlin multiplatform with typealias annotations for Dagger annotations (i.e. expect 
+annotations in common with actual typealias declarations in JVM source sets), you can match on just 
+annotation short names alone to support this case via `circuit.codegen.lenient` mode.
+
+```kotlin
+ksp {
+  arg("circuit.codegen.lenient", "true")
+}
+```
+
 ## Usage
 
 The primary entry point is the `CircuitInject` annotation.

gradle.properties

@@ -31,11 +31,17 @@ org.gradle.parallel=true
 org.gradle.configureondemand=true
 org.gradle.caching=true
 
+# Disable noisy DAGP stability warning
+dependency.analysis.compatibility=NONE
+
 # Disable noisy stability warning
 kotlin.mpp.stability.nowarn=true
 kotlin.mpp.androidSourceSetLayoutVersion=2
 kotlin.mpp.androidGradlePluginCompatibility.nowarn=true
 
+# https://kotlinlang.org/docs/ksp-multiplatform.html#avoid-the-ksp-configuration-on-ksp-1-0-1
+systemProp.allowAllTargetConfiguration=false
+
 # Enable for Compose iOS
 org.jetbrains.compose.experimental.uikit.enabled=true
 # Enable for Compose Web