From 596a74d288761c0f86217d25fa641ef79449f90a Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Fri, 6 Nov 2015 16:22:21 +0300 Subject: [PATCH] Code cleanup in reflection.jvm, generator scripts --- .../src/kotlin/reflect/exceptions.kt | 2 +- .../src/kotlin/reflect/jvm/KClassesJvm.kt | 2 +- .../reflect/jvm/internal/FunctionCaller.kt | 8 ++--- .../reflect/jvm/internal/KCallableImpl.kt | 2 +- .../kotlin/reflect/jvm/internal/KClassImpl.kt | 34 +++++++++---------- .../jvm/internal/KDeclarationContainerImpl.kt | 18 +++++----- .../internal/KFunctionFromReferenceImpl.kt | 6 ++-- .../reflect/jvm/internal/KFunctionImpl.kt | 2 +- .../reflect/jvm/internal/KPackageImpl.kt | 7 ++-- .../jvm/internal/ReflectProperties.java | 4 +-- .../jvm/internal/ReflectionObjectRenderer.kt | 12 +++---- .../reflect/jvm/internal/RuntimeTypeMapper.kt | 6 ++-- .../reflect/jvm/internal/kClassCache.kt | 8 ++--- .../infrastructure/build-protobuf-lite.kts | 2 +- .../check-library-abi-version.kts | 2 +- .../infrastructure/increment-version.kts | 6 ++-- .../strip-kotlin-annotations.kts | 8 ++--- 17 files changed, 65 insertions(+), 64 deletions(-) diff --git a/core/reflection.jvm/src/kotlin/reflect/exceptions.kt b/core/reflection.jvm/src/kotlin/reflect/exceptions.kt index 996b42ce438..dbac6f3c1c4 100644 --- a/core/reflection.jvm/src/kotlin/reflect/exceptions.kt +++ b/core/reflection.jvm/src/kotlin/reflect/exceptions.kt @@ -24,7 +24,7 @@ package kotlin.reflect * * @see [kotlin.reflect.jvm.isAccessible] */ -public class IllegalCallableAccessException(cause: IllegalAccessException) : Exception(cause.getMessage()) { +public class IllegalCallableAccessException(cause: IllegalAccessException) : Exception(cause.message) { init { @Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN") (this as java.lang.Throwable).initCause(cause) diff --git a/core/reflection.jvm/src/kotlin/reflect/jvm/KClassesJvm.kt b/core/reflection.jvm/src/kotlin/reflect/jvm/KClassesJvm.kt index be8725e98b2..f00d6466baf 100644 --- a/core/reflection.jvm/src/kotlin/reflect/jvm/KClassesJvm.kt +++ b/core/reflection.jvm/src/kotlin/reflect/jvm/KClassesJvm.kt @@ -27,5 +27,5 @@ import kotlin.reflect.jvm.internal.KClassImpl */ public val KClass<*>.jvmName: String get() { - return (this as KClassImpl).jClass.getName() + return (this as KClassImpl).jClass.name } diff --git a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/FunctionCaller.kt b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/FunctionCaller.kt index d9f281b87bd..2adf0e7f7bf 100644 --- a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/FunctionCaller.kt +++ b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/FunctionCaller.kt @@ -36,8 +36,8 @@ internal abstract class FunctionCaller( abstract fun call(args: Array<*>): Any? protected open fun checkArguments(args: Array<*>) { - if (parameterTypes.size() != args.size()) { - throw IllegalArgumentException("Callable expects ${parameterTypes.size()} arguments, but ${args.size()} were provided.") + if (parameterTypes.size != args.size) { + throw IllegalArgumentException("Callable expects ${parameterTypes.size} arguments, but ${args.size} were provided.") } } @@ -95,7 +95,7 @@ internal abstract class FunctionCaller( class InstanceMethod(method: ReflectMethod) : Method(method) { override fun call(args: Array<*>): Any? { checkArguments(args) - return callMethod(args[0], args.asList().subList(1, args.size()).toTypedArray()) + return callMethod(args[0], args.asList().subList(1, args.size).toTypedArray()) } } @@ -103,7 +103,7 @@ internal abstract class FunctionCaller( override fun call(args: Array<*>): Any? { checkArguments(args) checkObjectInstance(args.firstOrNull()) - return callMethod(null, args.asList().subList(1, args.size()).toTypedArray()) + return callMethod(null, args.asList().subList(1, args.size).toTypedArray()) } } diff --git a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KCallableImpl.kt b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KCallableImpl.kt index 9b5433ea64b..9e344bb9d85 100644 --- a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KCallableImpl.kt +++ b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KCallableImpl.kt @@ -68,7 +68,7 @@ internal interface KCallableImpl : KCallable, KAnnotatedElementImpl { // See ArgumentGenerator#generate override fun callBy(args: Map): R { val parameters = parameters - val arguments = ArrayList(parameters.size()) + val arguments = ArrayList(parameters.size) var mask = 0 val masks = ArrayList(1) var index = 0 diff --git a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KClassImpl.kt b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KClassImpl.kt index fc05f54055d..d59a08e0092 100644 --- a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KClassImpl.kt +++ b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KClassImpl.kt @@ -42,7 +42,7 @@ internal class KClassImpl(override val jClass: Class) : KDeclaration val classId = classId val descriptor = - if (classId.isLocal()) moduleData.localClassResolver.resolveLocalClass(classId) + if (classId.isLocal) moduleData.localClassResolver.resolveLocalClass(classId) else moduleData.module.findClassAcrossModuleDependencies(classId) descriptor ?: throw KotlinReflectionInternalError("Class not resolved: $jClass") @@ -67,8 +67,8 @@ internal class KClassImpl(override val jClass: Class) : KDeclaration override val constructorDescriptors: Collection get() { val descriptor = descriptor - if (descriptor.getKind() == ClassKind.CLASS || descriptor.getKind() == ClassKind.ENUM_CLASS) { - return descriptor.getConstructors() + if (descriptor.kind == ClassKind.CLASS || descriptor.kind == ClassKind.ENUM_CLASS) { + return descriptor.constructors } return emptyList() } @@ -76,39 +76,39 @@ internal class KClassImpl(override val jClass: Class) : KDeclaration @Suppress("UNCHECKED_CAST") override fun getProperties(name: Name): Collection = (memberScope.getContributedVariables(name, NoLookupLocation.FROM_REFLECTION) + - staticScope.getContributedVariables(name, NoLookupLocation.FROM_REFLECTION)) as Collection + staticScope.getContributedVariables(name, NoLookupLocation.FROM_REFLECTION)) override fun getFunctions(name: Name): Collection = memberScope.getContributedFunctions(name, NoLookupLocation.FROM_REFLECTION) + staticScope.getContributedFunctions(name, NoLookupLocation.FROM_REFLECTION) override val simpleName: String? get() { - if (jClass.isAnonymousClass()) return null + if (jClass.isAnonymousClass) return null val classId = classId return when { - classId.isLocal() -> calculateLocalClassName(jClass) - else -> classId.getShortClassName().asString() + classId.isLocal -> calculateLocalClassName(jClass) + else -> classId.shortClassName.asString() } } private fun calculateLocalClassName(jClass: Class<*>): String { - val name = jClass.getSimpleName() - jClass.getEnclosingMethod()?.let { method -> - return name.substringAfter(method.getName() + "$") + val name = jClass.simpleName + jClass.enclosingMethod?.let { method -> + return name.substringAfter(method.name + "$") } - jClass.getEnclosingConstructor()?.let { constructor -> - return name.substringAfter(constructor.getName() + "$") + jClass.enclosingConstructor?.let { constructor -> + return name.substringAfter(constructor.name + "$") } return name.substringAfter('$') } override val qualifiedName: String? get() { - if (jClass.isAnonymousClass()) return null + if (jClass.isAnonymousClass) return null val classId = classId return when { - classId.isLocal() -> null + classId.isLocal -> null else -> classId.asSingleFqName().asString() } } @@ -165,9 +165,9 @@ internal class KClassImpl(override val jClass: Class) : KDeclaration override fun toString(): String { return "class " + classId.let { classId -> - val packageFqName = classId.getPackageFqName() - val packagePrefix = if (packageFqName.isRoot()) "" else packageFqName.asString() + "." - val classSuffix = classId.getRelativeClassName().asString().replace('.', '$') + val packageFqName = classId.packageFqName + val packagePrefix = if (packageFqName.isRoot) "" else packageFqName.asString() + "." + val classSuffix = classId.relativeClassName.asString().replace('.', '$') packagePrefix + classSuffix } } diff --git a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KDeclarationContainerImpl.kt b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KDeclarationContainerImpl.kt index 4917f6e10ca..206af23a9c4 100644 --- a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KDeclarationContainerImpl.kt +++ b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KDeclarationContainerImpl.kt @@ -56,9 +56,9 @@ internal abstract class KDeclarationContainerImpl : ClassBasedDeclarationContain fun getMembers(scope: MemberScope, declaredOnly: Boolean, nonExtensions: Boolean, extensions: Boolean): Sequence> { val visitor = object : DeclarationDescriptorVisitorEmptyBodies?, Unit>() { private fun skipCallable(descriptor: CallableMemberDescriptor): Boolean { - if (declaredOnly && !descriptor.getKind().isReal()) return true + if (declaredOnly && !descriptor.kind.isReal) return true - val isExtension = descriptor.getExtensionReceiverParameter() != null + val isExtension = descriptor.extensionReceiverParameter != null if (isExtension && !extensions) return true if (!isExtension && !nonExtensions) return true @@ -80,7 +80,7 @@ internal abstract class KDeclarationContainerImpl : ClassBasedDeclarationContain return scope.getContributedDescriptors().asSequence() .filter { descriptor -> - descriptor !is MemberDescriptor || descriptor.getVisibility() != Visibilities.INVISIBLE_FAKE + descriptor !is MemberDescriptor || descriptor.visibility != Visibilities.INVISIBLE_FAKE } .map { descriptor -> descriptor.accept(visitor, Unit) @@ -115,11 +115,11 @@ internal abstract class KDeclarationContainerImpl : ClassBasedDeclarationContain RuntimeTypeMapper.mapPropertySignature(descriptor).asString() == signature } - if (properties.size() != 1) { + if (properties.size != 1) { val debugText = "'$name' (JVM signature: $signature)" throw KotlinReflectionInternalError( if (properties.isEmpty()) "Property $debugText not resolved in $this" - else "${properties.size()} properties $debugText resolved in $this: $properties" + else "${properties.size} properties $debugText resolved in $this: $properties" ) } @@ -132,11 +132,11 @@ internal abstract class KDeclarationContainerImpl : ClassBasedDeclarationContain RuntimeTypeMapper.mapSignature(descriptor).asString() == signature } - if (functions.size() != 1) { + if (functions.size != 1) { val debugText = "'$name' (JVM signature: $signature)" throw KotlinReflectionInternalError( if (functions.isEmpty()) "Function $debugText not resolved in $this" - else "${functions.size()} functions $debugText resolved in $this: $functions" + else "${functions.size} functions $debugText resolved in $this: $functions" ) } @@ -197,7 +197,7 @@ internal abstract class KDeclarationContainerImpl : ClassBasedDeclarationContain private fun addParametersAndMasks(result: MutableList>, desc: String) { val valueParameters = loadParameterTypes(desc) result.addAll(valueParameters) - repeat((valueParameters.size() + Integer.SIZE - 1) / Integer.SIZE) { + repeat((valueParameters.size + Integer.SIZE - 1) / Integer.SIZE) { result.add(Integer.TYPE) } } @@ -251,7 +251,7 @@ internal abstract class KDeclarationContainerImpl : ClassBasedDeclarationContain ): Field? { val owner = implClassForCallable(nameResolver, proto) ?: if (proto.hasExtension(JvmProtoBuf.propertySignature) && - proto.getExtension(JvmProtoBuf.propertySignature).let { it.hasField() && it.field.getIsStaticInOuter() }) { + proto.getExtension(JvmProtoBuf.propertySignature).let { it.hasField() && it.field.isStaticInOuter }) { jClass.enclosingClass ?: throw KotlinReflectionInternalError("Inconsistent metadata for field $name in $jClass") } else jClass diff --git a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KFunctionFromReferenceImpl.kt b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KFunctionFromReferenceImpl.kt index 39569a80615..edca11c2dab 100644 --- a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KFunctionFromReferenceImpl.kt +++ b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KFunctionFromReferenceImpl.kt @@ -27,11 +27,11 @@ import kotlin.reflect.KotlinReflectionInternalError internal class KFunctionFromReferenceImpl( val reference: FunctionReference ): KFunctionImpl( - reference.getOwner() as? KDeclarationContainerImpl ?: EmptyContainerForLocal, + reference.owner as? KDeclarationContainerImpl ?: EmptyContainerForLocal, reference.name, - reference.getSignature() + reference.signature ) { - override fun getArity() = reference.getArity() + override fun getArity() = reference.arity override val name = reference.name diff --git a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KFunctionImpl.kt b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KFunctionImpl.kt index 570c69cb671..ec4cf465992 100644 --- a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KFunctionImpl.kt +++ b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KFunctionImpl.kt @@ -99,7 +99,7 @@ internal open class KFunctionImpl protected constructor( } override fun getArity(): Int { - return descriptor.valueParameters.size() + + return descriptor.valueParameters.size + (if (descriptor.dispatchReceiverParameter != null) 1 else 0) + (if (descriptor.extensionReceiverParameter != null) 1 else 0) } diff --git a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KPackageImpl.kt b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KPackageImpl.kt index 1e8192ab0d5..fd3559b5d4a 100644 --- a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KPackageImpl.kt +++ b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KPackageImpl.kt @@ -14,6 +14,7 @@ * limitations under the License. */ +@file:Suppress("DEPRECATION") package kotlin.reflect.jvm.internal import org.jetbrains.kotlin.descriptors.ConstructorDescriptor @@ -45,7 +46,7 @@ internal class KPackageImpl(override val jClass: Class<*>, val moduleName: Strin @Suppress("UNCHECKED_CAST") override fun getProperties(name: Name): Collection = - scope.getContributedVariables(name, NoLookupLocation.FROM_REFLECTION) as Collection + scope.getContributedVariables(name, NoLookupLocation.FROM_REFLECTION) override fun getFunctions(name: Name): Collection = scope.getContributedFunctions(name, NoLookupLocation.FROM_REFLECTION) @@ -57,8 +58,8 @@ internal class KPackageImpl(override val jClass: Class<*>, val moduleName: Strin jClass.hashCode() override fun toString(): String { - val name = jClass.getName() - return "package " + if (jClass.isAnnotationPresent(javaClass())) { + val name = jClass.name + return "package " + if (jClass.isAnnotationPresent(KotlinPackage::class.java)) { if (name == "_DefaultPackage") "" else name.substringBeforeLast(".") } else name diff --git a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/ReflectProperties.java b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/ReflectProperties.java index 09ebcd7b04e..0175b1fd5b0 100644 --- a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/ReflectProperties.java +++ b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/ReflectProperties.java @@ -27,8 +27,8 @@ import java.lang.ref.WeakReference; public static abstract class Val { private static final Object NULL_VALUE = new Object() {}; - @SuppressWarnings("UnusedParameters") - public T get(Object instance, Object metadata) { + @SuppressWarnings({"UnusedParameters", "unused"}) + public final T getValue(Object instance, Object metadata) { return invoke(); } diff --git a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/ReflectionObjectRenderer.kt b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/ReflectionObjectRenderer.kt index a993f9d8c69..2bf45cc3a9e 100644 --- a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/ReflectionObjectRenderer.kt +++ b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/ReflectionObjectRenderer.kt @@ -58,17 +58,17 @@ internal object ReflectionObjectRenderer { // TODO: include visibility fun renderProperty(descriptor: PropertyDescriptor): String { - return StringBuilder { + return buildString { append(if (descriptor.isVar) "var " else "val ") appendReceiversAndName(descriptor) append(": ") append(renderType(descriptor.type)) - }.toString() + } } fun renderFunction(descriptor: FunctionDescriptor): String { - return StringBuilder { + return buildString { append("fun ") appendReceiversAndName(descriptor) @@ -78,11 +78,11 @@ internal object ReflectionObjectRenderer { append(": ") append(renderType(descriptor.returnType!!)) - }.toString() + } } fun renderParameter(parameter: KParameterImpl): String { - return StringBuilder { + return buildString { when (parameter.kind) { KParameter.Kind.EXTENSION_RECEIVER -> append("extension receiver") KParameter.Kind.INSTANCE -> append("instance") @@ -91,7 +91,7 @@ internal object ReflectionObjectRenderer { append(" of ") append(renderCallable(parameter.callable.descriptor)) - }.toString() + } } fun renderType(type: KotlinType): String { diff --git a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/RuntimeTypeMapper.kt b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/RuntimeTypeMapper.kt index e0bb56d0c78..fc381c0e6df 100644 --- a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/RuntimeTypeMapper.kt +++ b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/RuntimeTypeMapper.kt @@ -209,7 +209,7 @@ internal object RuntimeTypeMapper { val parameters = function.valueParameters when (function.name.asString()) { - "equals" -> if (parameters.size() == 1 && KotlinBuiltIns.isNullableAny(parameters.single().type)) { + "equals" -> if (parameters.size == 1 && KotlinBuiltIns.isNullableAny(parameters.single().type)) { return JvmFunctionSignature.BuiltInFunction.Predefined("equals(Ljava/lang/Object;)Z", Any::class.java.getDeclaredMethod("equals", Any::class.java)) } @@ -240,7 +240,7 @@ internal object RuntimeTypeMapper { } val classId = klass.classId - if (!classId.isLocal()) { + if (!classId.isLocal) { JavaToKotlinClassMap.INSTANCE.mapJavaToKotlin(classId.asSingleFqName())?.let { return it.classId } } @@ -248,5 +248,5 @@ internal object RuntimeTypeMapper { } private val Class<*>.primitiveType: PrimitiveType? - get() = if (isPrimitive()) JvmPrimitiveType.get(getSimpleName()).getPrimitiveType() else null + get() = if (isPrimitive) JvmPrimitiveType.get(simpleName).primitiveType else null } diff --git a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/kClassCache.kt b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/kClassCache.kt index a6e12f62199..12e7aacba9b 100644 --- a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/kClassCache.kt +++ b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/kClassCache.kt @@ -17,7 +17,6 @@ package kotlin.reflect.jvm.internal import java.lang.ref.WeakReference -import kotlin.reflect.KClass import kotlin.reflect.jvm.internal.pcollections.HashPMap // TODO: collect nulls periodically @@ -29,7 +28,7 @@ private var K_CLASS_CACHE = HashPMap.empty() // This function is invoked on each reflection access to Java classes, properties, etc. Performance is critical here. internal fun getOrCreateKotlinClass(jClass: Class): KClassImpl { - val name = jClass.getName() + val name = jClass.name val cached = K_CLASS_CACHE[name] if (cached is WeakReference<*>) { @Suppress("UNCHECKED_CAST") @@ -40,7 +39,8 @@ internal fun getOrCreateKotlinClass(jClass: Class): KClassImpl { } else if (cached != null) { // If the cached value is not a weak reference, it's an array of weak references - cached as Array>> + @Suppress("UNCHECKED_CAST") + (cached as Array>>) for (ref in cached) { val kClass = ref.get() if (kClass?.jClass == jClass) { @@ -50,7 +50,7 @@ internal fun getOrCreateKotlinClass(jClass: Class): KClassImpl { // This is the most unlikely case: we found a cached array of references of length at least 2 (can't be 1 because // the single element would be cached instead), and none of those classes is the one we're looking for - val size = cached.size() + val size = cached.size // Don't use Array constructor because it creates a lambda val newArray = arrayOfNulls>>(size + 1) // Don't use Arrays.copyOf because it works reflectively diff --git a/generators/infrastructure/build-protobuf-lite.kts b/generators/infrastructure/build-protobuf-lite.kts index d39b5fa2c06..200d3bdfc6f 100644 --- a/generators/infrastructure/build-protobuf-lite.kts +++ b/generators/infrastructure/build-protobuf-lite.kts @@ -21,7 +21,7 @@ fun main(args: Array) { val INCLUDE_END = ".java" val POM_PATH = "META-INF/maven/com.google.protobuf/protobuf-java/pom.xml" - if (args.size() != 2) { + if (args.size != 2) { error("Usage: kotlinc -script build-protobuf-lite.kts ") } diff --git a/generators/infrastructure/check-library-abi-version.kts b/generators/infrastructure/check-library-abi-version.kts index c45f5beded3..e7ad69118aa 100644 --- a/generators/infrastructure/check-library-abi-version.kts +++ b/generators/infrastructure/check-library-abi-version.kts @@ -67,7 +67,7 @@ fun loadVersion(library: File): IntArray { } fun main(args: Array) { - if (args.size() != 2) { + if (args.size != 2) { error("Usage: kotlinc -script check-library-abi-version.kts ") } diff --git a/generators/infrastructure/increment-version.kts b/generators/infrastructure/increment-version.kts index cf2e7f521b1..f9d6e6f0b4a 100644 --- a/generators/infrastructure/increment-version.kts +++ b/generators/infrastructure/increment-version.kts @@ -22,7 +22,7 @@ import java.io.File fun main(args: Array) { val filePathDefault = "updated-version.txt" - if (args.isEmpty() || args.size() > 2) { + if (args.isEmpty() || args.size > 2) { error("Usage: kotlinc -script increment-version.kts " + " " + "") @@ -31,7 +31,7 @@ fun main(args: Array) { var versionStr = args[0] val incrementPartStr = versionStr.takeLastWhile { it.isDigit() } - val versionPrefix = versionStr.take(versionStr.length() - incrementPartStr.length()) + val versionPrefix = versionStr.take(versionStr.length - incrementPartStr.length) val incrementPart = incrementPartStr.toInt() var filePath = args.getOrNull(1) ?: filePathDefault @@ -43,4 +43,4 @@ fun main(args: Array) { File("$filePath").writeText("$result") } -main(args) \ No newline at end of file +main(args) diff --git a/generators/infrastructure/strip-kotlin-annotations.kts b/generators/infrastructure/strip-kotlin-annotations.kts index 3cd3c8da9ff..10ae346c387 100644 --- a/generators/infrastructure/strip-kotlin-annotations.kts +++ b/generators/infrastructure/strip-kotlin-annotations.kts @@ -27,7 +27,7 @@ import java.util.zip.ZipOutputStream */ fun main(args: Array) { - if (args.size() != 4) { + if (args.size != 4) { error("Usage: kotlinc -script strip-kotlin-annotations.kts ") } @@ -70,8 +70,8 @@ fun main(args: Array) { val inBytes = inJar.getInputStream(entry).readBytes() val outBytes = transform(entry.getName(), inBytes) - if (inBytes.size() < outBytes.size()) { - error("Size increased for ${entry.getName()}: was ${inBytes.size()} bytes, became ${outBytes.size()} bytes") + if (inBytes.size < outBytes.size) { + error("Size increased for ${entry.getName()}: was ${inBytes.size} bytes, became ${outBytes.size} bytes") } entry.setCompressedSize(-1L) @@ -90,4 +90,4 @@ fun main(args: Array) { println("Output file size: ${outFile.length()} bytes") } -main(args) \ No newline at end of file +main(args)