V1

CHANGELOG.md

@@ -1,3 +1,21 @@
+# 0.4.0-alpha06
+* Add support for Kotlin 2.1.0
+
+# 0.4.0-alpha05
+* Set JvmVersion to 1.8
+
+# 0.4.0-alpha04
+* Update Dagger version
+
+# 0.4.0-alpha03
+* Update XProcessing version
+
+# 0.4.0-alpha02
+* Upgrade JavaPoet, KotlinPoet, & XProcessing
+
+# 0.4.0-alpha01
+* Initial support for KSP
+
 # 0.3.8
 
 * Throw CannotResolveType error when compiler cannot resolve it.

ast/build.gradle

@@ -1,18 +1,12 @@
 plugins {
     id 'org.jetbrains.kotlin.jvm'
-    id 'org.jetbrains.dokka'
+    id 'com.vanniktech.maven.publish'
 }
 
-apply plugin: 'kotlin-kapt'
-
-sourceCompatibility = 1.8
-
 dependencies {
     implementation deps.kotlin.stdlib
     implementation deps.dagger
 
     testImplementation deps.test.junit
     testImplementation deps.test.truth
 }
-
-apply plugin: 'com.vanniktech.maven.publish'

ast/src/main/kotlin/motif/ast/IrAnnotated.kt

@@ -21,11 +21,8 @@ interface IrAnnotated {
 
   val annotations: List<IrAnnotation>
 
-  fun hasAnnotation(annotationClass: KClass<out Annotation>): Boolean {
-    return annotations.any { it.matchesClass(annotationClass) }
-  }
+  fun hasAnnotation(annotationClass: KClass<out Annotation>): Boolean =
+      annotations.any { it.matchesClass(annotationClass) }
 
-  fun isNullable(): Boolean {
-    return annotations.any { it.className?.endsWith("Nullable") == true }
-  }
+  fun isNullable(): Boolean = annotations.any { it.className?.endsWith("Nullable") == true }
 }

ast/src/main/kotlin/motif/ast/IrAnnotation.kt

@@ -25,5 +25,7 @@ interface IrAnnotation : IrEquivalence {
 
   val members: List<IrMethod>
 
+  val annotationValueMap: Map<String, Any?>
+
   fun matchesClass(annotationClass: KClass<out Annotation>): Boolean
 }

ast/src/main/kotlin/motif/ast/IrClass.kt

@@ -34,16 +34,13 @@ interface IrClass : IrAnnotated, IrHasModifiers {
   val simpleName: String
     get() = type.simpleName
 
-  fun hasNonDefaultConstructor(): Boolean {
-    return constructors.any { it.hasParameters() }
-  }
+  fun hasNonDefaultConstructor(): Boolean = constructors.any { it.hasParameters() }
 
-  fun annotatedInnerClass(annotationClass: KClass<out Annotation>): IrClass? {
-    return nestedClasses.find { it.hasAnnotation(annotationClass) }
-  }
+  fun annotatedInnerClass(annotationClass: KClass<out Annotation>): IrClass? =
+      nestedClasses.find { it.hasAnnotation(annotationClass) }
 
   enum class Kind {
     CLASS,
-    INTERFACE
+    INTERFACE,
   }
 }

ast/src/main/kotlin/motif/ast/IrHasModifiers.kt

@@ -19,19 +19,11 @@ interface IrHasModifiers {
 
   val modifiers: Set<IrModifier>
 
-  fun isStatic(): Boolean {
-    return IrModifier.STATIC in modifiers
-  }
+  fun isStatic(): Boolean = IrModifier.STATIC in modifiers
 
-  fun isPrivate(): Boolean {
-    return IrModifier.PRIVATE in modifiers
-  }
+  fun isPrivate(): Boolean = IrModifier.PRIVATE in modifiers
 
-  fun isPublic(): Boolean {
-    return IrModifier.PUBLIC in modifiers
-  }
+  fun isPublic(): Boolean = IrModifier.PUBLIC in modifiers
 
-  fun isAbstract(): Boolean {
-    return IrModifier.ABSTRACT in modifiers
-  }
+  fun isAbstract(): Boolean = IrModifier.ABSTRACT in modifiers
 }

ast/src/main/kotlin/motif/ast/IrMethod.kt

@@ -21,11 +21,7 @@ interface IrMethod : IrAnnotated, IrHasModifiers {
   val name: String
   val isConstructor: Boolean
 
-  fun hasParameters(): Boolean {
-    return parameters.isNotEmpty()
-  }
+  fun hasParameters(): Boolean = parameters.isNotEmpty()
 
-  fun isVoid(): Boolean {
-    return returnType.isVoid
-  }
+  fun isVoid(): Boolean = returnType.isVoid
 }

ast/src/main/kotlin/motif/ast/IrModifier.kt

