From 078aedfb6813fbb14c44a44f3d2b91051e06c47d Mon Sep 17 00:00:00 2001 From: InsanusMokrassar Date: Wed, 5 Nov 2025 13:42:27 +0600 Subject: [PATCH] update dependencies --- android/pickers/build.gradle | 1 + gradle.properties | 4 +-- gradle/libs.versions.toml | 15 +++++---- koin/generator/src/main/kotlin/Processor.kt | 32 ++++++++++++++++--- .../generator/src/main/kotlin/Processor.kt | 15 +++++++-- .../main/kotlin/NoSuchElementWorkaround.kt | 12 +++++++ .../generator/src/main/kotlin/Processor.kt | 17 ++++++++-- .../generator/src/main/kotlin/Processor.kt | 5 ++- 8 files changed, 82 insertions(+), 19 deletions(-) create mode 100644 ksp/generator/src/main/kotlin/NoSuchElementWorkaround.kt diff --git a/android/pickers/build.gradle b/android/pickers/build.gradle index 17c6ce042b4..faacb584ba8 100644 --- a/android/pickers/build.gradle +++ b/android/pickers/build.gradle @@ -13,6 +13,7 @@ kotlin { androidMain { dependencies { api project(":micro_utils.android.smalltextfield") + api libs.jb.compose.icons } } } diff --git a/gradle.properties b/gradle.properties index 2fb41aa903c..ad67b9865ca 100644 --- a/gradle.properties +++ b/gradle.properties @@ -8,8 +8,8 @@ android.useAndroidX=true android.enableJetifier=true org.gradle.jvmargs=-Xmx2g -XX:MaxMetaspaceSize=2g -# https://github.com/google/ksp/issues/2491 -ksp.useKSP2=false +## https://github.com/google/ksp/issues/2491 +#ksp.useKSP2=false # JS NPM diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml index 41e75db3ba2..cfe1d0ac472 100644 --- a/gradle/libs.versions.toml +++ b/gradle/libs.versions.toml @@ -1,6 +1,6 @@ [versions] -kt = "2.2.20" +kt = "2.2.21" kt-serialization = "1.9.0" kt-coroutines = "1.10.2" @@ -8,11 +8,13 @@ kotlinx-browser = "0.5.0" kslog = "1.5.1" -jb-compose = "1.8.2" +jb-compose = "1.9.2" +jb-compose-material3 = "1.9.0" +jb-compose-icons = "1.7.8" jb-exposed = "0.61.0" jb-dokka = "2.1.0" -# 3.50.3.0 contains bug https://github.com/InsanusMokrassar/MicroUtils/actions/runs/18138301958/job/51629588088 +# 3.51.0.0 contains bug, checking with ./gradlew :micro_utils.repos.exposed:jvmTest sqlite = "3.50.1.0" korlibs = "5.4.0" @@ -26,11 +28,11 @@ koin = "4.1.1" okio = "3.16.2" -ksp = "2.2.20-2.0.3" +ksp = "2.3.1" kotlin-poet = "2.2.0" versions = "0.52.0" -nmcp = "1.1.0" +nmcp = "1.2.0" android-gradle = "8.10.+" dexcount = "4.0.0" @@ -89,7 +91,8 @@ jb-exposed = { module = "org.jetbrains.exposed:exposed-core", version.ref = "jb- jb-exposed-jdbc = { module = "org.jetbrains.exposed:exposed-jdbc", version.ref = "jb-exposed" } sqlite = { module = "org.xerial:sqlite-jdbc", version.ref = "sqlite" } -jb-compose-material3 = { module = "org.jetbrains.compose.material3:material3", version.ref = "jb-compose" } +jb-compose-material3 = { module = "org.jetbrains.compose.material3:material3", version.ref = "jb-compose-material3" } +jb-compose-icons = { module = "androidx.compose.material:material-icons-extended", version.ref = "jb-compose-icons" } android-coreKtx = { module = "androidx.core:core-ktx", version.ref = "android-coreKtx" } android-recyclerView = { module = "androidx.recyclerview:recyclerview", version.ref = "android-recyclerView" } diff --git a/koin/generator/src/main/kotlin/Processor.kt b/koin/generator/src/main/kotlin/Processor.kt index 6933cafb563..a0496fd743a 100644 --- a/koin/generator/src/main/kotlin/Processor.kt +++ b/koin/generator/src/main/kotlin/Processor.kt @@ -27,6 +27,7 @@ import com.squareup.kotlinpoet.ksp.toClassName import com.squareup.kotlinpoet.ksp.toTypeName import com.squareup.kotlinpoet.ksp.writeTo import dev.inmo.micro_ksp.generator.safeClassName +import dev.inmo.micro_ksp.generator.withNoSuchElementWorkaround import dev.inmo.micro_utils.koin.annotations.GenerateGenericKoinDefinition import dev.inmo.micro_utils.koin.annotations.GenerateKoinDefinition import org.koin.core.Koin @@ -240,9 +241,14 @@ class Processor( ksFile.getAnnotationsByType(GenerateKoinDefinition::class).forEach { val type = safeClassName { it.type } val targetType = runCatching { - type.parameterizedBy(*(it.typeArgs.takeIf { it.isNotEmpty() } ?.map { it.asTypeName() } ?.toTypedArray() ?: return@runCatching type)) + type.parameterizedBy( + *withNoSuchElementWorkaround(emptyArray()) { + it.typeArgs.takeIf { it.isNotEmpty() } ?.map { it.asTypeName() } ?.toTypedArray() ?: return@runCatching type + } + ) }.getOrElse { e -> when (e) { + is IllegalArgumentException if (e.message ?.contains("no type argument") == true) -> return@getOrElse type is KSTypeNotPresentException -> e.ksType.toClassName() } if (e is KSTypesNotPresentException) { @@ -251,14 +257,32 @@ class Processor( throw e } }.copy( - nullable = it.nullable + nullable = withNoSuchElementWorkaround(true) { it.nullable } ) - addCodeForType(targetType, it.name, it.nullable, it.generateSingle, it.generateFactory) + addCodeForType( + targetType, + it.name, + withNoSuchElementWorkaround(true) { + it.nullable + }, + withNoSuchElementWorkaround(true) { + it.generateSingle + }, + withNoSuchElementWorkaround(true) { + it.generateFactory + } + ) } ksFile.getAnnotationsByType(GenerateGenericKoinDefinition::class).forEach { val targetType = TypeVariableName("T", Any::class) - addCodeForType(targetType, it.name, it.nullable, it.generateSingle, it.generateFactory) + addCodeForType( + targetType = targetType, + name = it.name, + nullable = withNoSuchElementWorkaround(true) { it.nullable }, + generateSingle = withNoSuchElementWorkaround(true) { it.generateSingle }, + generateFactory = withNoSuchElementWorkaround(true) { it.generateFactory } + ) } }.build().let { File( diff --git a/ksp/classcasts/generator/src/main/kotlin/Processor.kt b/ksp/classcasts/generator/src/main/kotlin/Processor.kt index bd387d233b8..7c3e8ea6ee7 100644 --- a/ksp/classcasts/generator/src/main/kotlin/Processor.kt +++ b/ksp/classcasts/generator/src/main/kotlin/Processor.kt @@ -10,6 +10,7 @@ import com.google.devtools.ksp.processing.SymbolProcessor import com.google.devtools.ksp.symbol.* import com.squareup.kotlinpoet.* import com.squareup.kotlinpoet.ksp.toClassName +import dev.inmo.micro_ksp.generator.withNoSuchElementWorkaround import dev.inmo.micro_ksp.generator.writeFile import dev.inmo.micro_utils.ksp.classcasts.ClassCastsExcluded import dev.inmo.micro_utils.ksp.classcasts.ClassCastsIncluded @@ -25,7 +26,11 @@ class Processor( ) { val rootAnnotation = ksClassDeclaration.getAnnotationsByType(ClassCastsIncluded::class).first() val (includeRegex: Regex?, excludeRegex: Regex?) = rootAnnotation.let { - it.typesRegex.takeIf { it.isNotEmpty() } ?.let(::Regex) to it.excludeRegex.takeIf { it.isNotEmpty() } ?.let(::Regex) + withNoSuchElementWorkaround("") { + it.typesRegex + }.takeIf { it.isNotEmpty() } ?.let(::Regex) to withNoSuchElementWorkaround("") { + it.excludeRegex + }.takeIf { it.isNotEmpty() } ?.let(::Regex) } val classesSubtypes = mutableMapOf>() @@ -49,7 +54,9 @@ class Processor( when { potentialSubtype === ksClassDeclaration -> {} potentialSubtype.isAnnotationPresent(ClassCastsExcluded::class) -> return@forEach - potentialSubtype !is KSClassDeclaration || !potentialSubtype.checkSupertypeLevel(rootAnnotation.levelsToInclude.takeIf { it >= 0 }) -> return@forEach + potentialSubtype !is KSClassDeclaration || !potentialSubtype.checkSupertypeLevel( + withNoSuchElementWorkaround(-1) { rootAnnotation.levelsToInclude }.takeIf { it >= 0 } + ) -> return@forEach excludeRegex ?.matches(simpleName) == true -> return@forEach includeRegex ?.matches(simpleName) == false -> {} else -> classesSubtypes.getOrPut(ksClassDeclaration) { mutableSetOf() }.add(potentialSubtype) @@ -96,7 +103,9 @@ class Processor( @OptIn(KspExperimental::class) override fun process(resolver: Resolver): List { (resolver.getSymbolsWithAnnotation(ClassCastsIncluded::class.qualifiedName!!)).filterIsInstance().forEach { - val prefix = it.getAnnotationsByType(ClassCastsIncluded::class).first().outputFilePrefix + val prefix = withNoSuchElementWorkaround("") { + it.getAnnotationsByType(ClassCastsIncluded::class).first().outputFilePrefix + } it.writeFile(prefix = prefix, suffix = "ClassCasts") { FileSpec.builder( it.packageName.asString(), diff --git a/ksp/generator/src/main/kotlin/NoSuchElementWorkaround.kt b/ksp/generator/src/main/kotlin/NoSuchElementWorkaround.kt new file mode 100644 index 00000000000..a5e19134ddc --- /dev/null +++ b/ksp/generator/src/main/kotlin/NoSuchElementWorkaround.kt @@ -0,0 +1,12 @@ +package dev.inmo.micro_ksp.generator + +inline fun withNoSuchElementWorkaround( + default: T, + block: () -> T +): T = runCatching(block).getOrElse { + if (it is NoSuchElementException) { + default + } else { + throw it + } +} diff --git a/ksp/sealed/generator/src/main/kotlin/Processor.kt b/ksp/sealed/generator/src/main/kotlin/Processor.kt index f11bd40257b..f46ae51775e 100644 --- a/ksp/sealed/generator/src/main/kotlin/Processor.kt +++ b/ksp/sealed/generator/src/main/kotlin/Processor.kt @@ -12,6 +12,7 @@ import com.squareup.kotlinpoet.ksp.toClassName import dev.inmo.micro_ksp.generator.buildSubFileName import dev.inmo.micro_ksp.generator.companion import dev.inmo.micro_ksp.generator.findSubClasses +import dev.inmo.micro_ksp.generator.withNoSuchElementWorkaround import dev.inmo.micro_ksp.generator.writeFile import dev.inmo.micro_utils.ksp.sealed.GenerateSealedTypesWorkaround import dev.inmo.micro_utils.ksp.sealed.GenerateSealedWorkaround @@ -113,7 +114,7 @@ class Processor( val annotation = ksClassDeclaration.getGenerateSealedTypesWorkaroundAnnotation val subClasses = ksClassDeclaration.resolveSubclasses( searchIn = resolver.getAllFiles(), - allowNonSealed = annotation ?.includeNonSealedSubTypes ?: false + allowNonSealed = withNoSuchElementWorkaround(null) { annotation ?.includeNonSealedSubTypes } ?: false ).distinct() val subClassesNames = subClasses.filter { it.getAnnotationsByType(GenerateSealedTypesWorkaround.Exclude::class).count() == 0 @@ -164,7 +165,15 @@ class Processor( @OptIn(KspExperimental::class) override fun process(resolver: Resolver): List { (resolver.getSymbolsWithAnnotation(GenerateSealedWorkaround::class.qualifiedName!!)).filterIsInstance().forEach { - val prefix = (it.getGenerateSealedWorkaroundAnnotation) ?.prefix ?.takeIf { + val prefix = runCatching { + (it.getGenerateSealedWorkaroundAnnotation) ?.prefix + }.getOrElse { + if (it is NoSuchElementException) { + "" + } else { + throw it + } + } ?.takeIf { it.isNotEmpty() } ?: it.buildSubFileName.replaceFirst(it.simpleName.asString(), "") it.writeFile(prefix = prefix, suffix = "SealedWorkaround") { @@ -184,7 +193,9 @@ class Processor( } } (resolver.getSymbolsWithAnnotation(GenerateSealedTypesWorkaround::class.qualifiedName!!)).filterIsInstance().forEach { - val prefix = (it.getGenerateSealedTypesWorkaroundAnnotation) ?.prefix ?.takeIf { + val prefix = withNoSuchElementWorkaround("") { + (it.getGenerateSealedTypesWorkaroundAnnotation)?.prefix + } ?.takeIf { it.isNotEmpty() } ?: it.buildSubFileName.replaceFirst(it.simpleName.asString(), "") it.writeFile(prefix = prefix, suffix = "SealedTypesWorkaround") { diff --git a/ksp/variations/generator/src/main/kotlin/Processor.kt b/ksp/variations/generator/src/main/kotlin/Processor.kt index 59d8ad6bc5e..085196f8105 100644 --- a/ksp/variations/generator/src/main/kotlin/Processor.kt +++ b/ksp/variations/generator/src/main/kotlin/Processor.kt @@ -16,6 +16,7 @@ import com.squareup.kotlinpoet.ksp.toTypeName import dev.inmo.micro_ksp.generator.convertToClassName import dev.inmo.micro_ksp.generator.convertToClassNames import dev.inmo.micro_ksp.generator.findSubClasses +import dev.inmo.micro_ksp.generator.withNoSuchElementWorkaround import dev.inmo.micro_ksp.generator.writeFile import dev.inmo.micro_utils.ksp.variations.GenerateVariations import dev.inmo.micro_utils.ksp.variations.GenerationVariant @@ -218,7 +219,9 @@ class Processor( @OptIn(KspExperimental::class) override fun process(resolver: Resolver): List { (resolver.getSymbolsWithAnnotation(GenerateVariations::class.qualifiedName!!)).filterIsInstance().forEach { - val prefix = (it.getAnnotationsByType(GenerateVariations::class)).firstOrNull() ?.prefix ?.takeIf { + val prefix = withNoSuchElementWorkaround("") { + (it.getAnnotationsByType(GenerateVariations::class)).firstOrNull() ?.prefix + } ?.takeIf { it.isNotEmpty() } ?: it.simpleName.asString().replaceFirst(it.simpleName.asString(), "") it.writeFile(prefix = prefix, suffix = "GeneratedVariation") {