From a8b5d6f99017e64a2c3e0998fb4936f471fc15f7 Mon Sep 17 00:00:00 2001 From: Zac Sweers Date: Fri, 28 Jun 2024 16:34:09 -0400 Subject: [PATCH] Misc repo infra updates (#150) * Gradle 8.8 * Update dependencies * Add upcoming changes to CHANGELOG * Modernize CI * Empty * Make debugging easier * Update expected rules --- .github/workflows/ci.yml | 33 +- CHANGELOG.md | 8 + gradle/libs.versions.toml | 22 +- gradle/wrapper/gradle-wrapper.properties | 2 +- gradlew | 2 +- .../gradle/wrapper/gradle-wrapper.properties | 2 +- keeper-gradle-plugin/gradlew | 2 +- sample/build.gradle.kts | 13 +- sample/expectedRules.pro | 376 +++++++++++++++++- 9 files changed, 414 insertions(+), 46 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index b6cab19c..1fdc05b2 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -30,7 +30,7 @@ jobs: fail-fast: false # We want to see all results matrix: os: [ 'ubuntu-latest', 'windows-latest', 'macos-latest'] - agp: ['8.4.0', '8.5.0-alpha08'] + agp: ['8.5.0', '8.6.0-alpha08'] job: ['instrumentation', 'plugin'] env: DEP_OVERRIDE_agp: ${{ matrix.agp }} @@ -68,42 +68,21 @@ jobs: run: | echo 'KERNEL=="kvm", GROUP="kvm", MODE="0666", OPTIONS+="static_node=kvm"' | sudo tee /etc/udev/rules.d/99-kvm4all.rules sudo udevadm control --reload-rules - sudo udevadm trigger --name-match=kvm - - # TODO AVD caching disabled due to https://github.com/ReactiveCircus/android-emulator-runner/issues/278 -# - name: AVD cache -# uses: actions/cache@v3 -# id: avd-cache -# if: matrix.job == 'instrumentation' && matrix.os == 'ubuntu-latest' -# with: -# path: | -# ~/.android/avd/* -# ~/.android/adbkey -# ~/.android/adbkey.pub -# key: avd-${{ env.API_LEVEL }}-${{ env.AVD_TARGET }} -# -# - name: Create AVD and generate snapshot for caching -# if: matrix.job == 'instrumentation' && matrix.os == 'ubuntu-latest' && steps.avd-cache.outputs.cache-hit != 'true' -# uses: reactivecircus/android-emulator-runner@v2 -# with: -# api-level: ${{ env.API_LEVEL }} -# force-avd-creation: false -# emulator-options: -no-window -gpu swiftshader_indirect -noaudio -no-boot-anim -camera-back none -# disable-animations: true -# disable-spellchecker: true -# target: ${{ env.AVD_TARGET }} -# channel: canary # Necessary for ATDs -# script: echo "Generated AVD snapshot for caching." + sudo udevadm trigger --name-match=kvm - name: Run instrumentation tests if: matrix.job == 'instrumentation' && matrix.os == 'ubuntu-latest' + id: gradle-instrumentation-fork uses: reactivecircus/android-emulator-runner@v2 with: api-level: ${{ env.API_LEVEL }} + arch: x86_64 force-avd-creation: false emulator-options: -no-snapshot-save -no-window -gpu swiftshader_indirect -noaudio -no-boot-anim -camera-back none disable-animations: true disable-spellchecker: true + disk-size: 6000M + heap-size: 600M target: 'aosp_atd' channel: canary # Necessary for ATDs script: | diff --git a/CHANGELOG.md b/CHANGELOG.md index 6a4392d3..42e22e12 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,6 +1,14 @@ Changelog ========= +**Unreleased** +-------------- + +- **Fix**: Support running on Windows. +- Build against Gradle `8.8`. +- Build against AGP `8.5.0`. +- Build against Kotlin `1.9.24`. + 0.16.0 ------ diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml index 9410079f..7c55e31a 100644 --- a/gradle/libs.versions.toml +++ b/gradle/libs.versions.toml @@ -1,30 +1,30 @@ [versions] -agp = "8.4.0" -androidx-test = "1.6.0-alpha07" -kotlin = "1.9.23" +agp = "8.5.0" +androidx-test = "1.6.1" +kotlin = "1.9.24" gjf = "1.22.0" -ktfmt = "0.49" +ktfmt = "0.51" [plugins] agp-library = { id = "com.android.library", version.ref = "agp" } -binaryCompatibilityValidator = { id = "org.jetbrains.kotlinx.binary-compatibility-validator", version = "0.13.2" } +binaryCompatibilityValidator = { id = "org.jetbrains.kotlinx.binary-compatibility-validator", version = "0.15.0-Beta.3" } kotlin-jvm = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" } -mavenPublish = { id = "com.vanniktech.maven.publish", version = "0.28.0" } +mavenPublish = { id = "com.vanniktech.maven.publish", version = "0.29.0" } spotless = { id = "com.diffplug.spotless", version = "6.25.0" } [libraries] -androidx-annotation = "androidx.annotation:annotation:1.7.1" -androidx-test-orchestrator = "androidx.test:orchestrator:1.5.0-alpha04" -androidx-test-rules = { module = "androidx.test:rules", version = "1.6.0-alpha04" } +androidx-annotation = "androidx.annotation:annotation:1.8.0" +androidx-test-orchestrator = "androidx.test:orchestrator:1.5.0" +androidx-test-rules = { module = "androidx.test:rules", version = "1.6.1" } androidx-test-runner = { module = "androidx.test:runner", version.ref = "androidx-test" } -androidx-test-truth = "androidx.test.ext:junit:1.1.5" +androidx-test-truth = "androidx.test.ext:junit:1.2.1" agp = { module = "com.android.tools.build:gradle", version.ref = "agp" } desugarJdkLibs = "com.android.tools:desugar_jdk_libs:2.0.4" javapoet = "com.squareup:javapoet:1.13.0" junit = "junit:junit:4.13.2" kgp = { module = "org.jetbrains.kotlin:kotlin-gradle-plugin", version.ref = "kotlin" } kgp-api = { module = "org.jetbrains.kotlin:kotlin-gradle-plugin-api", version.ref = "kotlin" } -kotlinpoet = "com.squareup:kotlinpoet:1.16.0" +kotlinpoet = "com.squareup:kotlinpoet:1.17.0" okio = "com.squareup.okio:okio:3.9.0" truth = "com.google.truth:truth:1.4.2" zipflinger = { module = "com.android:zipflinger", version.ref = "agp" } diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties index b82aa23a..a4413138 100644 --- a/gradle/wrapper/gradle-wrapper.properties +++ b/gradle/wrapper/gradle-wrapper.properties @@ -1,6 +1,6 @@ distributionBase=GRADLE_USER_HOME distributionPath=wrapper/dists -distributionUrl=https\://services.gradle.org/distributions/gradle-8.7-bin.zip +distributionUrl=https\://services.gradle.org/distributions/gradle-8.8-bin.zip networkTimeout=10000 validateDistributionUrl=true zipStoreBase=GRADLE_USER_HOME diff --git a/gradlew b/gradlew index 1aa94a42..b740cf13 100755 --- a/gradlew +++ b/gradlew @@ -55,7 +55,7 @@ # Darwin, MinGW, and NonStop. # # (3) This script is generated from the Groovy template -# https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt +# https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt # within the Gradle project. # # You can find Gradle at https://github.com/gradle/gradle/. diff --git a/keeper-gradle-plugin/gradle/wrapper/gradle-wrapper.properties b/keeper-gradle-plugin/gradle/wrapper/gradle-wrapper.properties index b82aa23a..a4413138 100644 --- a/keeper-gradle-plugin/gradle/wrapper/gradle-wrapper.properties +++ b/keeper-gradle-plugin/gradle/wrapper/gradle-wrapper.properties @@ -1,6 +1,6 @@ distributionBase=GRADLE_USER_HOME distributionPath=wrapper/dists -distributionUrl=https\://services.gradle.org/distributions/gradle-8.7-bin.zip +distributionUrl=https\://services.gradle.org/distributions/gradle-8.8-bin.zip networkTimeout=10000 validateDistributionUrl=true zipStoreBase=GRADLE_USER_HOME diff --git a/keeper-gradle-plugin/gradlew b/keeper-gradle-plugin/gradlew index 1aa94a42..b740cf13 100755 --- a/keeper-gradle-plugin/gradlew +++ b/keeper-gradle-plugin/gradlew @@ -55,7 +55,7 @@ # Darwin, MinGW, and NonStop. # # (3) This script is generated from the Groovy template -# https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt +# https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt # within the Gradle project. # # You can find Gradle at https://github.com/gradle/gradle/. diff --git a/sample/build.gradle.kts b/sample/build.gradle.kts index 0703ad55..30ffdce4 100644 --- a/sample/build.gradle.kts +++ b/sample/build.gradle.kts @@ -124,11 +124,18 @@ if (isCi) { tasks.withType().configureEach { doLast { println("Checking expected rules") - val outputRules = outputProguardRules.asFile.get().readText().trim() - val expectedRules = file("expectedRules.pro").readText().trim() + val outputFile = outputProguardRules.asFile.get() + val outputRules = outputFile.readText().trim() + val expectedFile = file("expectedRules.pro") + val expectedRules = expectedFile.readText().trim() if (outputRules != expectedRules) { System.err.println( - "Rules don't match expected, output rules are below. Compare them with 'expectedRules.pro'" + """ + Rules don't match expected + Actual: file://$outputFile + Expected: file://$expectedFile + """ + .trimIndent() ) assertThat(outputRules).isEqualTo(expectedRules) } diff --git a/sample/expectedRules.pro b/sample/expectedRules.pro index 37c981b7..b9154daa 100644 --- a/sample/expectedRules.pro +++ b/sample/expectedRules.pro @@ -11,6 +11,18 @@ public void testOnlyMethod(); com.slack.keeper.sample.TestOnlyKotlinClass INSTANCE; } +-keep class kotlin.ExceptionsKt { +} +-keep class kotlin.ExceptionsKt__ExceptionsKt { + public static void addSuppressed(java.lang.Throwable,java.lang.Throwable); +} +-keep class kotlin.KotlinNothingValueException { + public (); +} +-keep class kotlin.KotlinVersion { + public boolean isAtLeast(int,int,int); + kotlin.KotlinVersion CURRENT; +} -keep interface kotlin.Lazy { public java.lang.Object getValue(); } @@ -19,28 +31,390 @@ -keep class kotlin.LazyKt__LazyJVMKt { public static kotlin.Lazy lazy(kotlin.jvm.functions.Function0); } +-keep class kotlin.NoWhenBranchMatchedException { + public (); +} +-keep class kotlin.Pair { + public java.lang.Object component1(); + public java.lang.Object component2(); + public java.lang.Object getFirst(); + public java.lang.Object getSecond(); +} +-keep class kotlin.Result { + public static java.lang.Object constructor-impl(java.lang.Object); + public static java.lang.Throwable exceptionOrNull-impl(java.lang.Object); + public static boolean isFailure-impl(java.lang.Object); + public static boolean isSuccess-impl(java.lang.Object); + kotlin.Result$Companion Companion; +} +-keep class kotlin.Result$Companion { +} +-keep class kotlin.ResultKt { + public static java.lang.Object createFailure(java.lang.Throwable); + public static void throwOnFailure(java.lang.Object); +} +-keep class kotlin.TuplesKt { + public static kotlin.Pair to(java.lang.Object,java.lang.Object); +} -keep class kotlin.Unit { kotlin.Unit INSTANCE; } +-keep class kotlin._Assertions { + boolean ENABLED; +} +-keep class kotlin.collections.AbstractMutableMap { + protected (); + public java.util.Set getEntries(); + public java.util.Set getKeys(); + public int getSize(); + public java.util.Set keySet(); + public java.lang.Object put(java.lang.Object,java.lang.Object); + public int size(); +} +-keep class kotlin.collections.AbstractMutableSet { + protected (); + public boolean add(java.lang.Object); + public int getSize(); +} +-keep class kotlin.collections.ArrayDeque { + public (); + public void addLast(java.lang.Object); + public boolean isEmpty(); + public java.lang.Object removeFirstOrNull(); +} +-keep class kotlin.collections.ArraysKt { +} +-keep class kotlin.collections.ArraysKt___ArraysJvmKt { + public static java.lang.Object[] copyInto$default(java.lang.Object[],java.lang.Object[],int,int,int,int,java.lang.Object); + public static void fill$default(java.lang.Object[],java.lang.Object,int,int,int,java.lang.Object); +} +-keep class kotlin.collections.ArraysKt___ArraysKt { + public static java.lang.Iterable asIterable(java.lang.Object[]); + public static java.lang.Object getOrNull(java.lang.Object[],int); +} +-keep class kotlin.collections.CollectionsKt { +} +-keep class kotlin.collections.CollectionsKt__CollectionsJVMKt { + public static java.util.List build(java.util.List); + public static java.util.List createListBuilder(); + public static java.util.List createListBuilder(int); + public static java.util.List listOf(java.lang.Object); +} +-keep class kotlin.collections.CollectionsKt__CollectionsKt { + public static java.util.List emptyList(); + public static java.util.List listOf(java.lang.Object[]); +} +-keep class kotlin.collections.CollectionsKt__IterablesKt { + public static int collectionSizeOrDefault(java.lang.Iterable,int); +} +-keep class kotlin.collections.CollectionsKt__MutableCollectionsKt { + public static boolean addAll(java.util.Collection,java.lang.Iterable); +} +-keep class kotlin.collections.CollectionsKt___CollectionsKt { + public static kotlin.sequences.Sequence asSequence(java.lang.Iterable); + public static java.lang.Object firstOrNull(java.util.List); + public static java.lang.String joinToString$default(java.lang.Iterable,java.lang.CharSequence,java.lang.CharSequence,java.lang.CharSequence,int,java.lang.CharSequence,kotlin.jvm.functions.Function1,int,java.lang.Object); + public static java.util.List plus(java.util.Collection,java.lang.Object); + public static java.util.List toList(java.lang.Iterable); + public static java.util.Set toSet(java.lang.Iterable); +} +-keep class kotlin.collections.IndexedValue { + public (int,java.lang.Object); + public int getIndex(); + public java.lang.Object getValue(); +} +-keep class kotlin.collections.IntIterator { + public int nextInt(); +} +-keep class kotlin.collections.LongIterator { + public long nextLong(); +} +-keep class kotlin.collections.MapsKt { +} +-keep class kotlin.collections.MapsKt__MapsJVMKt { + public static int mapCapacity(int); +} +-keep class kotlin.comparisons.ComparisonsKt { +} +-keep class kotlin.comparisons.ComparisonsKt__ComparisonsKt { + public static int compareValues(java.lang.Comparable,java.lang.Comparable); +} +-keep class kotlin.concurrent.ThreadsKt { + public static java.lang.Thread thread$default(boolean,boolean,java.lang.ClassLoader,java.lang.String,int,kotlin.jvm.functions.Function0,int,java.lang.Object); +} +-keep class kotlin.coroutines.AbstractCoroutineContextElement { + public (kotlin.coroutines.CoroutineContext$Key); + public kotlin.coroutines.CoroutineContext$Element get(kotlin.coroutines.CoroutineContext$Key); + public kotlin.coroutines.CoroutineContext minusKey(kotlin.coroutines.CoroutineContext$Key); + public kotlin.coroutines.CoroutineContext plus(kotlin.coroutines.CoroutineContext); +} +-keep class kotlin.coroutines.AbstractCoroutineContextKey { + public (kotlin.coroutines.CoroutineContext$Key,kotlin.jvm.functions.Function1); +} +-keep interface kotlin.coroutines.Continuation { + public kotlin.coroutines.CoroutineContext getContext(); + public void resumeWith(java.lang.Object); +} +-keep interface kotlin.coroutines.ContinuationInterceptor { + public kotlin.coroutines.CoroutineContext$Element get(kotlin.coroutines.CoroutineContext$Key); + public kotlin.coroutines.Continuation interceptContinuation(kotlin.coroutines.Continuation); + public kotlin.coroutines.CoroutineContext minusKey(kotlin.coroutines.CoroutineContext$Key); + public void releaseInterceptedContinuation(kotlin.coroutines.Continuation); + kotlin.coroutines.ContinuationInterceptor$Key Key; +} +-keep class kotlin.coroutines.ContinuationInterceptor$DefaultImpls { + public static kotlin.coroutines.CoroutineContext$Element get(kotlin.coroutines.ContinuationInterceptor,kotlin.coroutines.CoroutineContext$Key); + public static kotlin.coroutines.CoroutineContext minusKey(kotlin.coroutines.ContinuationInterceptor,kotlin.coroutines.CoroutineContext$Key); +} +-keep class kotlin.coroutines.ContinuationInterceptor$Key { +} +-keep class kotlin.coroutines.ContinuationKt { + public static kotlin.coroutines.Continuation createCoroutine(kotlin.jvm.functions.Function1,kotlin.coroutines.Continuation); + public static void startCoroutine(kotlin.jvm.functions.Function1,kotlin.coroutines.Continuation); + public static void startCoroutine(kotlin.jvm.functions.Function2,java.lang.Object,kotlin.coroutines.Continuation); +} +-keep interface kotlin.coroutines.CoroutineContext { + public java.lang.Object fold(java.lang.Object,kotlin.jvm.functions.Function2); + public kotlin.coroutines.CoroutineContext$Element get(kotlin.coroutines.CoroutineContext$Key); + public kotlin.coroutines.CoroutineContext minusKey(kotlin.coroutines.CoroutineContext$Key); + public kotlin.coroutines.CoroutineContext plus(kotlin.coroutines.CoroutineContext); +} +-keep interface kotlin.coroutines.CoroutineContext$Element { + public java.lang.Object fold(java.lang.Object,kotlin.jvm.functions.Function2); + public kotlin.coroutines.CoroutineContext$Element get(kotlin.coroutines.CoroutineContext$Key); + public kotlin.coroutines.CoroutineContext$Key getKey(); + public kotlin.coroutines.CoroutineContext minusKey(kotlin.coroutines.CoroutineContext$Key); +} +-keep class kotlin.coroutines.CoroutineContext$Element$DefaultImpls { + public static java.lang.Object fold(kotlin.coroutines.CoroutineContext$Element,java.lang.Object,kotlin.jvm.functions.Function2); + public static kotlin.coroutines.CoroutineContext$Element get(kotlin.coroutines.CoroutineContext$Element,kotlin.coroutines.CoroutineContext$Key); + public static kotlin.coroutines.CoroutineContext minusKey(kotlin.coroutines.CoroutineContext$Element,kotlin.coroutines.CoroutineContext$Key); + public static kotlin.coroutines.CoroutineContext plus(kotlin.coroutines.CoroutineContext$Element,kotlin.coroutines.CoroutineContext); +} +-keep interface kotlin.coroutines.CoroutineContext$Key { +} +-keep class kotlin.coroutines.EmptyCoroutineContext { + kotlin.coroutines.EmptyCoroutineContext INSTANCE; +} +-keep class kotlin.coroutines.intrinsics.IntrinsicsKt { +} +-keep class kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsJvmKt { + public static kotlin.coroutines.Continuation createCoroutineUnintercepted(kotlin.jvm.functions.Function1,kotlin.coroutines.Continuation); + public static kotlin.coroutines.Continuation createCoroutineUnintercepted(kotlin.jvm.functions.Function2,java.lang.Object,kotlin.coroutines.Continuation); + public static kotlin.coroutines.Continuation intercepted(kotlin.coroutines.Continuation); +} +-keep class kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsKt { + public static java.lang.Object getCOROUTINE_SUSPENDED(); +} +-keep class kotlin.coroutines.jvm.internal.Boxing { + public static java.lang.Boolean boxBoolean(boolean); + public static java.lang.Integer boxInt(int); + public static java.lang.Long boxLong(long); +} +-keep class kotlin.coroutines.jvm.internal.ContinuationImpl { + public (kotlin.coroutines.Continuation); + public (kotlin.coroutines.Continuation,kotlin.coroutines.CoroutineContext); + public kotlin.coroutines.CoroutineContext getContext(); + protected void releaseIntercepted(); +} +-keep interface kotlin.coroutines.jvm.internal.CoroutineStackFrame { + public kotlin.coroutines.jvm.internal.CoroutineStackFrame getCallerFrame(); + public java.lang.StackTraceElement getStackTraceElement(); +} +-keep class kotlin.coroutines.jvm.internal.DebugProbesKt { + public static kotlin.coroutines.Continuation probeCoroutineCreated(kotlin.coroutines.Continuation); + public static void probeCoroutineSuspended(kotlin.coroutines.Continuation); +} +-keep class kotlin.coroutines.jvm.internal.RestrictedSuspendLambda { + public (int,kotlin.coroutines.Continuation); +} +-keep interface kotlin.coroutines.jvm.internal.SuspendFunction { +} +-keep class kotlin.coroutines.jvm.internal.SuspendLambda { + public (int,kotlin.coroutines.Continuation); +} +-keep class kotlin.io.ByteStreamsKt { + public static byte[] readBytes(java.io.InputStream); +} -keep class kotlin.io.CloseableKt { public static void closeFinally(java.io.Closeable,java.lang.Throwable); } +-keep class kotlin.jvm.JvmClassMappingKt { + public static kotlin.reflect.KClass getKotlinClass(java.lang.Class); +} -keep interface kotlin.jvm.functions.Function0 { public java.lang.Object invoke(); } +-keep interface kotlin.jvm.functions.Function1 { + public java.lang.Object invoke(java.lang.Object); +} +-keep interface kotlin.jvm.functions.Function2 { + public java.lang.Object invoke(java.lang.Object,java.lang.Object); +} +-keep interface kotlin.jvm.functions.Function3 { + public java.lang.Object invoke(java.lang.Object,java.lang.Object,java.lang.Object); +} +-keep interface kotlin.jvm.functions.Function4 { + public java.lang.Object invoke(java.lang.Object,java.lang.Object,java.lang.Object,java.lang.Object); +} +-keep interface kotlin.jvm.functions.Function5 { + public java.lang.Object invoke(java.lang.Object,java.lang.Object,java.lang.Object,java.lang.Object,java.lang.Object); +} +-keep interface kotlin.jvm.functions.Function6 { + public java.lang.Object invoke(java.lang.Object,java.lang.Object,java.lang.Object,java.lang.Object,java.lang.Object,java.lang.Object); +} +-keep interface kotlin.jvm.functions.Function7 { + public java.lang.Object invoke(java.lang.Object,java.lang.Object,java.lang.Object,java.lang.Object,java.lang.Object,java.lang.Object,java.lang.Object); +} +-keep class kotlin.jvm.internal.CallableReference { + public (); + protected (java.lang.Object); + java.lang.Object receiver; +} +-keep class kotlin.jvm.internal.DefaultConstructorMarker { +} +-keep class kotlin.jvm.internal.FunctionReferenceImpl { + public (int,java.lang.Class,java.lang.String,java.lang.String,int); + public (int,java.lang.Object,java.lang.Class,java.lang.String,java.lang.String,int); +} +-keep class kotlin.jvm.internal.InlineMarker { + public static void finallyEnd(int); + public static void finallyStart(int); + public static void mark(int); +} -keep class kotlin.jvm.internal.Intrinsics { public static boolean areEqual(java.lang.Object,java.lang.Object); public static void checkNotNull(java.lang.Object); public static void checkNotNull(java.lang.Object,java.lang.String); public static void checkNotNullExpressionValue(java.lang.Object,java.lang.String); public static void checkNotNullParameter(java.lang.Object,java.lang.String); + public static void checkParameterIsNotNull(java.lang.Object,java.lang.String); + public static void needClassReification(); + public static void reifiedOperationMarker(int,java.lang.String); + public static void throwNpe(); + public static void throwUninitializedPropertyAccessException(java.lang.String); } -keep class kotlin.jvm.internal.Lambda { public (int); } +-keep class kotlin.jvm.internal.PropertyReference0Impl { + public (java.lang.Object,java.lang.Class,java.lang.String,java.lang.String,int); + public java.lang.Object get(); +} +-keep class kotlin.jvm.internal.Ref$BooleanRef { + public (); + boolean element; +} +-keep class kotlin.jvm.internal.Ref$IntRef { + public (); + int element; +} +-keep class kotlin.jvm.internal.Ref$LongRef { + public (); + long element; +} +-keep class kotlin.jvm.internal.Ref$ObjectRef { + public (); + java.lang.Object element; +} +-keep class kotlin.jvm.internal.Reflection { + public static kotlin.reflect.KClass getOrCreateKotlinClass(java.lang.Class); +} -keep class kotlin.jvm.internal.StringCompanionObject { kotlin.jvm.internal.StringCompanionObject INSTANCE; } +-keep class kotlin.jvm.internal.TypeIntrinsics { + public static java.lang.Object beforeCheckcastToFunctionOfArity(java.lang.Object,int); +} +-keep interface kotlin.jvm.internal.markers.KMutableIterator { +} +-keep interface kotlin.jvm.internal.markers.KMutableMap$Entry { +} +-keep class kotlin.random.Random { + kotlin.random.Random$Default Default; +} +-keep class kotlin.random.Random$Default { + public int nextInt(); +} +-keep class kotlin.ranges.IntRange { +} +-keep class kotlin.ranges.LongRange { +} +-keep class kotlin.ranges.RangesKt { +} +-keep class kotlin.ranges.RangesKt___RangesKt { + public static int coerceAtLeast(int,int); + public static long coerceAtLeast(long,long); + public static long coerceAtMost(long,long); + public static kotlin.ranges.IntRange until(int,int); +} +-keep interface kotlin.reflect.KClass { + public java.lang.String getSimpleName(); + public boolean isInstance(java.lang.Object); +} +-keep interface kotlin.reflect.KFunction { +} +-keep interface kotlin.sequences.Sequence { + public java.util.Iterator iterator(); +} +-keep class kotlin.sequences.SequenceScope { + public java.lang.Object yield(java.lang.Object,kotlin.coroutines.Continuation); +} +-keep class kotlin.sequences.SequencesKt { +} +-keep class kotlin.sequences.SequencesKt__SequenceBuilderKt { + public static kotlin.sequences.Sequence sequence(kotlin.jvm.functions.Function2); +} +-keep class kotlin.sequences.SequencesKt__SequencesKt { + public static kotlin.sequences.Sequence asSequence(java.util.Iterator); + public static kotlin.sequences.Sequence emptySequence(); +} +-keep class kotlin.sequences.SequencesKt___SequencesKt { + public static kotlin.sequences.Sequence filter(kotlin.sequences.Sequence,kotlin.jvm.functions.Function1); + public static kotlin.sequences.Sequence mapNotNull(kotlin.sequences.Sequence,kotlin.jvm.functions.Function1); + public static kotlin.sequences.Sequence sortedWith(kotlin.sequences.Sequence,java.util.Comparator); + public static java.util.List toList(kotlin.sequences.Sequence); +} +-keep class kotlin.text.StringsKt { +} +-keep class kotlin.text.StringsKt__IndentKt { + public static java.lang.String trimIndent(java.lang.String); +} +-keep class kotlin.text.StringsKt__StringNumberConversionsKt { + public static java.lang.Long toLongOrNull(java.lang.String); +} +-keep class kotlin.text.StringsKt__StringsJVMKt { + public static boolean startsWith$default(java.lang.String,java.lang.String,boolean,int,java.lang.Object); +} +-keep class kotlin.text.StringsKt__StringsKt { + public static int lastIndexOf$default(java.lang.CharSequence,java.lang.String,int,boolean,int,java.lang.Object); + public static java.lang.String substringAfter$default(java.lang.String,java.lang.String,java.lang.String,int,java.lang.Object); + public static java.lang.String substringBefore$default(java.lang.String,char,java.lang.String,int,java.lang.Object); + public static java.lang.String substringBefore$default(java.lang.String,java.lang.String,java.lang.String,int,java.lang.Object); + public static java.lang.CharSequence trim(java.lang.CharSequence); +} +-keep class kotlin.text.StringsKt___StringsKt { + public static char last(java.lang.CharSequence); +} +-keep class kotlin.time.Duration { + public static int compareTo-LRDsOJo(long,long); + public static long getInWholeMilliseconds-impl(long); + public static java.lang.String toString-impl(long); + public long unbox-impl(); + kotlin.time.Duration$Companion Companion; +} +-keep class kotlin.time.Duration$Companion { + public long getINFINITE-UwyO8pc(); + public long getZERO-UwyO8pc(); +} +-keep class kotlin.time.DurationKt { + public static long toDuration(int,kotlin.time.DurationUnit); + public static long toDuration(long,kotlin.time.DurationUnit); +} +-keep enum kotlin.time.DurationUnit { + kotlin.time.DurationUnit MILLISECONDS; + kotlin.time.DurationUnit SECONDS; +} -keep class okio.ByteString { public java.lang.String hex(); okio.ByteString$Companion Companion; @@ -48,4 +422,4 @@ -keep class okio.ByteString$Companion { public okio.ByteString encodeUtf8(java.lang.String); } --keeppackagenames kotlin +-keeppackagenames kotlin,kotlin.collections,kotlin.comparisons,kotlin.coroutines,kotlin.coroutines.intrinsics,kotlin.coroutines.jvm.internal,kotlin.jvm.internal,kotlin.ranges,kotlin.sequences,kotlin.text