@@ -30,5 +30,5 @@ enum class IrModifier {
   VOLATILE,
   DEFAULT,
   OPEN,
-  TRANSITIVE
+  TRANSITIVE,
 }

ast/src/main/kotlin/motif/ast/IrType.kt

@@ -25,6 +25,7 @@ interface IrType : IrEquivalence {
     get() = simpleName(qualifiedName)
 
   fun resolveClass(): IrClass?
+
   fun isAssignableTo(type: IrType): Boolean
 }
 

ast/src/test/kotlin/motif/ast/SimpleNameTest.kt

@@ -33,13 +33,12 @@ class SimpleNameTest(private val qualifiedName: String, private val expectedSimp
             "java.util.List<? super java.lang.String>" to "List<? super String>",
             "java.util.Map<java.lang.String, java.lang.Integer>" to "Map<String, Integer>",
             "java.util.Map<? extends java.lang.String, ? super java.lang.Integer>" to
-                "Map<? extends String, ? super Integer>")
+                "Map<? extends String, ? super Integer>",
+        )
 
     @JvmStatic
     @Parameterized.Parameters(name = "{0}")
-    fun data(): Collection<Array<Any>> {
-      return tests.map { (key, value) -> arrayOf<Any>(key, value) }
-    }
+    fun data(): Collection<Array<Any>> = tests.map { (key, value) -> arrayOf(key, value) }
   }
 
   @Test

build.gradle

@@ -1,3 +1,5 @@
+import org.jetbrains.dokka.gradle.DokkaTaskPartial
+
 // https://github.com/gradle/gradle/issues/4848
 gradle.startParameter.configureOnDemand = false
 
@@ -11,6 +13,7 @@ buildscript {
     }
     dependencies {
         classpath deps.build.gradlePlugins.android
+        classpath deps.build.gradlePlugins.intellij
         classpath deps.build.gradlePlugins.kotlin
         classpath deps.build.gradlePlugins.ksp
         classpath deps.build.gradlePlugins.dokka
@@ -39,6 +42,12 @@ subprojects {
                 useTarget(deps.autoCommon)
             } else if (requested.group == "org.jetbrains.kotlinx" && requested.name == "kotlinx-metadata") {
                 useTarget(deps.kotlinxMetadata)
+            } else if (requested.group == "com.google.devtools.ksp") {
+                useVersion(deps.versions.ksp)
+            } else if (requested.group == "androidx.room") {
+                if (requested.name != "room-compiler-processing" && requested.name != "room-compiler-processing-testing") {
+                    useVersion(deps.versions.room)
+                }
             }
         }
     }
@@ -56,44 +65,85 @@ subprojects {
         }
         boolean isKotlinLibrary = project.plugins.hasPlugin("org.jetbrains.kotlin.jvm") || project.plugins.hasPlugin("org.jetbrains.kotlin.android")
         if (isKotlinLibrary) {
+            java {
+                toolchain.languageVersion.set(JavaLanguageVersion.of(11))
+            }
+            kotlin {
+                jvmToolchain(11)
+            }
             it.tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).configureEach {
                 kotlinOptions {
                     freeCompilerArgs += extraKotlincArgs
                 }
             }
         }
+
+        boolean isAndroidLibraryOrApp = project.plugins.hasPlugin("org.jetbrains.kotlin.android")
+        if (isAndroidLibraryOrApp) {
+            android {
+                compileOptions {
+                    sourceCompatibility JavaVersion.VERSION_1_8
+                    targetCompatibility JavaVersion.VERSION_1_8
+                }
+
+            }
+        }
+
+        if (isKotlinLibrary && isAndroidLibraryOrApp) {
+            android {
+                kotlinOptions {
+                    jvmTarget = "1.8"
+                }
+            }
+        }
     }
 
     if (project.path != ":tests") {
         apply plugin: 'com.diffplug.spotless'
         spotless {
             format 'misc', {
-                target '**/*.md', '**/.gitignore'
+                target '*.md', '.gitignore'
 
                 trimTrailingWhitespace()
                 endWithNewline()
             }
             kotlin {
-                target "**/*.kt"
-                ktlint(deps.versions.ktlint).userData(['indent_size': '2', 'continuation_indent_size': '2'])
+                target "src/**/*.kt"
+                ktlint(deps.versions.ktlint).editorConfigOverride([
+                        "indent_size": "2",
+                        "continuation_indent_size": "4"
+                ])
+                suppressLintsFor {
+                    step = 'ktlint'
+                    shortCode = 'standard:function-naming'
+                }
                 ktfmt(deps.versions.ktfmt)
                 licenseHeaderFile rootProject.file('config/spotless/copyright.kt')
                 trimTrailingWhitespace()
                 endWithNewline()
             }
             java {
-                target "**/*.java"
+                target "src/**/*.java"
                 googleJavaFormat(deps.versions.gjf)
                 licenseHeaderFile rootProject.file('config/spotless/copyright.java')
                 removeUnusedImports()
                 trimTrailingWhitespace()
                 endWithNewline()
             }
             groovyGradle {
-                target '**/*.gradle'
+                target '*.gradle'
                 trimTrailingWhitespace()
                 endWithNewline()
             }
         }
     }
+
+    apply plugin: 'org.jetbrains.dokka'
+    if (!project.name.contains("samples") && !project.name.contains("tests")) {
+        tasks.withType(DokkaTaskPartial).configureEach {
+            outputDirectory.set(new File(buildDir, "docs/partial"))
+            moduleName.set(project.property("POM_ARTIFACT_ID").toString())
+            moduleVersion.set(project.property("VERSION_NAME").toString())
+        }
+    }
 }

compiler/ast/build.gradle

@@ -1,13 +1,8 @@
 plugins {
     id 'org.jetbrains.kotlin.jvm'
-    id 'org.jetbrains.dokka'
+    id 'com.vanniktech.maven.publish'
 }
 
-apply plugin: 'kotlin-kapt'
-
-sourceCompatibility = 1.8
-
-
 dependencies {
     implementation deps.kotlin.stdlib
     implementation deps.autoCommon
@@ -22,5 +17,3 @@ dependencies {
     testImplementation deps.test.compileTesting
     testImplementation deps.test.roomCompilerProcessingTesting
 }
-
-apply plugin: 'com.vanniktech.maven.publish'

compiler/ast/src/main/kotlin/com/uber/xprocessing/ext/XAnnotation.kt

@@ -28,25 +28,23 @@ import com.google.auto.common.AnnotationMirrors
  * Used to find equivalence of two XAnnotation since AnnotationMirrors.equivalence() only applies to
  * the Javac backend.
  */
-fun XAnnotation.isEquivalent(other: XAnnotation, env: XProcessingEnv): Boolean {
-  return if (env.backend == XProcessingEnv.Backend.JAVAC) {
-    val key = AnnotationMirrors.equivalence().wrap(this.toJavac())
-    val otherKey = AnnotationMirrors.equivalence().wrap(other.toJavac())
-    key == otherKey
-  } else {
-    (type.isEquivalent(other.type, env) &&
-        annotationValues.size == other.annotationValues.size &&
-        annotationValues.zip(other.annotationValues).all { (lhs, rhs) -> lhs.isEquivalent(rhs) })
-  }
-}
+fun XAnnotation.isEquivalent(other: XAnnotation, env: XProcessingEnv): Boolean =
+    if (env.backend == XProcessingEnv.Backend.JAVAC) {
+      val key = AnnotationMirrors.equivalence().wrap(this.toJavac())
+      val otherKey = AnnotationMirrors.equivalence().wrap(other.toJavac())
+      key == otherKey
+    } else {
+      (type.isEquivalent(other.type, env) &&
+          annotationValues.size == other.annotationValues.size &&
+          annotationValues.zip(other.annotationValues).all { (lhs, rhs) -> lhs.isEquivalent(rhs) })
+    }
 
 /**
  * Used to find equivalence of two XAnnotation since AnnotationMirrors.equivalence() only applies to
  * the Javac backend.
  */
-fun XAnnotationValue.isEquivalent(other: XAnnotationValue): Boolean {
-  return this.name == other.name && this.value == other.value
-}
+fun XAnnotationValue.isEquivalent(other: XAnnotationValue): Boolean =
+    this.name == other.name && this.value == other.value
 
 /** Cleans up differences in the toString() methods between the JAVAC and KSP backends. */
 fun XAnnotation.toPrettyString(): String {
@@ -55,7 +53,9 @@ fun XAnnotation.toPrettyString(): String {
           .map {
             if (it.name == "value") {
               "\"${it.value}\""
-            } else "${it.name} = ${it.value}"
+            } else {
+              "${it.name} = ${it.value}"
+            }
           }
           .joinToString(", ")
   val annotationValuesList =

compiler/ast/src/main/kotlin/com/uber/xprocessing/ext/XElement.kt

@@ -33,13 +33,10 @@ val XElement.modifiers: List<Modifier>
       if (isFinal()) modifiers += Modifier.FINAL
       if (isTransient()) modifiers += Modifier.TRANSIENT
       return@let modifiers
-    }
-        ?: emptyList()
+    } ?: emptyList()
   }
 
 val XElement.modifierNames: List<String>
   get() = modifiers.map { it.name }
 
-fun XHasModifiers.isPackagePrivate(): Boolean {
-  return !isPrivate() && !isProtected() && !isPublic()
-}
+fun XHasModifiers.isPackagePrivate(): Boolean = !isPrivate() && !isProtected() && !isPublic()