Cleanup in compiler modules

compiler/backend-common/src/org/jetbrains/kotlin/backend/common/CodegenUtilKt.kt

@@ -67,7 +67,7 @@ public object CodegenUtilKt {
                             }
                             else null
                         }
-                assert(actualDelegates.size() <= 1) { "Many delegates found for $delegatingMember: $actualDelegates" }
+                assert(actualDelegates.size <= 1) { "Many delegates found for $delegatingMember: $actualDelegates" }
 
                 actualDelegates.firstOrNull()
             }

compiler/backend-common/src/org/jetbrains/kotlin/backend/common/bridges/bridges.kt

@@ -109,7 +109,7 @@ public fun <Function : FunctionHandle> findConcreteSuperDeclaration(function: Fu
     result.removeAll(toRemove)
 
     val concreteRelevantDeclarations = result.filter { !it.isAbstract }
-    if (concreteRelevantDeclarations.size() != 1) {
+    if (concreteRelevantDeclarations.size != 1) {
         error("Concrete fake override $function should have exactly one concrete super-declaration: $concreteRelevantDeclarations")
     }
 

compiler/backend/src/org/jetbrains/kotlin/codegen/ArgumentGenerator.kt

@@ -32,8 +32,8 @@ abstract class ArgumentGenerator {
      * @see kotlin.reflect.jvm.internal.KCallableImpl.callBy
      */
     open fun generate(valueArgumentsByIndex: List<ResolvedValueArgument>, actualArgs: List<ResolvedValueArgument>): DefaultCallMask {
-        assert(valueArgumentsByIndex.size() == actualArgs.size()) {
-            "Value arguments collection should have same size, but ${valueArgumentsByIndex.size()} != ${actualArgs.size()}"
+        assert(valueArgumentsByIndex.size == actualArgs.size) {
+            "Value arguments collection should have same size, but ${valueArgumentsByIndex.size} != ${actualArgs.size}"
         }
 
         val arg2Index = valueArgumentsByIndex.mapToIndex()
@@ -48,7 +48,7 @@ abstract class ArgumentGenerator {
             }
         }
 
-        val masks = DefaultCallMask(valueArgumentsByIndex.size())
+        val masks = DefaultCallMask(valueArgumentsByIndex.size)
 
         for (argumentWithDeclIndex in actualArgsWithDeclIndex) {
             val argument = argumentWithDeclIndex.arg

compiler/backend/src/org/jetbrains/kotlin/codegen/CollectionStubMethodGenerator.kt

@@ -214,7 +214,7 @@ class CollectionStubMethodGenerator(
     private fun Collection<KotlinType>.findMostSpecificTypeForClass(klass: ClassDescriptor): KotlinType {
         val types = this.filter { it.getConstructor().getDeclarationDescriptor() == klass }
         if (types.isEmpty()) error("No supertype of $klass in $this")
-        if (types.size() == 1) return types.first()
+        if (types.size == 1) return types.first()
         // Find the first type in the list such that it's a subtype of every other type in that list
         return types.first { type ->
             types.all { other -> KotlinTypeChecker.DEFAULT.isSubtypeOf(type, other) }
@@ -227,7 +227,7 @@ class CollectionStubMethodGenerator(
         child.setModality(Modality.FINAL)
         child.setVisibility(Visibilities.PUBLIC)
         val typeParameters = descriptor.getTypeConstructor().getParameters()
-        val newTypeParameters = ArrayList<TypeParameterDescriptor>(typeParameters.size())
+        val newTypeParameters = ArrayList<TypeParameterDescriptor>(typeParameters.size)
         DescriptorSubstitutor.substituteTypeParameters(typeParameters, TypeSubstitution.EMPTY, child, newTypeParameters)
         child.setTypeParameterDescriptors(typeParameters)
         return Pair(child, newTypeParameters)

compiler/backend/src/org/jetbrains/kotlin/codegen/InlineCycleReporter.kt

@@ -32,9 +32,9 @@ public class InlineCycleReporter(val diagnostics: DiagnosticSink) {
         if (call != null) {
             val callElement = call.getCall().getCallElement()
             if (processingFunctions.contains(callElement)) {
-                val cycle = processingFunctions.asSequence().dropWhile { it.getKey() != callElement }
+                val cycle = processingFunctions.asSequence().dropWhile { it.key != callElement }
                 cycle.forEach {
-                    diagnostics.report(Errors.INLINE_CALL_CYCLE.on(it.getKey(), it.getValue()))
+                    diagnostics.report(Errors.INLINE_CALL_CYCLE.on(it.key, it.value))
                 }
                 return false
             }

compiler/backend/src/org/jetbrains/kotlin/codegen/InterfaceImplBodyCodegen.kt

@@ -123,7 +123,7 @@ public class InterfaceImplBodyCodegen(
                         val myParameters = signature.getValueParameters()
                         val calleeParameters = method.getValueParameters()
 
-                        if (myParameters.size() != calleeParameters.size()) {
+                        if (myParameters.size != calleeParameters.size) {
                             throw AssertionError(
                                     "Method from super interface has a different signature.\n" +
                                     "This method:\n%s\n%s\n%s\nSuper method:\n%s\n%s\n%s".format(

compiler/backend/src/org/jetbrains/kotlin/codegen/MultifileClassCodegen.kt

@@ -312,7 +312,7 @@ public class MultifileClassCodegen(
                     fragments.add(fragment)
                 }
             }
-            if (fragments.size() > 1) {
+            if (fragments.size > 1) {
                 throw IllegalStateException("More than one package fragment, files: $files | fragments: $fragments")
             }
             return fragments.firstOrNull()

compiler/backend/src/org/jetbrains/kotlin/codegen/SignatureCollectingClassBuilderFactory.kt

@@ -67,7 +67,7 @@ public abstract class SignatureCollectingClassBuilderFactory(
 
         override fun done() {
             for ((signature, elementsAndDescriptors) in signatures.entrySet()) {
-                if (elementsAndDescriptors.size() == 1) continue // no clash
+                if (elementsAndDescriptors.size == 1) continue // no clash
                 handleClashingSignatures(ConflictingJvmDeclarationsData(
                         classInternalName,
                         classCreatedFor,

compiler/backend/src/org/jetbrains/kotlin/codegen/classFileUtils.kt

@@ -47,7 +47,7 @@ private fun List<PackageParts>.addCompiledParts(state: GenerationState): List<Pa
         mapping.findPackageParts(qualifier)?.run { parts.remove(name) }
     }
 
-    return (this + mapping.packageFqName2Parts.values())
+    return (this + mapping.packageFqName2Parts.values)
             .groupBy { it.packageFqName }
             .map {
                 val (packageFqName, packageParts) = it

compiler/backend/src/org/jetbrains/kotlin/codegen/context/DefaultImplsClassContext.kt

@@ -38,7 +38,7 @@ class DefaultImplsClassContext(
     override fun getAccessors(): Collection<AccessorForCallableDescriptor<*>> {
         val accessors = super.getAccessors()
         val alreadyExistKeys = accessors.map ({ Pair(it.calleeDescriptor, it.superCallTarget) })
-        val filtered = interfaceContext.accessors.toMap ({ Pair(it.calleeDescriptor, it.superCallTarget) }, {it}) - alreadyExistKeys
+        val filtered = interfaceContext.accessors.toMapBy({ Pair(it.calleeDescriptor, it.superCallTarget) }, { it }) - alreadyExistKeys
         return accessors + filtered.values
     }
 }

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/Parameters.kt

@@ -54,10 +54,10 @@ internal class Parameters(val real: List<ParameterInfo>, val captured: List<Capt
     }
 
     private fun get(index: Int): ParameterInfo {
-        if (index < real.size()) {
+        if (index < real.size) {
             return real.get(index)
         }
-        return captured.get(index - real.size())
+        return captured.get(index - real.size)
     }
 
     override fun iterator(): Iterator<ParameterInfo> {

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/ParametersBuilder.kt

@@ -35,18 +35,18 @@ internal class ParametersBuilder private constructor(){
     private var nextCaptured = 0
 
     fun addThis(type: Type, skipped: Boolean): ParameterInfo {
-        val info = ParameterInfo(type, skipped, nextValueParameterIndex, -1, valueAndHiddenParams.size())
+        val info = ParameterInfo(type, skipped, nextValueParameterIndex, -1, valueAndHiddenParams.size)
         addParameter(info)
         return info
     }
 
     fun addNextParameter(type: Type, skipped: Boolean, remapValue: StackValue?): ParameterInfo {
-        return addParameter(ParameterInfo(type, skipped, nextValueParameterIndex, remapValue, valueAndHiddenParams.size()))
+        return addParameter(ParameterInfo(type, skipped, nextValueParameterIndex, remapValue, valueAndHiddenParams.size))
     }
 
     fun addNextValueParameter(type: Type, skipped: Boolean, remapValue: StackValue?, parameterIndex: Int): ParameterInfo {
         return addParameter(ParameterInfo(type, skipped, nextValueParameterIndex, remapValue,
-                                          if (parameterIndex == -1) valueAndHiddenParams.size() else { parameterIndex + valueParamStart }))
+                                          if (parameterIndex == -1) valueAndHiddenParams.size else { parameterIndex + valueParamStart }))
     }
 
     fun addCapturedParam(
@@ -102,7 +102,7 @@ internal class ParametersBuilder private constructor(){
     }
 
     fun markValueParametesStart(){
-        this.valueParamStart = valueAndHiddenParams.size()
+        this.valueParamStart = valueAndHiddenParams.size
     }
 
     fun listCaptured(): List<CapturedParamInfo> {

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/SMAP.kt

@@ -202,7 +202,7 @@ public open class DefaultSourceMapper(val sourceInfo: SourceInfo, override val p
     private fun createKey(name: String, path: String) = "$name#$path"
 
     override val resultMappings: List<FileMapping>
-        get() = fileMappings.values().map { it.toFileMapping() }
+        get() = fileMappings.values.map { it.toFileMapping() }
 
     override fun visitSource(name: String, path: String) {
         lastVisited = fileMappings.getOrPut(createKey(name, path), { RawFileMapping(name, path) })

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/SMAPParser.kt

@@ -44,7 +44,7 @@ object SMAPParser {
     public fun parse(mappingInfo: String): SMAP {
         val fileMappings = linkedMapOf<Int, FileMapping>()
 
-        val fileSectionStart = mappingInfo.indexOf(SMAP.FILE_SECTION) + SMAP.FILE_SECTION.length()
+        val fileSectionStart = mappingInfo.indexOf(SMAP.FILE_SECTION) + SMAP.FILE_SECTION.length
         val lineSectionAnchor = mappingInfo.indexOf(SMAP.LINE_SECTION)
         val files = mappingInfo.substring(fileSectionStart, lineSectionAnchor)
 
@@ -63,7 +63,7 @@ object SMAPParser {
         }
 
 
-        val lines = mappingInfo.substring(lineSectionAnchor + SMAP.LINE_SECTION.length(), mappingInfo.indexOf(SMAP.END)).trim().split('\n')
+        val lines = mappingInfo.substring(lineSectionAnchor + SMAP.LINE_SECTION.length, mappingInfo.indexOf(SMAP.END)).trim().split('\n')
         for (lineMapping in lines) {
             /*only simple mapping now*/
             val targetSplit = lineMapping.indexOf(':')
@@ -79,6 +79,6 @@ object SMAPParser {
             fileMappings[fileIndex]!!.addRangeMapping(RangeMapping(originalIndex, targetIndex, range))
         }
 
-        return SMAP(fileMappings.values().toList())
+        return SMAP(fileMappings.values.toList())
     }
 }

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/TryBlockClustering.kt

@@ -97,5 +97,5 @@ fun <T : IntervalWithHandler> doClustering(blocks: List<T>): List<TryBlockCluste
         cluster.blocks.add(block)
     }
 
-    return clusters.values().toList()
+    return clusters.values.toList()
 }

compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/BinaryOp.kt

@@ -31,7 +31,7 @@ public class BinaryOp(private val opcode: Int) : IntrinsicMethod() {
 
     override fun toCallable(method: CallableMethod): Callable {
         val returnType = method.returnType
-        assert(method.getValueParameters().size() == 1)
+        assert(method.getValueParameters().size == 1)
         val operandType = numberFunctionOperandType(returnType)
         val paramType = if (shift()) Type.INT_TYPE else operandType
 

compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/IsArrayOf.kt

@@ -32,7 +32,7 @@ class IsArrayOf : IntrinsicMethod() {
         val method = typeMapper.mapToCallableMethod(fd, false)
 
         val builtIns = fd.module.builtIns
-        val elementType = typeArguments.values().first()
+        val elementType = typeArguments.values.first()
         val arrayKtType = builtIns.getArrayType(Variance.INVARIANT, elementType)
         val arrayType = typeMapper.mapType(arrayKtType)
 

compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/JavaClassFunction.kt

@@ -28,7 +28,7 @@ import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
 public class JavaClassFunction : IntrinsicMethod() {
     override fun toCallable(fd: FunctionDescriptor, isSuper: Boolean, resolvedCall: ResolvedCall<*>, codegen: ExpressionCodegen): Callable {
         val javaClass = resolvedCall.getResultingDescriptor().getReturnType()!!.getArguments().first().getType()
-        return object : IntrinsicCallable(getType(javaClass<Class<Any>>()), listOf(), null, null) {
+        return object : IntrinsicCallable(getType(Class::class.java), listOf(), null, null) {
             override fun invokeIntrinsic(v: InstructionAdapter) {
                 codegen.putReifiedOperationMarkerIfTypeIsReifiedParameter(javaClass, ReifiedTypeInliner.OperationKind.JAVA_CLASS)
                 putJavaLangClassInstance(v, codegen.getState().typeMapper.mapType(javaClass))

compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/JavaClassProperty.kt

@@ -54,12 +54,12 @@ public class JavaClassProperty : IntrinsicPropertyGetter() {
             v.invokevirtual("java/lang/Object", "getClass", "()Ljava/lang/Class;", false)
         }
 
-        return getType(javaClass<Class<Any>>())
+        return getType(Class::class.java)
     }
 
     override fun toCallable(fd: FunctionDescriptor, isSuper: Boolean, resolvedCall: ResolvedCall<*>, codegen: ExpressionCodegen): Callable {
         val classType = codegen.getState().typeMapper.mapType(resolvedCall.getCall().getDispatchReceiver()!!.getType())
-        return object : IntrinsicCallable(getType(javaClass<Class<Any>>()), listOf(), classType, null) {
+        return object : IntrinsicCallable(getType(Class::class.java), listOf(), classType, null) {
             override fun invokeIntrinsic(v: InstructionAdapter) {
                 if (isPrimitive(classType)) {
                     v.getstatic(boxType(classType).getInternalName(), "TYPE", "Ljava/lang/Class;")

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/common/MethodAnalyzer.kt

@@ -110,10 +110,10 @@ public open class MethodAnalyzer<V : Value>(
 
             }
             catch (e: AnalyzerException) {
-                throw AnalyzerException(e.node, "Error at instruction " + insn + ": " + e.getMessage(), e)
+                throw AnalyzerException(e.node, "Error at instruction " + insn + ": " + e.message, e)
             }
             catch (e: Exception) {
-                throw AnalyzerException(insnNode, "Error at instruction " + insn + ": " + e.getMessage(), e)
+                throw AnalyzerException(insnNode, "Error at instruction " + insn + ": " + e.message, e)
             }
 
         }

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/fixStack/AnalyzeTryCatchBlocks.kt

@@ -71,7 +71,7 @@ private fun insertSaveRestoreStackMarkers(
     val doneTryStartLabels = hashSetOf<LabelNode>()
     val doneHandlerLabels = hashSetOf<LabelNode>()
 
-    for (decompiledTryDescriptor in decompiledTryDescriptorForStart.values()) {
+    for (decompiledTryDescriptor in decompiledTryDescriptorForStart.values) {
         with(decompiledTryDescriptor) {
             if (!doneTryStartLabels.contains(tryStartLabel)) {
                 doneTryStartLabels.add(tryStartLabel)

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/fixStack/FixStackAnalyzer.kt

@@ -96,7 +96,7 @@ internal class FixStackAnalyzer(
             }
             else {
                 extraStack.add(value)
-                maxExtraStackSize = Math.max(maxExtraStackSize, extraStack.size())
+                maxExtraStackSize = Math.max(maxExtraStackSize, extraStack.size)
             }
         }
 

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/fixStack/FixStackContext.kt

@@ -107,7 +107,7 @@ internal class FixStackContext(val methodNode: MethodNode) {
         if (saveNodes.isEmpty()) {
             throw AssertionError("${indexOf(insnNode)}: in handler ${indexOf(restoreLabel)} restore is not matched with save")
         }
-        else if (saveNodes.size() > 1) {
+        else if (saveNodes.size > 1) {
             throw AssertionError("${indexOf(insnNode)}: in handler ${indexOf(restoreLabel)} restore is matched with several saves")
         }
         val saveNode = saveNodes.first()

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/fixStack/LocalVariablesManager.kt

@@ -39,7 +39,7 @@ internal class LocalVariablesManager(val context: FixStackContext, val methodNod
     }
 
     fun allocateVariablesForSaveStackMarker(saveStackMarker: AbstractInsnNode, savedStackValues: List<BasicValue>): SavedStackDescriptor {
-        val numRestoreStackMarkers = context.restoreStackMarkersForSaveMarker[saveStackMarker]!!.size()
+        val numRestoreStackMarkers = context.restoreStackMarkersForSaveMarker[saveStackMarker]!!.size
         return allocateNewHandle(numRestoreStackMarkers, saveStackMarker, savedStackValues)
     }
 
@@ -58,7 +58,7 @@ internal class LocalVariablesManager(val context: FixStackContext, val methodNod
     }
 
     private fun getFirstUnusedLocalVariableIndex(): Int =
-            allocatedHandles.values().fold(initialMaxLocals) {
+            allocatedHandles.values.fold(initialMaxLocals) {
                 index, handle -> Math.max(index, handle.savedStackDescriptor.firstUnusedLocalVarIndex)
             }
 

compiler/backend/src/org/jetbrains/kotlin/codegen/serialization/JvmStringTable.kt

@@ -38,7 +38,7 @@ class JvmStringTable(private val typeMapper: JetTypeMapper) : StringTable {
 
     override fun getStringIndex(string: String): Int =
             map.getOrPut(string) {
-                strings.size().apply {
+                strings.size.apply {
                     strings.add(string)
 
                     val lastRecord = records.lastOrNull()
@@ -78,7 +78,7 @@ class JvmStringTable(private val typeMapper: JetTypeMapper) : StringTable {
             }
         }
 
-        val index = strings.size()
+        val index = strings.size
         if (classId.isLocal) {
             localNames.add(index)
         }

compiler/backend/src/org/jetbrains/kotlin/codegen/state/typeMappingUtil.kt

@@ -76,7 +76,7 @@ val CallableDescriptor?.isMethodWithDeclarationSiteWildcards: Boolean
     get() {
         if (this !is CallableMemberDescriptor) return false
         return firstOverridden {
-            METHODS_WITH_DECLARATION_SITE_WILDCARDS.containsRaw(it.propertyIfAccessor.fqNameOrNull())
+            METHODS_WITH_DECLARATION_SITE_WILDCARDS.contains(it.propertyIfAccessor.fqNameOrNull())
         } != null
     }
 

compiler/cli/cli-runner/src/org/jetbrains/kotlin/runner/Main.kt

@@ -41,7 +41,7 @@ public object Main {
         classpath.add(".")
 
         var i = 0
-        while (i < args.size()) {
+        while (i < args.size) {
             val arg = args[i]
             if (collectingArguments) {
                 arguments.add(arg)
@@ -50,7 +50,7 @@ public object Main {
             }
 
             fun next(): String {
-                if (++i == args.size()) {
+                if (++i == args.size) {
                     throw RunnerException("argument expected to $arg")
                 }
                 return args[i]
@@ -105,7 +105,7 @@ public object Main {
             run(args)
         }
         catch (e: RunnerException) {
-            System.err.println("error: " + e.getMessage())
+            System.err.println("error: " + e.message)
             System.exit(1)
         }
     }

compiler/cli/cli-runner/src/org/jetbrains/kotlin/runner/runners.kt

@@ -85,7 +85,7 @@ class JarRunner(private val path: String) : AbstractRunner() {
                 }
             }
             catch (e: IOException) {
-                throw RunnerException("could not read manifest from " + path + ": " + e.getMessage())
+                throw RunnerException("could not read manifest from " + path + ": " + e.message)
             }
             ?: throw RunnerException("no Main-Class entry found in manifest in $path")
 

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/K2JVMCompiler.kt

@@ -61,11 +61,11 @@ public open class K2JVMCompiler : CLICompiler<K2JVMCompilerArguments>() {
         configuration.put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, messageSeverityCollector)
 
         if (IncrementalCompilation.isEnabled()) {
-            val incrementalCompilationComponents = services.get(javaClass<IncrementalCompilationComponents>())
+            val incrementalCompilationComponents = services.get(IncrementalCompilationComponents::class.java)
             configuration.put(JVMConfigurationKeys.INCREMENTAL_COMPILATION_COMPONENTS, incrementalCompilationComponents)
         }
 
-        val locator = services.get(javaClass<CompilerJarLocator>())
+        val locator = services.get(CompilerJarLocator::class.java)
         configuration.put(JVMConfigurationKeys.COMPILER_JAR_LOCATOR, locator)
 
         try {
@@ -83,12 +83,12 @@ public open class K2JVMCompiler : CLICompiler<K2JVMCompilerArguments>() {
             PluginCliParser.loadPlugins(arguments, configuration)
         }
         catch (e: PluginCliOptionProcessingException) {
-            val message = e.getMessage() + "\n\n" + cliPluginUsageString(e.pluginId, e.options)
+            val message = e.message + "\n\n" + cliPluginUsageString(e.pluginId, e.options)
             messageSeverityCollector.report(CompilerMessageSeverity.ERROR, message, CompilerMessageLocation.NO_LOCATION)
             return INTERNAL_ERROR
         }
         catch (e: CliOptionProcessingException) {
-            messageSeverityCollector.report(CompilerMessageSeverity.ERROR, e.getMessage()!!, CompilerMessageLocation.NO_LOCATION)
+            messageSeverityCollector.report(CompilerMessageSeverity.ERROR, e.message!!, CompilerMessageLocation.NO_LOCATION)
             return INTERNAL_ERROR
         }
         catch (t: Throwable) {
@@ -169,7 +169,7 @@ public open class K2JVMCompiler : CLICompiler<K2JVMCompilerArguments>() {
                 KotlinToJVMBytecodeCompiler.compileModules(environment, configuration, moduleScript.getModules(), directory, jar, friendPaths, arguments.includeRuntime)
             }
             else if (arguments.script) {
-                val scriptArgs = arguments.freeArgs.subList(1, arguments.freeArgs.size())
+                val scriptArgs = arguments.freeArgs.subList(1, arguments.freeArgs.size)
                 environment = createCoreEnvironment(rootDisposable, configuration)
 
                 if (messageSeverityCollector.anyReported(CompilerMessageSeverity.ERROR)) return COMPILATION_ERROR

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/PluginCliParser.kt

@@ -38,7 +38,7 @@ public object PluginCliParser {
                 javaClass.getClassLoader()
         )
 
-        val componentRegistrars = ServiceLoader.load(javaClass<ComponentRegistrar>(), classLoader).toArrayList()
+        val componentRegistrars = ServiceLoader.load(ComponentRegistrar::class.java, classLoader).toArrayList()
         componentRegistrars.addAll(BundledCompilerPlugins.componentRegistrars)
         configuration.addAll(ComponentRegistrar.PLUGIN_COMPONENT_REGISTRARS, componentRegistrars)
 
@@ -55,7 +55,7 @@ public object PluginCliParser {
             it.pluginId
         } ?: mapOf()
 
-        val commandLineProcessors = ServiceLoader.load(javaClass<CommandLineProcessor>(), classLoader).toArrayList()
+        val commandLineProcessors = ServiceLoader.load(CommandLineProcessor::class.java, classLoader).toArrayList()
         commandLineProcessors.addAll(BundledCompilerPlugins.commandLineProcessors)
 
         for (processor in commandLineProcessors) {
@@ -78,7 +78,7 @@ public object PluginCliParser {
                             processor.pluginOptions,
                             "Required plugin option not present: ${processor.pluginId}:${option.name}")
                 }
-                if (!option.allowMultipleOccurrences && values.size() > 1) {
+                if (!option.allowMultipleOccurrences && values.size > 1) {
                     throw PluginCliOptionProcessingException(
                             processor.pluginId,
                             processor.pluginOptions,

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreEnvironment.kt

@@ -119,14 +119,14 @@ public class KotlinCoreEnvironment private constructor(
 
     init {
         val project = projectEnvironment.getProject()
-        project.registerService(javaClass<DeclarationProviderFactoryService>(), CliDeclarationProviderFactoryService(sourceFiles))
+        project.registerService(DeclarationProviderFactoryService::class.java, CliDeclarationProviderFactoryService(sourceFiles))
         project.registerService(ModuleVisibilityManager::class.java, CliModuleVisibilityManagerImpl())
 
         registerProjectServicesForCLI(projectEnvironment)
         registerProjectServices(projectEnvironment)
 
         fillClasspath(configuration)
-        val fileManager = ServiceManager.getService(project, javaClass<CoreJavaFileManager>())
+        val fileManager = ServiceManager.getService(project, CoreJavaFileManager::class.java)
         val index = JvmDependenciesIndex(javaRoots)
         (fileManager as KotlinCliJavaFileManagerImpl).initIndex(index)
 
@@ -142,7 +142,7 @@ public class KotlinCoreEnvironment private constructor(
 
         KotlinScriptDefinitionProvider.getInstance(project).setScriptDefinitions(configuration.getList(CommonConfigurationKeys.SCRIPT_DEFINITIONS_KEY))
 
-        project.registerService(javaClass<JvmVirtualFileFinderFactory>(), JvmCliVirtualFileFinderFactory(index))
+        project.registerService(JvmVirtualFileFinderFactory::class.java, JvmCliVirtualFileFinderFactory(index))
 
         ExternalDeclarationsProvider.registerExtensionPoint(project)
         ExpressionCodegenExtension.registerExtensionPoint(project)
@@ -342,16 +342,16 @@ public class KotlinCoreEnvironment private constructor(
         }
 
         private fun registerAppExtensionPoints() {
-            CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), BinaryFileStubBuilders.EP_NAME, javaClass<FileTypeExtensionPoint<Any>>())
-            CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), FileContextProvider.EP_NAME, javaClass<FileContextProvider>())
+            CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), BinaryFileStubBuilders.EP_NAME, FileTypeExtensionPoint::class.java)
+            CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), FileContextProvider.EP_NAME, FileContextProvider::class.java)
             //
-            CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), MetaDataContributor.EP_NAME, javaClass<MetaDataContributor>())
-            CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), PsiAugmentProvider.EP_NAME, javaClass<PsiAugmentProvider>())
-            CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), JavaMainMethodProvider.EP_NAME, javaClass<JavaMainMethodProvider>())
+            CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), MetaDataContributor.EP_NAME, MetaDataContributor::class.java)
+            CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), PsiAugmentProvider.EP_NAME, PsiAugmentProvider::class.java)
+            CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), JavaMainMethodProvider.EP_NAME, JavaMainMethodProvider::class.java)
             //
-            CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), ContainerProvider.EP_NAME, javaClass<ContainerProvider>())
-            CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), ClsCustomNavigationPolicy.EP_NAME, javaClass<ClsCustomNavigationPolicy>())
-            CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), ClassFileDecompilers.EP_NAME, javaClass<ClassFileDecompilers.Decompiler>())
+            CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), ContainerProvider.EP_NAME, ContainerProvider::class.java)
+            CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), ClsCustomNavigationPolicy.EP_NAME, ClsCustomNavigationPolicy::class.java)
+            CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), ClassFileDecompilers.EP_NAME, ClassFileDecompilers.Decompiler::class.java)
         }
 
         private fun registerApplicationExtensionPointsAndExtensionsFrom(configuration: CompilerConfiguration, configFilePath: String) {
@@ -384,40 +384,40 @@ public class KotlinCoreEnvironment private constructor(
                 registerFileType(KotlinFileType.INSTANCE, "kt")
                 registerFileType(KotlinFileType.INSTANCE, KotlinParserDefinition.STD_SCRIPT_SUFFIX)
                 registerParserDefinition(KotlinParserDefinition())
-                getApplication().registerService(javaClass<KotlinBinaryClassCache>(), KotlinBinaryClassCache())
-                getApplication().registerService(javaClass<JavaClassSupers>(), javaClass<JavaClassSupersImpl>())
+                getApplication().registerService(KotlinBinaryClassCache::class.java, KotlinBinaryClassCache())
+                getApplication().registerService(JavaClassSupers::class.java, JavaClassSupersImpl::class.java)
             }
         }
 
         private fun registerProjectExtensionPoints(area: ExtensionsArea) {
-            CoreApplicationEnvironment.registerExtensionPoint(area, PsiTreeChangePreprocessor.EP_NAME, javaClass<PsiTreeChangePreprocessor>())
-            CoreApplicationEnvironment.registerExtensionPoint(area, PsiElementFinder.EP_NAME, javaClass<PsiElementFinder>())
+            CoreApplicationEnvironment.registerExtensionPoint(area, PsiTreeChangePreprocessor.EP_NAME, PsiTreeChangePreprocessor::class.java)
+            CoreApplicationEnvironment.registerExtensionPoint(area, PsiElementFinder.EP_NAME, PsiElementFinder::class.java)
         }
 
         // made public for Upsource
         @JvmStatic
         public fun registerProjectServices(projectEnvironment: JavaCoreProjectEnvironment) {
             with (projectEnvironment.getProject()) {
-                registerService(javaClass<KotlinScriptDefinitionProvider>(), KotlinScriptDefinitionProvider())
-                registerService(javaClass<KotlinJavaPsiFacade>(), KotlinJavaPsiFacade(this))
-                registerService(javaClass<KtLightClassForFacade.FacadeStubCache>(), KtLightClassForFacade.FacadeStubCache(this))
+                registerService(KotlinScriptDefinitionProvider::class.java, KotlinScriptDefinitionProvider())
+                registerService(KotlinJavaPsiFacade::class.java, KotlinJavaPsiFacade(this))
+                registerService(KtLightClassForFacade.FacadeStubCache::class.java, KtLightClassForFacade.FacadeStubCache(this))
             }
         }
 
         private fun registerProjectServicesForCLI(projectEnvironment: JavaCoreProjectEnvironment) {
             with (projectEnvironment.getProject()) {
-                registerService(javaClass<CoreJavaFileManager>(), ServiceManager.getService(this, javaClass<JavaFileManager>()) as CoreJavaFileManager)
+                registerService(CoreJavaFileManager::class.java, ServiceManager.getService(this, JavaFileManager::class.java) as CoreJavaFileManager)
 
                 val cliLightClassGenerationSupport = CliLightClassGenerationSupport(this)
-                registerService(javaClass<LightClassGenerationSupport>(), cliLightClassGenerationSupport)
-                registerService(javaClass<CliLightClassGenerationSupport>(), cliLightClassGenerationSupport)
-                registerService(javaClass<CodeAnalyzerInitializer>(), cliLightClassGenerationSupport)
+                registerService(LightClassGenerationSupport::class.java, cliLightClassGenerationSupport)
+                registerService(CliLightClassGenerationSupport::class.java, cliLightClassGenerationSupport)
+                registerService(CodeAnalyzerInitializer::class.java, cliLightClassGenerationSupport)
 
                 val area = Extensions.getArea(this)
 
                 area.getExtensionPoint(PsiElementFinder.EP_NAME).registerExtension(JavaElementFinder(this, cliLightClassGenerationSupport))
                 area.getExtensionPoint(PsiElementFinder.EP_NAME).registerExtension(
-                        PsiElementFinderImpl(this, ServiceManager.getService(this, javaClass<JavaFileManager>())))
+                        PsiElementFinderImpl(this, ServiceManager.getService(this, JavaFileManager::class.java)))
             }
         }
     }

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/messages/ReplSystemInWrapper.kt

@@ -31,7 +31,7 @@ public class ReplSystemInWrapper(
     private var inputByteArray = byteArrayOf()
 
     private val isAtBufferEnd: Boolean
-        get() = curBytePos == inputByteArray.size()
+        get() = curBytePos == inputByteArray.size
 
     @Volatile var isReplScriptExecuting = false
 

compiler/conditional-preprocessor/src/org.jetbrains.kotlin.preprocessor/Modifications.kt

@@ -25,7 +25,7 @@ data class Modification(val range: TextRange, val apply: (String) -> String)
 class CollectModificationsVisitor(evaluators: List<Evaluator>) : KtTreeVisitorVoid() {
 
     val elementModifications: Map<Evaluator, MutableList<Modification>> =
-            evaluators.toMap(selector = { it }, transform = { arrayListOf<Modification>() })
+            evaluators.toMapBy(selector = { it }, transform = { arrayListOf<Modification>() })
 
     override fun visitDeclaration(declaration: KtDeclaration) {
         super.visitDeclaration(declaration)
@@ -40,10 +40,10 @@ class CollectModificationsVisitor(evaluators: List<Evaluator>) : KtTreeVisitorVo
 
             if (!conditionalResult)
                 modifications.add(Modification(declaration.textRange) { rangeText ->
-                    StringBuilder {
+                    buildString {
                         append("/* Not available on $evaluator */")
                         repeat(StringUtil.getLineBreakCount(rangeText)) { append("\n") }
-                    }.toString()
+                    }
                 })
             else {
                 val targetName = annotations.filterIsInstance<Conditional.TargetName>().singleOrNull()
@@ -60,13 +60,13 @@ class CollectModificationsVisitor(evaluators: List<Evaluator>) : KtTreeVisitorVo
 }
 
 fun List<Modification>.applyTo(sourceText: String): String {
-    return StringBuilder {
+    return buildString {
         var prevIndex = 0
         for ((range, transform) in this@applyTo) {
             append(sourceText, prevIndex, range.startOffset)
             append(transform(range.substring(sourceText)))
             prevIndex = range.endOffset
         }
-        append(sourceText, prevIndex, sourceText.length())
-    }.toString()
+        append(sourceText, prevIndex, sourceText.length)
+    }
 }

compiler/conditional-preprocessor/src/org.jetbrains.kotlin.preprocessor/Preprocessor.kt

@@ -36,10 +36,10 @@ public fun createJvmProfile(targetRoot: File, version: Int): Profile = Profile("
 public fun createJsProfile(targetRoot: File): Profile = Profile("JS", JsPlatformEvaluator(), File(targetRoot, "js"))
 
 public val profileEvaluators: Map<String, () -> Evaluator> =
-        listOf(6, 7, 8).toMap({ version -> "JVM$version" }, { version -> { JvmPlatformEvaluator(version) } })  + ("JS" to { JsPlatformEvaluator() })
+        listOf(6, 7, 8).toMapBy({ version -> "JVM$version" }, { version -> { JvmPlatformEvaluator(version) } }) + ("JS" to { JsPlatformEvaluator() })
 
 public fun createProfile(name: String, targetRoot: File): Profile {
-    val (profileName, evaluator) = profileEvaluators.entrySet().firstOrNull { it.key.equals(name, ignoreCase = true) } ?: throw IllegalArgumentException("Profile with name '$name' is not supported")
+    val (profileName, evaluator) = profileEvaluators.entries.firstOrNull { it.key.equals(name, ignoreCase = true) } ?: throw IllegalArgumentException("Profile with name '$name' is not supported")
     return Profile(profileName, evaluator(), targetRoot)
 }
 
@@ -64,7 +64,7 @@ public class Preprocessor(val logger: Logger = SystemOutLogger) {
         class Modify(val sourceText: String, val modifications: List<Modification>) : FileProcessingResult() {
             fun getModifiedText(): String = modifications.applyTo(sourceText)
 
-            override fun toString(): String = "Modify(${modifications.size()})"
+            override fun toString(): String = "Modify(${modifications.size})"
         }
 
         override fun toString() = this.javaClass.simpleName
@@ -89,7 +89,7 @@ public class Preprocessor(val logger: Logger = SystemOutLogger) {
         val visitor = CollectModificationsVisitor(listOf(evaluator))
         psiFile.accept(visitor)
 
-        val list = visitor.elementModifications.values().single()
+        val list = visitor.elementModifications.values.single()
         return if (list.isNotEmpty())
             FileProcessingResult.Modify(sourceText, list)
         else
@@ -150,7 +150,7 @@ fun String.convertLineSeparators(): String = StringUtil.convertLineSeparators(th
 
 fun File.isTextEqualTo(content: String): Boolean = readText().lines() == content.lines()
 
-fun File.makeRelativeTo(from: File, to: File) = File(to, relativeTo(from))
+fun File.makeRelativeTo(from: File, to: File) = File(to, toRelativeString(from))
 
 fun File.mkdirsOrFail() {
     if (!mkdirs() && !exists()) {

compiler/conditional-preprocessor/src/org.jetbrains.kotlin.preprocessor/PreprocessorCLI.kt

@@ -21,7 +21,7 @@ import java.util.concurrent.Executors
 import java.util.concurrent.TimeUnit
 
 fun main(args: Array<String>) {
-    if (args.size() != 3) {
+    if (args.size != 3) {
         println("Usage: <path to sources> <output path> <profile>")
         System.exit(1)
     }

compiler/conditional-preprocessor/src/org.jetbrains.kotlin.preprocessor/logging.kt

@@ -38,7 +38,7 @@ public object SystemOutLogger : Logger {
 public fun Logger.withPrefix(prefix: String): Logger = PrefixedLogger(prefix, this)
 
 public class PrefixedLogger(val prefix: String, val logger: Logger) : Logger {
-    private fun prefix(msg: CharSequence): CharSequence = StringBuilder {
+    private fun prefix(msg: CharSequence): CharSequence = StringBuilder().apply {
         append(prefix)
         append(": ")
         append(msg)

compiler/container/src/org/jetbrains/kotlin/container/Cache.kt

@@ -63,7 +63,7 @@ private fun getSetterInfos(c: Class<*>): List<SetterInfo> {
     val setterInfos = ArrayList<SetterInfo>()
     for (method in c.getMethods()) {
         for (annotation in method.getDeclaredAnnotations()) {
-            if (annotation.annotationType().getName().endsWith(".Inject")) {
+            if (annotation.annotationClass.java.getName().endsWith(".Inject")) {
                 setterInfos.add(SetterInfo(method, method.getGenericParameterTypes().toList()))
             }
         }
@@ -114,6 +114,6 @@ private fun getRegistrations(klass: Class<*>): List<Type> {
     val interfaces = LinkedHashSet<Type>()
     superClasses.forEach { collectInterfacesRecursive(it, interfaces) }
     registrations.addAll(interfaces)
-    registrations.remove(javaClass<Any>())
+    registrations.remove(Any::class.java)
     return registrations
 }

compiler/container/src/org/jetbrains/kotlin/container/Container.kt

@@ -70,14 +70,14 @@ public class StorageComponentContainer(id: String) : ComponentContainer, Compone
     private fun resolveIterable(request: Type, context: ValueResolveContext): ValueDescriptor? {
         if (request !is ParameterizedType) return null
         val rawType = request.getRawType()
-        if (rawType != javaClass<Iterable<*>>()) return null
+        if (rawType != Iterable::class.java) return null
         val typeArguments = request.getActualTypeArguments()
-        if (typeArguments.size() != 1) return null
+        if (typeArguments.size != 1) return null
         val iterableTypeArgument = typeArguments[0]
         val iterableType = when (iterableTypeArgument) {
             is WildcardType -> {
                 val upperBounds = iterableTypeArgument.getUpperBounds()
-                if (upperBounds.size() != 1) return null
+                if (upperBounds.size != 1) return null
                 upperBounds[0]
             }
             is Class<*> -> iterableTypeArgument
@@ -112,9 +112,9 @@ public fun StorageComponentContainer.registerInstance(instance: Any): StorageCom
 }
 
 public inline fun <reified T : Any> StorageComponentContainer.resolve(context: ValueResolveContext = unknownContext): ValueDescriptor? {
-    return resolve(javaClass<T>(), context)
+    return resolve(T::class.java, context)
 }
 
 public inline fun <reified T : Any> StorageComponentContainer.resolveMultiple(context: ValueResolveContext = unknownContext): Iterable<ValueDescriptor> {
-    return resolveMultiple(javaClass<T>(), context)
+    return resolveMultiple(T::class.java, context)
 }

compiler/container/src/org/jetbrains/kotlin/container/Resolve.kt

@@ -58,7 +58,7 @@ fun Method.bindToMethod(context: ValueResolveContext): MethodBinding {
 }
 
 private fun Member.bindArguments(parameters: List<Type>, context: ValueResolveContext): List<ValueDescriptor> {
-    val bound = ArrayList<ValueDescriptor>(parameters.size())
+    val bound = ArrayList<ValueDescriptor>(parameters.size)
     var unsatisfied: MutableList<Type>? = null
 
     for (parameter in parameters) {

compiler/container/src/org/jetbrains/kotlin/container/Storage.kt

@@ -49,7 +49,7 @@ public class ComponentStorage(val myId: String) : ValueResolver {
         if (entry.isNotEmpty()) {
             registerDependency(request, context)
 
-            if (entry.size() > 1)
+            if (entry.size > 1)
                 throw InvalidCardinalityException("Request $request cannot be satisfied because there is more than one type registered", entry)
             return entry.singleOrNull()
         }
@@ -68,7 +68,7 @@ public class ComponentStorage(val myId: String) : ValueResolver {
     public fun dump(printer: PrintStream): Unit = with (printer) {
         val heading = "Container: $myId"
         println(heading)
-        println("=".repeat(heading.length()))
+        println("=".repeat(heading.length))
         println()
         getDescriptorsInDisposeOrder().forEach { descriptor ->
             println(descriptor)

compiler/frontend.java/src/org/jetbrains/kotlin/load/java/sam/SamConversionResolverImpl.kt

@@ -67,7 +67,7 @@ public object SamConversionResolverImpl : SamConversionResolver {
     }
 
     private fun findFunctionWithMostSpecificReturnType(supertypes: Set<KotlinType>): SimpleFunctionDescriptor {
-        val candidates = ArrayList<SimpleFunctionDescriptor>(supertypes.size())
+        val candidates = ArrayList<SimpleFunctionDescriptor>(supertypes.size)
         for (supertype in supertypes) {
             val abstractMembers = SingleAbstractMethodUtils.getAbstractMembers(supertype)
             if (!abstractMembers.isEmpty()) {

compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/JavaAnnotationCallChecker.kt

@@ -73,7 +73,7 @@ public class JavaAnnotationCallChecker : CallChecker {
             argument: Map.Entry<ValueParameterDescriptor, ResolvedValueArgument>,
             diagnostic: DiagnosticFactory0<KtExpression>
     ) {
-        argument.getValue().getArguments().forEach {
+        argument.value.getArguments().forEach {
             if (it.getArgumentExpression() != null) {
                 context.trace.report(
                         diagnostic.on(

compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/JvmVirtualFileFinder.kt

@@ -24,6 +24,6 @@ public interface JvmVirtualFileFinder : VirtualFileFinder, KotlinClassFinder {
     public object SERVICE {
         @JvmStatic
         public fun getInstance(project: Project): JvmVirtualFileFinder =
-            ServiceManager.getService(project, javaClass<JvmVirtualFileFinderFactory>()).create(GlobalSearchScope.allScope(project))
+            ServiceManager.getService(project, JvmVirtualFileFinderFactory::class.java).create(GlobalSearchScope.allScope(project))
     }
 }

compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/JvmVirtualFileFinderFactory.kt

@@ -26,6 +26,6 @@ public interface JvmVirtualFileFinderFactory : VirtualFileFinderFactory {
     public object SERVICE {
         @JvmStatic
         public fun getInstance(project: Project): JvmVirtualFileFinderFactory =
-            ServiceManager.getService(project, javaClass<JvmVirtualFileFinderFactory>())
+            ServiceManager.getService(project, JvmVirtualFileFinderFactory::class.java)
     }
 }

compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/VirtualFileKotlinClass.kt

@@ -50,7 +50,7 @@ public class VirtualFileKotlinClass private constructor(
     override fun toString() = "${javaClass.getSimpleName()}: $file"
 
     companion object Factory {
-        private val LOG = Logger.getInstance(javaClass<VirtualFileKotlinClass>())
+        private val LOG = Logger.getInstance(VirtualFileKotlinClass::class.java)
         private val perfCounter = PerformanceCounter.create("Binary class from Kotlin file")
 
         @Deprecated("Use KotlinBinaryClassCache")

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/TraitDefaultMethodCallChecker.kt

@@ -38,12 +38,12 @@ public class TraitDefaultMethodCallChecker : CallChecker {
 
         if (containerDescriptor is JavaClassDescriptor && DescriptorUtils.isInterface(containerDescriptor)) {
             //is java interface default method called from trait
-            val classifier = DescriptorUtils.getParentOfType(context.scope.ownerDescriptor, javaClass<ClassifierDescriptor>())
+            val classifier = DescriptorUtils.getParentOfType(context.scope.ownerDescriptor, ClassifierDescriptor::class.java)
 
             if (classifier != null && DescriptorUtils.isInterface(classifier)) {
                 context.trace.report(
                         ErrorsJvm.INTERFACE_CANT_CALL_DEFAULT_METHOD_VIA_SUPER.on(
-                                PsiTreeUtil.getParentOfType(resolvedCall.getCall().getCallElement(), javaClass<KtExpression>())
+                                PsiTreeUtil.getParentOfType(resolvedCall.getCall().getCallElement(), KtExpression::class.java)
                         )
                 )
             }

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/extensions/AnalysisCompletedHandlerExtension.kt

@@ -27,7 +27,7 @@ import org.jetbrains.kotlin.resolve.BindingContext
 public interface AnalysisCompletedHandlerExtension {
     companion object : ProjectExtensionDescriptor<AnalysisCompletedHandlerExtension>(
             "org.jetbrains.kotlin.analyzeCompleteHandlerExtension",
-            javaClass<AnalysisCompletedHandlerExtension>()
+            AnalysisCompletedHandlerExtension::class.java
     )
 
     public fun analysisCompleted(

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/jvmSignature/KotlinToJvmSignatureMapper.kt

@@ -26,7 +26,7 @@ fun erasedSignaturesEqualIgnoringReturnTypes(subFunction: JvmMethodSignature, su
     val subParams = subFunction.getValueParameters()
     val superParams = superFunction.getValueParameters()
 
-    if (subParams.size() != superParams.size()) return false
+    if (subParams.size != superParams.size) return false
 
     return subParams.zip(superParams).all {
         p -> val (subParam, superParam) = p

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/platform/JavaGenericVarianceViolationTypeChecker.kt

@@ -59,14 +59,14 @@ public object JavaGenericVarianceViolationTypeChecker : AdditionalTypeChecker {
 
         val correspondingSubType = TypeCheckingProcedure.findCorrespondingSupertype(expressionTypeWithSmartCast, lowerBound) ?: return
 
-        assert(lowerBound.arguments.size() == upperBound.arguments.size()) {
+        assert(lowerBound.arguments.size == upperBound.arguments.size) {
             "Different arguments count in flexible bounds: " +
-            "($lowerBound(${lowerBound.arguments.size()})..$upperBound(${upperBound.arguments.size()})"
+            "($lowerBound(${lowerBound.arguments.size})..$upperBound(${upperBound.arguments.size})"
         }
 
-        assert(lowerBound.arguments.size() == correspondingSubType.arguments.size()) {
+        assert(lowerBound.arguments.size == correspondingSubType.arguments.size) {
             "Different arguments count in corresponding subtype and supertype: " +
-            "($lowerBound(${lowerBound.arguments.size()})..$correspondingSubType(${correspondingSubType.arguments.size()})"
+            "($lowerBound(${lowerBound.arguments.size})..$correspondingSubType(${correspondingSubType.arguments.size})"
         }
 
 

compiler/frontend.java/src/org/jetbrains/kotlin/synthetic/JavaSyntheticPropertiesScope.kt

@@ -169,13 +169,13 @@ class JavaSyntheticPropertiesScope(storageManager: StorageManager, private val l
 
     override fun getSyntheticExtensionProperties(receiverTypes: Collection<KotlinType>, name: Name, location: LookupLocation): Collection<PropertyDescriptor> {
         var result: SmartList<PropertyDescriptor>? = null
-        val processedTypes: MutableSet<TypeConstructor>? = if (receiverTypes.size() > 1) HashSet<TypeConstructor>() else null
+        val processedTypes: MutableSet<TypeConstructor>? = if (receiverTypes.size > 1) HashSet<TypeConstructor>() else null
         for (type in receiverTypes) {
             result = collectSyntheticPropertiesByName(result, type.constructor, name, processedTypes, location)
         }
         return when {
             result == null -> emptyList()
-            result.size() > 1 -> result.toSet()
+            result.size > 1 -> result.toSet()
             else -> result
         }
     }
@@ -304,7 +304,7 @@ class JavaSyntheticPropertiesScope(storageManager: StorageManager, private val l
                 descriptor.setMethod = setMethod
 
                 val classTypeParams = ownerClass.typeConstructor.parameters
-                val typeParameters = ArrayList<TypeParameterDescriptor>(classTypeParams.size())
+                val typeParameters = ArrayList<TypeParameterDescriptor>(classTypeParams.size)
                 val typeSubstitutor = DescriptorSubstitutor.substituteTypeParameters(classTypeParams, TypeSubstitution.EMPTY, descriptor, typeParameters)
 
                 val propertyType = typeSubstitutor.safeSubstitute(type, Variance.INVARIANT)

compiler/frontend.java/src/org/jetbrains/kotlin/synthetic/SamAdapterFunctionsScope.kt

@@ -67,7 +67,7 @@ class SamAdapterFunctionsScope(storageManager: StorageManager) : SyntheticScope
         }
         return when {
             result == null -> emptyList()
-            result.size() > 1 -> result.toSet()
+            result.size > 1 -> result.toSet()
             else -> result
         }
     }
@@ -118,7 +118,7 @@ class SamAdapterFunctionsScope(storageManager: StorageManager) : SyntheticScope
                 }
                 //TODO: duplicated parameter names
 
-                val typeParameters = ArrayList<TypeParameterDescriptor>(sourceTypeParams.size())
+                val typeParameters = ArrayList<TypeParameterDescriptor>(sourceTypeParams.size)
                 val typeSubstitutor = DescriptorSubstitutor.substituteTypeParameters(sourceTypeParams, TypeSubstitution.EMPTY, descriptor, typeParameters)
 
                 descriptor.toSourceFunctionTypeParameters = typeParameters.zip(sourceTypeParams).toMap()

compiler/frontend/src/org/jetbrains/kotlin/cfg/UnreachableCode.kt

@@ -58,7 +58,7 @@ class UnreachableCodeImpl(
         acceptChildren(object : PsiElementVisitor() {
             override fun visitElement(element: PsiElement) {
                 val isReachable = element is KtElement && reachableElements.contains(element) && !element.hasChildrenInSet(unreachableElements)
-                if (isReachable || element.getChildren().size() == 0) {
+                if (isReachable || element.getChildren().size == 0) {
                     children.add(element)
                 }
                 else {
@@ -77,7 +77,7 @@ class UnreachableCodeImpl(
         val childrenToRemove = HashSet<PsiElement>()
         fun collectSiblingsIfMeaningless(elementIndex: Int, direction: Int) {
             val index = elementIndex + direction
-            if (index !in 0..(size() - 1)) return
+            if (index !in 0..(size - 1)) return
 
             val element = this[index]
             if (element.isMeaningless()) {

compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/TypePredicate.kt

@@ -58,14 +58,14 @@ public object AllTypes : TypePredicate {
 
 // todo: simplify computed type predicate when possible
 public fun and(predicates: Collection<TypePredicate>): TypePredicate =
-        when (predicates.size()) {
+        when (predicates.size) {
             0 -> AllTypes
             1 -> predicates.first()
             else -> ForAllTypes(predicates.toList())
         }
 
 public fun or(predicates: Collection<TypePredicate>): TypePredicate? =
-        when (predicates.size()) {
+        when (predicates.size) {
             0 -> null
             1 -> predicates.first()
             else -> ForSomeType(predicates.toList())

compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/eval/accessInstructions.kt

@@ -64,7 +64,7 @@ public class ReadValueInstruction private constructor(
     }
 
     override val inputValues: List<PseudoValue>
-        get() = receiverValues.keySet().toList()
+        get() = receiverValues.keys.toList()
 
     override val outputValue: PseudoValue
         get() = _outputValue!!
@@ -78,7 +78,7 @@ public class ReadValueInstruction private constructor(
     }
 
     override fun toString(): String {
-        val inVal = if (receiverValues.isEmpty()) "" else "|${receiverValues.keySet().joinToString()}"
+        val inVal = if (receiverValues.isEmpty()) "" else "|${receiverValues.keys.joinToString()}"
         val targetName = when (target) {
             is AccessTarget.Declaration -> target.descriptor
             is AccessTarget.Call -> target.resolvedCall.getResultingDescriptor()
@@ -104,7 +104,7 @@ public class WriteValueInstruction(
 ) : AccessValueInstruction(assignment, lexicalScope, target, receiverValues) {
     override val inputValues: List<PseudoValue>
         // as is necessary: see KT-10384
-        get() = (receiverValues.keySet() as Collection<PseudoValue>) + rValue
+        get() = (receiverValues.keys as Collection<PseudoValue>) + rValue
 
     override fun accept(visitor: InstructionVisitor) {
         visitor.visitWriteValue(this)

compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/eval/operationInstructions.kt

@@ -59,7 +59,7 @@ public class CallInstruction private constructor(
         val resolvedCall: ResolvedCall<*>,
         override val receiverValues: Map<PseudoValue, ReceiverValue>,
         public val arguments: Map<PseudoValue, ValueParameterDescriptor>
-) : OperationInstruction(element, lexicalScope, (receiverValues.keySet() as Collection<PseudoValue>) + arguments.keySet()), InstructionWithReceivers {
+) : OperationInstruction(element, lexicalScope, (receiverValues.keys as Collection<PseudoValue>) + arguments.keys), InstructionWithReceivers {
     // as is necessary above: see KT-10384
 
     public constructor (

compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/jumps/NondeterministicJumpInstruction.kt

@@ -54,7 +54,7 @@ public class NondeterministicJumpInstruction(
 
     override val nextInstructions: Collection<Instruction>
         get() {
-            val targetInstructions = Lists.newArrayList(resolvedTargets.values())
+            val targetInstructions = Lists.newArrayList(resolvedTargets.values)
             targetInstructions.add(next)
             return targetInstructions
         }

compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/pseudocodeUtils.kt

@@ -123,7 +123,7 @@ public fun getExpectedTypePredicate(
             val candidateArgumentMap = candidateCall.getValueArguments()
             val callArguments = call.getValueArguments()
             val i = inputValueIndex - argValueOffset
-            if (i < 0 || i >= callArguments.size()) continue
+            if (i < 0 || i >= callArguments.size) continue
 
             val mapping = candidateCall.getArgumentMapping(callArguments.get(i))
             if (mapping !is ArgumentMatch) continue
@@ -288,7 +288,7 @@ fun Pseudocode.getElementValuesRecursively(element: KtElement): List<PseudoValue
 
 public fun KtElement.getContainingPseudocode(context: BindingContext): Pseudocode? {
     val pseudocodeDeclaration =
-            PsiTreeUtil.getParentOfType(this, javaClass<KtDeclarationWithBody>(), javaClass<KtClassOrObject>(), javaClass<KtScript>())
+            PsiTreeUtil.getParentOfType(this, KtDeclarationWithBody::class.java, KtClassOrObject::class.java, KtScript::class.java)
             ?: getNonStrictParentOfType<KtProperty>()
             ?: return null
 

compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/Renderers.kt

@@ -52,7 +52,7 @@ import java.io.StringWriter
 
 public object Renderers {
 
-    private val LOG = Logger.getInstance(javaClass<Renderers>())
+    private val LOG = Logger.getInstance(Renderers::class.java)
 
     @JvmField
     public val TO_STRING: Renderer<Any> = Renderer {
@@ -129,7 +129,7 @@ public object Renderers {
     @JvmStatic
     public fun <T> commaSeparated(itemRenderer: Renderer<T>): Renderer<Collection<T>> = Renderer {
         collection ->
-        StringBuilder {
+        buildString {
             val iterator = collection.iterator()
             while (iterator.hasNext()) {
                 val next = iterator.next()
@@ -138,7 +138,7 @@ public object Renderers {
                     append(", ")
                 }
             }
-        }.toString()
+        }
     }
 
     @JvmField
@@ -201,7 +201,7 @@ public object Renderers {
             val parameterTypes = Lists.newArrayList<KotlinType>()
             for (valueParameterDescriptor in substitutedDescriptor.getValueParameters()) {
                 parameterTypes.add(valueParameterDescriptor.getType())
-                if (valueParameterDescriptor.index >= inferenceErrorData.valueArgumentsTypes.size()) continue
+                if (valueParameterDescriptor.index >= inferenceErrorData.valueArgumentsTypes.size) continue
                 val actualType = inferenceErrorData.valueArgumentsTypes.get(valueParameterDescriptor.index)
                 if (!KotlinTypeChecker.DEFAULT.isSubtypeOf(actualType, valueParameterDescriptor.getType())) {
                     errorPositions.add(VALUE_PARAMETER_POSITION.position(valueParameterDescriptor.index))
@@ -360,19 +360,19 @@ public object Renderers {
     @JvmField
     public val CLASSES_OR_SEPARATED: Renderer<Collection<ClassDescriptor>> = Renderer {
         descriptors ->
-        StringBuilder {
+        buildString {
             var index = 0
             for (descriptor in descriptors) {
                 append(DescriptorUtils.getFqName(descriptor).asString())
                 index++
-                if (index <= descriptors.size() - 2) {
+                if (index <= descriptors.size - 2) {
                     append(", ")
                 }
-                else if (index == descriptors.size() - 1) {
+                else if (index == descriptors.size - 1) {
                     append(" or ")
                 }
             }
-        }.toString()
+        }
     }
 
     private fun renderTypes(types: Collection<KotlinType>) = StringUtil.join(types, { RENDER_TYPE.render(it) }, ", ")
@@ -417,7 +417,7 @@ public object Renderers {
     @JvmField
     public val RENDER_TYPE_BOUNDS_SHORT: Renderer<TypeBounds> = Renderer { renderTypeBounds(it, short = true) }
 
-    private fun renderDebugMessage(message: String, inferenceErrorData: InferenceErrorData) = StringBuilder {
+    private fun renderDebugMessage(message: String, inferenceErrorData: InferenceErrorData) = buildString {
         append(message)
         append("\nConstraint system: \n")
         append(RENDER_CONSTRAINT_SYSTEM.render(inferenceErrorData.constraintSystem))
@@ -435,5 +435,5 @@ public object Renderers {
             append(RENDER_TYPE.render(inferenceErrorData.receiverArgumentType)).append(".")
         }
         append("(").append(renderTypes(inferenceErrorData.valueArgumentsTypes)).append(")")
-    }.toString()
+    }
 }

compiler/frontend/src/org/jetbrains/kotlin/extensions/ExternalDeclarationsProvider.kt

@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.psi.KtFile
 public interface ExternalDeclarationsProvider {
     companion object : ProjectExtensionDescriptor<ExternalDeclarationsProvider>(
             "org.jetbrains.kotlin.externalDeclarationsProvider",
-            javaClass<ExternalDeclarationsProvider>()
+            ExternalDeclarationsProvider::class.java
     )
 
     public fun getExternalDeclarations(moduleInfo: ModuleInfo?): Collection<KtFile>

compiler/frontend/src/org/jetbrains/kotlin/extensions/StorageComponentContainerContributor.kt

@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.resolve.TargetPlatform
 
 public interface StorageComponentContainerContributor {
     companion object : ProjectExtensionDescriptor<StorageComponentContainerContributor>(
-            "org.jetbrains.kotlin.storageComponentContainerContributor", javaClass<StorageComponentContainerContributor>()
+            "org.jetbrains.kotlin.storageComponentContainerContributor", StorageComponentContainerContributor::class.java
     )
 
     public fun addDeclarations(container: StorageComponentContainer, platform: TargetPlatform)

compiler/frontend/src/org/jetbrains/kotlin/kdoc/psi/impl/KDocImpl.kt

@@ -45,10 +45,10 @@ public class KDocImpl(buffer: CharSequence?) : LazyParseablePsiElement(KDocToken
         getChildrenOfType<KDocSection>().firstOrNull { it.getName() == name }
 
     override fun findSectionByTag(tag: KDocKnownTag): KDocSection? =
-        findSectionByName(tag.name().toLowerCase())
+        findSectionByName(tag.name.toLowerCase())
 
     override fun findSectionByTag(tag: KDocKnownTag, subjectName: String): KDocSection? =
         getChildrenOfType<KDocSection>().firstOrNull {
-            it.getName() == tag.name().toLowerCase() && it.getSubjectName() == subjectName
+            it.getName() == tag.name.toLowerCase() && it.getSubjectName() == subjectName
         }
 }

compiler/frontend/src/org/jetbrains/kotlin/kdoc/psi/impl/KDocLink.kt

@@ -30,9 +30,9 @@ public class KDocLink(node: ASTNode) : KtElementImpl(node) {
     public fun getLinkTextRange(): TextRange {
         val text = getText()
         if (text.startsWith('[') && text.endsWith(']')) {
-            return TextRange(1, text.length() - 1)
+            return TextRange(1, text.length - 1)
         }
-        return TextRange(0, text.length())
+        return TextRange(0, text.length)
     }
 
     /**

compiler/frontend/src/org/jetbrains/kotlin/parsing/CommentBinders.kt

@@ -32,7 +32,7 @@ object PrecedingCommentsBinder : WhitespacesAndCommentsBinder {
         }
 
         // 2. bind plain comments
-        var result = tokens.size()
+        var result = tokens.size
         tokens@ for (idx in tokens.indices.reversed()) {
             val tokenType = tokens[idx]
             when (tokenType) {
@@ -61,7 +61,7 @@ object PrecedingDocCommentsBinder : WhitespacesAndCommentsBinder {
             if (tokens[idx] == KtTokens.DOC_COMMENT) return idx
         }
 
-        return tokens.size()
+        return tokens.size
     }
 }
 

compiler/frontend/src/org/jetbrains/kotlin/psi/DebugTextUtil.kt

@@ -194,7 +194,7 @@ private object DebugTextBuildingVisitor : KtVisitor<String, Unit>() {
     }
 
     override fun visitPropertyAccessor(accessor: KtPropertyAccessor, data: Unit?): String? {
-        val containingProperty = KtStubbedPsiUtil.getContainingDeclaration(accessor, javaClass<KtProperty>())
+        val containingProperty = KtStubbedPsiUtil.getContainingDeclaration(accessor, KtProperty::class.java)
         val what = (if (accessor.isGetter()) "getter" else "setter")
         return what + " for " + (if (containingProperty != null) containingProperty.getDebugText() else "...")
     }

compiler/frontend/src/org/jetbrains/kotlin/psi/EditCommaSeparatedListHelper.kt

@@ -62,7 +62,7 @@ object EditCommaSeparatedListHelper {
                 anchorAfter = if (index > 0) allItems.get(index - 1) else null
             }
             else {
-                anchorAfter = allItems.get(allItems.size() - 1)
+                anchorAfter = allItems.get(allItems.size - 1)
             }
         }
         return addItemAfter(list, allItems, item, anchorAfter)

compiler/frontend/src/org/jetbrains/kotlin/psi/KotlinStringLiteralTextEscaper.kt

@@ -52,7 +52,7 @@ public class KotlinStringLiteralTextEscaper(host: KtStringTemplateExpression): L
                     }
                     val unescaped = child.getUnescapedValue()
                     outChars.append(unescaped)
-                    repeat(unescaped.length()) {
+                    repeat(unescaped.length) {
                         sourceOffsetsList.add(sourceOffset)
                     }
                     sourceOffset += child.getTextLength()
@@ -67,7 +67,7 @@ public class KotlinStringLiteralTextEscaper(host: KtStringTemplateExpression): L
 
     override fun getOffsetInHost(offsetInDecoded: Int, rangeInsideHost: TextRange): Int {
         val offsets = sourceOffsets
-        if (offsets == null || offsetInDecoded >= offsets.size()) return -1
+        if (offsets == null || offsetInDecoded >= offsets.size) return -1
         return Math.min(offsets[offsetInDecoded], rangeInsideHost.getLength()) + rangeInsideHost.getStartOffset()
     }
 

compiler/frontend/src/org/jetbrains/kotlin/psi/KtBlockCodeFragment.kt

@@ -28,6 +28,6 @@ public class KtBlockCodeFragment(
         context: PsiElement?
 ) : KtCodeFragment(project, name, text, imports, KtNodeTypes.BLOCK_CODE_FRAGMENT, context) {
 
-    override fun getContentElement() = findChildByClass(javaClass<KtBlockExpression>())
+    override fun getContentElement() = findChildByClass(KtBlockExpression::class.java)
                                                 ?: throw IllegalStateException("Block expression should be parsed for BlockCodeFragment")
 }

compiler/frontend/src/org/jetbrains/kotlin/psi/KtClass.kt

@@ -72,7 +72,7 @@ public open class KtClass : KtClassOrObject {
         var current: KtClassOrObject? = this
         while (current != null) {
             parts.add(current.getName()!!)
-            current = PsiTreeUtil.getParentOfType<KtClassOrObject>(current, javaClass<KtClassOrObject>())
+            current = PsiTreeUtil.getParentOfType<KtClassOrObject>(current, KtClassOrObject::class.java)
         }
         val file = getContainingFile()
         if (file !is KtFile) return null

compiler/frontend/src/org/jetbrains/kotlin/psi/KtClassOrObject.kt

@@ -51,7 +51,7 @@ abstract public class KtClassOrObject :
         val specifierList = getSuperTypeList() ?: return
         assert(superTypeListEntry.getParent() === specifierList)
 
-        if (specifierList.getEntries().size() > 1) {
+        if (specifierList.getEntries().size > 1) {
             EditCommaSeparatedListHelper.removeItem<KtElement>(superTypeListEntry)
         }
         else {
@@ -65,7 +65,7 @@ abstract public class KtClassOrObject :
 
     public fun addDeclaration(declaration: KtDeclaration): KtDeclaration {
         val body = getOrCreateBody()
-        val anchor = PsiTreeUtil.skipSiblingsBackward(body.rBrace ?: body.getLastChild()!!, javaClass<PsiWhiteSpace>())
+        val anchor = PsiTreeUtil.skipSiblingsBackward(body.rBrace ?: body.getLastChild()!!, PsiWhiteSpace::class.java)
         return body.addAfter(declaration, anchor) as KtDeclaration
     }
 
@@ -106,7 +106,7 @@ abstract public class KtClassOrObject :
         CheckUtil.checkWritable(this);
 
         val file = getContainingKtFile();
-        if (!isTopLevel() || file.getDeclarations().size() > 1) {
+        if (!isTopLevel() || file.getDeclarations().size > 1) {
             super.delete()
         }
         else {

compiler/frontend/src/org/jetbrains/kotlin/psi/KtExpressionCodeFragment.kt

@@ -28,5 +28,5 @@ public class KtExpressionCodeFragment(
         context: PsiElement?
 ) : KtCodeFragment(project, name, text, imports, KtNodeTypes.EXPRESSION_CODE_FRAGMENT, context) {
 
-    override fun getContentElement() = findChildByClass(javaClass<KtExpression>())
+    override fun getContentElement() = findChildByClass(KtExpression::class.java)
 }

compiler/frontend/src/org/jetbrains/kotlin/psi/KtExpressionImpl.kt

@@ -26,7 +26,7 @@ public abstract class KtExpressionImpl(node: ASTNode) : KtElementImpl(node), KtE
 
     protected fun findExpressionUnder(type: KtNodeType): KtExpression? {
         val containerNode = findChildByType<KtContainerNode>(type) ?: return null
-        return containerNode.findChildByClass<KtExpression>(javaClass())
+        return containerNode.findChildByClass<KtExpression>(KtExpression::class.java)
     }
 
     override fun replace(newElement: PsiElement): PsiElement {

compiler/frontend/src/org/jetbrains/kotlin/psi/KtPsiFactory.kt

@@ -224,7 +224,7 @@ public class KtPsiFactory(private val project: Project) {
     public fun <TDeclaration : KtDeclaration> createDeclaration(text: String): TDeclaration {
         val file = createFile(text)
         val declarations = file.getDeclarations()
-        assert(declarations.size() == 1) { "${declarations.size()} declarations in $text" }
+        assert(declarations.size == 1) { "${declarations.size} declarations in $text" }
         @Suppress("UNCHECKED_CAST")
         val result = declarations.first() as TDeclaration
         return result
@@ -305,7 +305,7 @@ public class KtPsiFactory(private val project: Project) {
 
     public fun createWhenEntry(entryText: String): KtWhenEntry {
         val function = createFunction("fun foo() { when(12) { " + entryText + " } }")
-        val whenEntry = PsiTreeUtil.findChildOfType(function, javaClass<KtWhenEntry>())
+        val whenEntry = PsiTreeUtil.findChildOfType(function, KtWhenEntry::class.java)
 
         assert(whenEntry != null) { "Couldn't generate when entry" }
         assert(entryText == whenEntry!!.text) { "Generate when entry text differs from the given text" }
@@ -453,7 +453,7 @@ public class KtPsiFactory(private val project: Project) {
         private fun placeKeyword() {
             assert(state == State.MODIFIERS)
 
-            if (sb.length() != 0) {
+            if (sb.length != 0) {
                 sb.append(" ")
             }
             val keyword = when (target) {

compiler/frontend/src/org/jetbrains/kotlin/psi/KtSecondaryConstructor.kt

@@ -29,11 +29,11 @@ public class KtSecondaryConstructor : KtConstructor<KtSecondaryConstructor> {
 
     override fun getContainingClassOrObject() = getParent().getParent() as KtClassOrObject
 
-    override fun getBodyExpression() = findChildByClass(javaClass<KtBlockExpression>())
+    override fun getBodyExpression() = findChildByClass(KtBlockExpression::class.java)
 
     override fun getConstructorKeyword() = notNullChild<PsiElement>(super.getConstructorKeyword())
 
-    public fun getDelegationCall(): KtConstructorDelegationCall = findNotNullChildByClass(javaClass<KtConstructorDelegationCall>())
+    public fun getDelegationCall(): KtConstructorDelegationCall = findNotNullChildByClass(KtConstructorDelegationCall::class.java)
 
     public fun hasImplicitDelegationCall(): Boolean = getDelegationCall().isImplicit()
 

compiler/frontend/src/org/jetbrains/kotlin/psi/createByPattern.kt

@@ -59,7 +59,7 @@ private class PsiElementArgumentType<T : PsiElement>(klass: Class<T>) : PsiEleme
     }
 }
 
-private object PsiChildRangeArgumentType : PsiElementPlaceholderArgumentType<PsiChildRange, KtElement>(javaClass(), javaClass()) {
+private object PsiChildRangeArgumentType : PsiElementPlaceholderArgumentType<PsiChildRange, KtElement>(PsiChildRange::class.java, KtElement::class.java) {
     override fun replacePlaceholderElement(placeholder: KtElement, argument: PsiChildRange) {
         val project = placeholder.getProject()
         val codeStyleManager = CodeStyleManager.getInstance(project)
@@ -81,10 +81,10 @@ private object PsiChildRangeArgumentType : PsiElementPlaceholderArgumentType<Psi
 }
 
 private val SUPPORTED_ARGUMENT_TYPES = listOf(
-        PsiElementArgumentType<KtExpression>(javaClass()),
-        PsiElementArgumentType<KtTypeReference>(javaClass()),
-        PlainTextArgumentType<String>(javaClass(), toPlainText = { it }),
-        PlainTextArgumentType<Name>(javaClass(), toPlainText = { it.render() }),
+        PsiElementArgumentType<KtExpression>(KtExpression::class.java),
+        PsiElementArgumentType<KtTypeReference>(KtTypeReference::class.java),
+        PlainTextArgumentType<String>(String::class.java, toPlainText = { it }),
+        PlainTextArgumentType<Name>(Name::class.java, toPlainText = { it.render() }),
         PsiChildRangeArgumentType
 )
 
@@ -184,7 +184,7 @@ private data class PatternData(val processedText: String, val placeholders: Map<
 private fun processPattern(pattern: String, args: List<Any>): PatternData {
     val ranges = LinkedHashMap<Int, MutableList<Placeholder>>()
 
-    fun charOrNull(i: Int) = if (0 <= i && i < pattern.length()) pattern[i] else null
+    fun charOrNull(i: Int) = if (0 <= i && i < pattern.length) pattern[i] else null
 
     fun check(condition: Boolean, message: String) {
         if (!condition) {
@@ -192,9 +192,9 @@ private fun processPattern(pattern: String, args: List<Any>): PatternData {
         }
     }
 
-    val text = StringBuilder {
+    val text = buildString {
         var i = 0
-        while (i < pattern.length()) {
+        while (i < pattern.length) {
             var c = pattern[i]
 
             if (c == '$') {
@@ -205,12 +205,12 @@ private fun processPattern(pattern: String, args: List<Any>): PatternData {
                 else {
                     check(nextChar?.isDigit() ?: false, "unclosed '$'")
 
-                    val lastIndex = (i..pattern.length() - 1).firstOrNull { !pattern[it].isDigit() } ?: pattern.length()
+                    val lastIndex = (i..pattern.length - 1).firstOrNull { !pattern[it].isDigit() } ?: pattern.length
                     val n = pattern.substring(i, lastIndex).toInt()
                     check(n >= 0, "invalid placeholder number: $n")
                     i = lastIndex
 
-                    val arg: Any? = if (n < args.size()) args[n] else null /* report wrong number of arguments later */
+                    val arg: Any? = if (n < args.size) args[n] else null /* report wrong number of arguments later */
                     val placeholderText = if (charOrNull(i) != ':' || charOrNull(i + 1) != '\'') {
                         if (arg is String) arg else "xyz"
                     }
@@ -226,7 +226,7 @@ private fun processPattern(pattern: String, args: List<Any>): PatternData {
                     }
 
                     append(placeholderText)
-                    val range = TextRange(length() - placeholderText.length(), length())
+                    val range = TextRange(length - placeholderText.length, length)
                     ranges.getOrPut(n, { ArrayList() }).add(Placeholder(range, placeholderText))
                     continue
                 }
@@ -236,17 +236,17 @@ private fun processPattern(pattern: String, args: List<Any>): PatternData {
             }
             i++
         }
-    }.toString()
+    }
 
     if (!ranges.isEmpty()) {
-        val max = ranges.keySet().max()!!
+        val max = ranges.keys.max()!!
         for (i in 0..max) {
             check(ranges.contains(i), "no '$$i' placeholder")
         }
     }
 
-    if (args.size() != ranges.size()) {
-        throw IllegalArgumentException("Wrong number of arguments, expected: ${ranges.size()}, passed: ${args.size()}")
+    if (args.size != ranges.size) {
+        throw IllegalArgumentException("Wrong number of arguments, expected: ${ranges.size}, passed: ${args.size}")
     }
 
     return PatternData(text, ranges)
@@ -262,14 +262,14 @@ public class BuilderByPattern<TElement> {
     }
 
     public fun appendNonFormattedText(text: String): BuilderByPattern<TElement> {
-        patternBuilder.append("$" + arguments.size())
+        patternBuilder.append("$" + arguments.size)
         arguments.add(text)
         return this
     }
 
     public fun appendExpression(expression: KtExpression?): BuilderByPattern<TElement> {
         if (expression != null) {
-            patternBuilder.append("$" + arguments.size())
+            patternBuilder.append("$" + arguments.size)
             arguments.add(expression)
         }
         return this
@@ -287,20 +287,20 @@ public class BuilderByPattern<TElement> {
 
     public fun appendTypeReference(typeRef: KtTypeReference?): BuilderByPattern<TElement> {
         if (typeRef != null) {
-            patternBuilder.append("$" + arguments.size())
+            patternBuilder.append("$" + arguments.size)
             arguments.add(typeRef)
         }
         return this
     }
 
     public fun appendName(name: Name): BuilderByPattern<TElement> {
-        patternBuilder.append("$" + arguments.size())
+        patternBuilder.append("$" + arguments.size)
         arguments.add(name)
         return this
     }
 
     public fun appendChildRange(range: PsiChildRange): BuilderByPattern<TElement> {
-        patternBuilder.append("$" + arguments.size())
+        patternBuilder.append("$" + arguments.size)
         arguments.add(range)
         return this
     }

compiler/frontend/src/org/jetbrains/kotlin/psi/psiUtil/KtStringTemplateExpressionManipulator.kt

@@ -30,7 +30,7 @@ public class KtStringTemplateExpressionManipulator : AbstractElementManipulator<
         val newText = oldText.substring(0, range.getStartOffset()) + content + oldText.substring(range.getEndOffset())
         val expression = KtPsiFactory(element.getProject()).createExpression(newText)
         node.replaceAllChildrenToChildrenOf(expression.getNode())
-        return node.getPsi(javaClass())
+        return node.getPsi(KtStringTemplateExpression::class.java)
     }
 
     override fun getRangeInElement(element: KtStringTemplateExpression): TextRange {

compiler/frontend/src/org/jetbrains/kotlin/psi/psiUtil/StringTemplateExpressionManipulator.kt

@@ -30,7 +30,7 @@ public class StringTemplateExpressionManipulator: AbstractElementManipulator<KtS
         val newText = oldText.substring(0, range.getStartOffset()) + content + oldText.substring(range.getEndOffset())
         val expression = KtPsiFactory(element.getProject()).createExpression(newText)
         node.replaceAllChildrenToChildrenOf(expression.getNode())
-        return node.getPsi(javaClass())
+        return node.getPsi(KtStringTemplateExpression::class.java)
     }
 
     override fun getRangeInElement(element: KtStringTemplateExpression): TextRange {

compiler/frontend/src/org/jetbrains/kotlin/psi/psiUtil/ktPsiUtil.kt

@@ -152,7 +152,7 @@ public fun KtExpression.isDotReceiver(): Boolean =
 public fun KtElement.getCalleeHighlightingRange(): TextRange {
     val annotationEntry: KtAnnotationEntry =
             PsiTreeUtil.getParentOfType<KtAnnotationEntry>(
-                    this, javaClass<KtAnnotationEntry>(), /* strict = */false, javaClass<KtValueArgumentList>()
+                    this, KtAnnotationEntry::class.java, /* strict = */false, KtValueArgumentList::class.java
             ) ?: return getTextRange()
 
     val startOffset = annotationEntry.getAtSymbol()?.getTextRange()?.getStartOffset()

compiler/frontend/src/org/jetbrains/kotlin/psi/psiUtil/psiUtils.kt

@@ -117,23 +117,23 @@ public fun <T : PsiElement> PsiElement.getNonStrictParentOfType(parentClass: Cla
 }
 
 inline public fun <reified T : PsiElement> PsiElement.getParentOfType(strict: Boolean): T? {
-    return PsiTreeUtil.getParentOfType(this, javaClass<T>(), strict)
+    return PsiTreeUtil.getParentOfType(this, T::class.java, strict)
 }
 
 inline public fun <reified T : PsiElement> PsiElement.getStrictParentOfType(): T? {
-    return PsiTreeUtil.getParentOfType(this, javaClass<T>(), true)
+    return PsiTreeUtil.getParentOfType(this, T::class.java, true)
 }
 
 inline public fun <reified T : PsiElement> PsiElement.getNonStrictParentOfType(): T? {
-    return PsiTreeUtil.getParentOfType(this, javaClass<T>(), false)
+    return PsiTreeUtil.getParentOfType(this, T::class.java, false)
 }
 
 inline public fun <reified T : PsiElement> PsiElement.getChildOfType(): T? {
-    return PsiTreeUtil.getChildOfType(this, javaClass<T>())
+    return PsiTreeUtil.getChildOfType(this, T::class.java)
 }
 
 inline public fun <reified T : PsiElement> PsiElement.getChildrenOfType(): Array<T> {
-    return PsiTreeUtil.getChildrenOfType(this, javaClass<T>()) ?: arrayOf()
+    return PsiTreeUtil.getChildrenOfType(this, T::class.java) ?: arrayOf()
 }
 
 public fun PsiElement.getNextSiblingIgnoringWhitespaceAndComments(): PsiElement? {

compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtAnnotationUseSiteTargetElementType.kt

@@ -26,11 +26,11 @@ import org.jetbrains.kotlin.psi.stubs.KotlinAnnotationUseSiteTargetStub
 import org.jetbrains.kotlin.psi.stubs.impl.KotlinAnnotationUseSiteTargetStubImpl
 
 public class KtAnnotationUseSiteTargetElementType(debugName: String) : KtStubElementType<KotlinAnnotationUseSiteTargetStub, KtAnnotationUseSiteTarget>(
-        debugName, javaClass<KtAnnotationUseSiteTarget>(), javaClass<KotlinAnnotationUseSiteTargetStub>()
+        debugName, KtAnnotationUseSiteTarget::class.java, KotlinAnnotationUseSiteTargetStub::class.java
 ) {
 
     override fun createStub(psi: KtAnnotationUseSiteTarget, parentStub: StubElement<PsiElement>): KotlinAnnotationUseSiteTargetStub {
-        val useSiteTarget = psi.getAnnotationUseSiteTarget().name()
+        val useSiteTarget = psi.getAnnotationUseSiteTarget().name
         return KotlinAnnotationUseSiteTargetStubImpl(parentStub, StringRef.fromString(useSiteTarget)!!)
     }
 

compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/KtEnumEntrySuperClassReferenceExpressionElementType.kt

@@ -28,8 +28,8 @@ import org.jetbrains.kotlin.psi.stubs.impl.KotlinEnumEntrySuperclassReferenceExp
 public class KtEnumEntrySuperClassReferenceExpressionElementType(@NonNls debugName: String)
     : KtStubElementType<KotlinEnumEntrySuperclassReferenceExpressionStub, KtEnumEntrySuperclassReferenceExpression>(
         debugName,
-        javaClass<KtEnumEntrySuperclassReferenceExpression>(),
-        javaClass<KotlinEnumEntrySuperclassReferenceExpressionStub>()
+        KtEnumEntrySuperclassReferenceExpression::class.java,
+        KotlinEnumEntrySuperclassReferenceExpressionStub::class.java
     ) {
 
     override fun createStub(psi: KtEnumEntrySuperclassReferenceExpression, parentStub: StubElement<*>): KotlinEnumEntrySuperclassReferenceExpressionStub {

compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinStubBaseImpl.kt

@@ -75,8 +75,8 @@ public open class KotlinStubBaseImpl<T : KtElementImplStub<*>>(parent: StubEleme
     }
 
     companion object {
-        private val LOGGER: Logger = Logger.getInstance(javaClass<KotlinStubBaseImpl<KtElementImplStub<*>>>())
+        private val LOGGER: Logger = Logger.getInstance(KotlinStubBaseImpl::class.java)
 
-        private val BASE_STUB_INTERFACES = listOf(javaClass<KotlinStubWithFqName<*>>(), javaClass<KotlinClassOrObjectStub<*>>(), javaClass<NamedStub<*>>(), javaClass<KotlinCallableStubBase<*>>())
+        private val BASE_STUB_INTERFACES = listOf(KotlinStubWithFqName::class.java, KotlinClassOrObjectStub::class.java, NamedStub::class.java, KotlinCallableStubBase::class.java)
     }
 }

compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/ModifierMaskUtils.kt

@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.lexer.KtModifierKeywordToken
 
 public object ModifierMaskUtils {
     init {
-        assert(MODIFIER_KEYWORDS_ARRAY.size() <= 32) { "Current implementation depends on the ability to represent modifier list as bit mask" }
+        assert(MODIFIER_KEYWORDS_ARRAY.size <= 32) { "Current implementation depends on the ability to represent modifier list as bit mask" }
     }
 
     @JvmStatic

compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/Utils.kt

@@ -20,6 +20,6 @@ import com.intellij.util.io.StringRef
 
 object Utils {
     fun wrapStrings(names : List<String>) : Array<StringRef> {
-        return Array(names.size()) { i -> StringRef.fromString(names.get(i))!! }
+        return Array(names.size) { i -> StringRef.fromString(names.get(i))!! }
     }
 }

compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationChecker.kt

@@ -157,7 +157,7 @@ public class AnnotationChecker(private val additionalCheckers: Iterable<Addition
             val targetEntryDescriptor = classDescriptor.annotations.findAnnotation(KotlinBuiltIns.FQ_NAMES.target)
                                         ?: return null
             val valueArguments = targetEntryDescriptor.allValueArguments
-            val valueArgument = valueArguments.entrySet().firstOrNull()?.getValue() as? ArrayValue ?: return null
+            val valueArgument = valueArguments.entries.firstOrNull()?.value as? ArrayValue ?: return null
             return valueArgument.value.filterIsInstance<EnumValue>().mapNotNull {
                 KotlinTarget.valueOrNull(it.value.name.asString())
             }.toSet()

compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationUtil.kt

@@ -52,7 +52,7 @@ private fun CallableDescriptor.isPlatformStaticIn(predicate: (DeclarationDescrip
         }
 
 public fun AnnotationDescriptor.argumentValue(parameterName: String): Any? {
-    return getAllValueArguments().entrySet()
+    return getAllValueArguments().entries
             .singleOrNull { it.key.getName().asString() == parameterName }
             ?.value?.value
 }

compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingContextUtils.kt

@@ -42,10 +42,10 @@ public fun KtReturnExpression.getTargetFunctionDescriptor(context: BindingContex
     if (targetLabel != null) return context[LABEL_TARGET, targetLabel]?.let { context[FUNCTION, it] }
 
     val declarationDescriptor = context[DECLARATION_TO_DESCRIPTOR, getNonStrictParentOfType<KtDeclarationWithBody>()]
-    val containingFunctionDescriptor = DescriptorUtils.getParentOfType(declarationDescriptor, javaClass<FunctionDescriptor>(), false)
+    val containingFunctionDescriptor = DescriptorUtils.getParentOfType(declarationDescriptor, FunctionDescriptor::class.java, false)
     if (containingFunctionDescriptor == null) return null
 
-    return sequence(containingFunctionDescriptor) { DescriptorUtils.getParentOfType(it, javaClass<FunctionDescriptor>()) }
+    return sequence(containingFunctionDescriptor) { DescriptorUtils.getParentOfType(it, FunctionDescriptor::class.java) }
             .dropWhile { it is AnonymousFunctionDescriptor }
             .firstOrNull()
 }

compiler/frontend/src/org/jetbrains/kotlin/resolve/CodeAnalyzerInitializer.kt

@@ -27,7 +27,7 @@ public interface CodeAnalyzerInitializer {
     
     companion object {
         public fun getInstance(project: Project): CodeAnalyzerInitializer =
-                ServiceManager.getService<CodeAnalyzerInitializer>(project, javaClass<CodeAnalyzerInitializer>())!!
+                ServiceManager.getService<CodeAnalyzerInitializer>(project, CodeAnalyzerInitializer::class.java)!!
     }
 }
 

compiler/frontend/src/org/jetbrains/kotlin/resolve/CompositeBindingContext.kt

@@ -36,7 +36,7 @@ public class CompositeBindingContext private constructor(
     companion object {
         public fun create(delegates: List<BindingContext>): BindingContext {
             if (delegates.isEmpty()) return BindingContext.EMPTY
-            if (delegates.size() == 1) return delegates.first()
+            if (delegates.size == 1) return delegates.first()
             return CompositeBindingContext(delegates)
         }
     }

compiler/frontend/src/org/jetbrains/kotlin/resolve/DataClassUtils.kt

@@ -34,7 +34,7 @@ public fun isComponentLike(name: Name): Boolean {
 }
 
 public fun getComponentIndex(componentName: Name): Int =
-    componentName.asString().substring(COMPONENT_FUNCTION_NAME_PREFIX.length()).toInt()
+    componentName.asString().substring(COMPONENT_FUNCTION_NAME_PREFIX.length).toInt()
 
 public fun createComponentName(index: Int): Name =
     Name.identifier(COMPONENT_FUNCTION_NAME_PREFIX + index)

compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationResolver.kt

@@ -51,7 +51,7 @@ public class DeclarationResolver(
     }
 
     public fun checkRedeclarations(c: TopDownAnalysisContext) {
-        for (classDescriptor in c.getDeclaredClasses().values()) {
+        for (classDescriptor in c.getDeclaredClasses().values) {
             val descriptorMap = HashMultimap.create<Name, DeclarationDescriptor>()
             for (desc in classDescriptor.getUnsubstitutedMemberScope().getContributedDescriptors()) {
                 if (desc is ClassDescriptor || desc is PropertyDescriptor) {
@@ -67,7 +67,7 @@ public class DeclarationResolver(
         val redeclarations = Sets.newHashSet<Pair<PsiElement, Name>>()
         for (name in descriptorMap.keySet()) {
             val descriptors = descriptorMap[name]
-            if (descriptors.size() <= 1) {
+            if (descriptors.size <= 1) {
                 continue
             }
             // We mustn't compare PropertyDescriptor with PropertyDescriptor because we do this at OverloadResolver
@@ -97,7 +97,7 @@ public class DeclarationResolver(
 
             val descriptors = getTopLevelDescriptorsByFqName(topLevelDescriptorProvider, fqName, NoLookupLocation.WHEN_CHECK_REDECLARATIONS)
 
-            if (descriptors.size() > 1) {
+            if (descriptors.size > 1) {
                 for (declarationOrPackageDirective in declarationsOrPackageDirectives) {
                     val reportAt =
                             if (declarationOrPackageDirective is KtPackageDirective) declarationOrPackageDirective.getNameIdentifier()

compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorToSourceUtils.kt

@@ -67,7 +67,7 @@ public object DescriptorToSourceUtils {
     @JvmStatic
     public fun descriptorToDeclaration(descriptor: DeclarationDescriptor): PsiElement? {
         val effectiveReferencedDescriptors = getEffectiveReferencedDescriptors(descriptor)
-        return if (effectiveReferencedDescriptors.size() == 1) getSourceFromDescriptor(effectiveReferencedDescriptors.firstOrNull()!!) else null
+        return if (effectiveReferencedDescriptors.size == 1) getSourceFromDescriptor(effectiveReferencedDescriptors.firstOrNull()!!) else null
     }
 
     @JvmStatic

compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt

@@ -195,7 +195,7 @@ class FunctionDescriptorResolver(
     ): List<ValueParameterDescriptor> {
         val expectedValueParameters = expectedFunctionType.getValueParameters(functionDescriptor)
         if (expectedValueParameters != null) {
-            if (expectedValueParameters.size() == 1 && function is KtFunctionLiteral && function.getValueParameterList() == null) {
+            if (expectedValueParameters.size == 1 && function is KtFunctionLiteral && function.getValueParameterList() == null) {
                 // it parameter for lambda
                 val valueParameterDescriptor = expectedValueParameters.first()
                 val it = ValueParameterDescriptorImpl(functionDescriptor, null, 0, Annotations.EMPTY, Name.identifier("it"),
@@ -205,9 +205,9 @@ class FunctionDescriptorResolver(
                 trace.record(BindingContext.AUTO_CREATED_IT, it)
                 return listOf(it)
             }
-            if (function.getValueParameters().size() != expectedValueParameters.size()) {
+            if (function.getValueParameters().size != expectedValueParameters.size) {
                 val expectedParameterTypes = ExpressionTypingUtils.getValueParametersTypes(expectedValueParameters)
-                trace.report(EXPECTED_PARAMETERS_NUMBER_MISMATCH.on(function, expectedParameterTypes.size(), expectedParameterTypes))
+                trace.report(EXPECTED_PARAMETERS_NUMBER_MISMATCH.on(function, expectedParameterTypes.size, expectedParameterTypes))
             }
         }
 
@@ -313,7 +313,7 @@ class FunctionDescriptorResolver(
         for (i in valueParameters.indices) {
             val valueParameter = valueParameters.get(i)
             val typeReference = valueParameter.getTypeReference()
-            val expectedType = expectedValueParameters?.let { if (i < it.size()) it[i].getType() else null }
+            val expectedType = expectedValueParameters?.let { if (i < it.size) it[i].getType() else null }
 
             val type: KotlinType
             if (typeReference != null) {

compiler/frontend/src/org/jetbrains/kotlin/resolve/QualifiedExpressionResolver.kt

@@ -83,12 +83,12 @@ public class QualifiedExpressionResolver(val symbolUsageValidator: SymbolUsageVa
             ) as? ClassifierDescriptor
             return TypeQualifierResolutionResult(qualifierPartList, descriptor)
         }
-        assert(qualifierPartList.size() >= 1) {
+        assert(qualifierPartList.size >= 1) {
             "Too short qualifier list for user type $userType : ${qualifierPartList.joinToString()}"
         }
 
         val qualifier = resolveToPackageOrClass(
-                qualifierPartList.subList(0, qualifierPartList.size() - 1), module,
+                qualifierPartList.subList(0, qualifierPartList.size - 1), module,
                 trace, scope.ownerDescriptor, scope.check { !userType.startWithPackage }, position = QualifierPosition.TYPE
         ) ?: return TypeQualifierResolutionResult(qualifierPartList, null)
 
@@ -170,7 +170,7 @@ public class QualifiedExpressionResolver(val symbolUsageValidator: SymbolUsageVa
         }
 
         val packageOrClassDescriptor = resolveToPackageOrClass(
-                path.subList(0, path.size() - 1), moduleDescriptor, trace,
+                path.subList(0, path.size - 1), moduleDescriptor, trace,
                 packageFragmentForVisibilityCheck, scopeForFirstPart = null, position = QualifierPosition.IMPORT
         ) ?: return null
 
@@ -480,7 +480,7 @@ public class QualifiedExpressionResolver(val symbolUsageValidator: SymbolUsageVa
             trace: BindingTrace,
             position: QualifierPosition
     ): Pair<PackageViewDescriptor, Int> {
-        val possiblePackagePrefixSize = path.indexOfFirst { it.typeArguments != null }.let { if (it == -1) path.size() else it + 1 }
+        val possiblePackagePrefixSize = path.indexOfFirst { it.typeArguments != null }.let { if (it == -1) path.size else it + 1 }
         var fqName = path.subList(0, possiblePackagePrefixSize).fold(FqName.ROOT) { fqName, qualifierPart ->
             fqName.child(qualifierPart.name)
         }
@@ -522,13 +522,13 @@ public class QualifiedExpressionResolver(val symbolUsageValidator: SymbolUsageVa
             position: QualifierPosition,
             isQualifier: Boolean = true
     ) {
-        if (descriptors.size() > 1) {
+        if (descriptors.size > 1) {
             val visibleDescriptors = descriptors.filter { isVisible(it, shouldBeVisibleFrom, position) }
             if (visibleDescriptors.isEmpty()) {
                 val descriptor = descriptors.first() as DeclarationDescriptorWithVisibility
                 trace.report(Errors.INVISIBLE_REFERENCE.on(referenceExpression, descriptor, descriptor.visibility, descriptor))
             }
-            else if (visibleDescriptors.size() > 1) {
+            else if (visibleDescriptors.size > 1) {
                 trace.record(BindingContext.AMBIGUOUS_REFERENCE_TARGET, referenceExpression, visibleDescriptors)
             }
             else {

compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeBinding.kt

@@ -76,8 +76,8 @@ private class ExplicitTypeBinding(
     override fun getArgumentBindings(): List<TypeArgumentBinding<KtTypeElement>?> {
         val psiTypeArguments = psiElement.getTypeArgumentsAsTypes()
         val isErrorBinding = run {
-            val sizeIsEqual = psiTypeArguments.size() == kotlinType.getArguments().size()
-                              && psiTypeArguments.size() == kotlinType.getConstructor().getParameters().size()
+            val sizeIsEqual = psiTypeArguments.size == kotlinType.getArguments().size
+                              && psiTypeArguments.size == kotlinType.getConstructor().getParameters().size
             kotlinType.isError() || !sizeIsEqual
         }
 
@@ -115,7 +115,7 @@ private class NoTypeElementBinding<out P : PsiElement>(
 ): TypeBinding<P> {
 
     override fun getArgumentBindings(): List<TypeArgumentBinding<P>?> {
-        val isErrorBinding = kotlinType.isError() || kotlinType.getConstructor().getParameters().size() != kotlinType.getArguments().size()
+        val isErrorBinding = kotlinType.isError() || kotlinType.getConstructor().getParameters().size != kotlinType.getArguments().size
         return kotlinType.getArguments().indices.map {
             val typeProjection = kotlinType.getArguments()[it]
             TypeArgumentBindingImpl(

compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeResolver.kt

@@ -493,7 +493,7 @@ public class TypeResolver(
             ModifierCheckerCore.check(argumentElement, c.trace, null)
             if (projectionKind == KtProjectionKind.STAR) {
                 val parameters = constructor.getParameters()
-                if (parameters.size() > i) {
+                if (parameters.size > i) {
                     val parameterDescriptor = parameters[i]
                     TypeUtils.makeStarProjection(parameterDescriptor)
                 }
@@ -504,7 +504,7 @@ public class TypeResolver(
             else {
                 val type = resolveType(c.noBareTypes(), argumentElement.getTypeReference()!!)
                 val kind = resolveProjectionKind(projectionKind)
-                if (constructor.getParameters().size() > i) {
+                if (constructor.getParameters().size > i) {
                     val parameterDescriptor = constructor.getParameters()[i]
                     if (kind != INVARIANT && parameterDescriptor.getVariance() != INVARIANT) {
                         if (kind == parameterDescriptor.getVariance()) {

compiler/frontend/src/org/jetbrains/kotlin/resolve/VarianceChecker.kt

@@ -55,7 +55,7 @@ class VarianceChecker(private val trace: BindingTrace) {
     }
 
     private fun checkClasses(c: TopDownAnalysisContext) {
-        for (jetClassOrObject in c.getDeclaredClasses()!!.keySet()) {
+        for (jetClassOrObject in c.getDeclaredClasses()!!.keys) {
             if (jetClassOrObject is KtClass) {
                 for (specifier in jetClassOrObject.getSuperTypeListEntries()) {
                     specifier.getTypeReference()?.checkTypePosition(trace.getBindingContext(), OUT_VARIANCE, trace)

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CandidateResolver.kt

@@ -121,15 +121,15 @@ public class CandidateResolver(
                 typeArguments.add(type)
             }
 
-            val expectedTypeArgumentCount = candidateDescriptor.getTypeParameters().size()
-            for (index in jetTypeArguments.size()..expectedTypeArgumentCount - 1) {
+            val expectedTypeArgumentCount = candidateDescriptor.getTypeParameters().size
+            for (index in jetTypeArguments.size..expectedTypeArgumentCount - 1) {
                 typeArguments.add(ErrorUtils.createErrorType(
                         "Explicit type argument expected for " + candidateDescriptor.getTypeParameters().get(index).getName()))
             }
             val substitution = FunctionDescriptorUtil.createSubstitution(candidateDescriptor as FunctionDescriptor, typeArguments)
             val substitutor = TypeSubstitutor.create(SubstitutionFilteringInternalResolveAnnotations(substitution))
 
-            if (expectedTypeArgumentCount != jetTypeArguments.size()) {
+            if (expectedTypeArgumentCount != jetTypeArguments.size) {
                 candidateCall.addStatus(OTHER_ERROR)
                 tracing.wrongNumberOfTypeArguments(trace, expectedTypeArgumentCount)
             }
@@ -315,9 +315,9 @@ public class CandidateResolver(
         var resultStatus = SUCCESS
         val argumentTypes = Lists.newArrayList<KotlinType>()
         val infoForArguments = candidateCall.getDataFlowInfoForArguments()
-        for (entry in candidateCall.getValueArguments().entrySet()) {
-            val parameterDescriptor = entry.getKey()
-            val resolvedArgument = entry.getValue()
+        for (entry in candidateCall.getValueArguments().entries) {
+            val parameterDescriptor = entry.key
+            val resolvedArgument = entry.value
 
 
             for (argument in resolvedArgument.getArguments()) {
@@ -507,7 +507,7 @@ public class CandidateResolver(
             substitutor: TypeSubstitutor,
             trace: BindingTrace) {
         val typeParameters = functionDescriptor.getTypeParameters()
-        for (i in 0..Math.min(typeParameters.size(), jetTypeArguments.size()) - 1) {
+        for (i in 0..Math.min(typeParameters.size, jetTypeArguments.size) - 1) {
             val typeParameterDescriptor = typeParameters.get(i)
             val typeArgument = typeArguments.get(i)
             val typeReference = jetTypeArguments.get(i).getTypeReference()

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/dynamicCalls.kt

@@ -155,7 +155,7 @@ class DynamicCallableDescriptors(private val builtIns: KotlinBuiltIns) {
         val parameters = ArrayList<ValueParameterDescriptor>()
 
         fun addParameter(arg : ValueArgument, outType: KotlinType, varargElementType: KotlinType?) {
-            val index = parameters.size()
+            val index = parameters.size
 
             parameters.add(ValueParameterDescriptorImpl(
                     owner,

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/util/callUtil.kt

@@ -45,7 +45,7 @@ public fun <D : CallableDescriptor> ResolvedCall<D>.hasUnmappedArguments(): Bool
 
 public fun <D : CallableDescriptor> ResolvedCall<D>.hasUnmappedParameters(): Boolean {
     val parameterToArgumentMap = getValueArguments()
-    return !parameterToArgumentMap.keySet().containsAll(getResultingDescriptor().getValueParameters())
+    return !parameterToArgumentMap.keys.containsAll(getResultingDescriptor().getValueParameters())
 }
 
 public fun <D : CallableDescriptor> ResolvedCall<D>.allArgumentsMapped()
@@ -144,8 +144,8 @@ public fun KtElement.getCall(context: BindingContext): Call? {
 
 public fun KtElement.getParentCall(context: BindingContext, strict: Boolean = true): Call? {
     val callExpressionTypes = arrayOf<Class<out KtElement>?>(
-            javaClass<KtSimpleNameExpression>(), javaClass<KtCallElement>(), javaClass<KtBinaryExpression>(),
-            javaClass<KtUnaryExpression>(), javaClass<KtArrayAccessExpression>())
+            KtSimpleNameExpression::class.java, KtCallElement::class.java, KtBinaryExpression::class.java,
+            KtUnaryExpression::class.java, KtArrayAccessExpression::class.java)
 
     val parent = if (strict) {
         PsiTreeUtil.getParentOfType(this, *callExpressionTypes)

compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/ConstantExpressionEvaluator.kt

@@ -367,7 +367,7 @@ private class ConstantExpressionEvaluatorVisitor(
         val leftExpression = expression.left ?: return null
 
         val operationToken = expression.operationToken
-        if (OperatorConventions.BOOLEAN_OPERATIONS.containsKeyRaw(operationToken)) {
+        if (OperatorConventions.BOOLEAN_OPERATIONS.containsKey(operationToken)) {
             val booleanType = constantExpressionEvaluator.builtIns.booleanType
             val leftConstant = evaluate(leftExpression, booleanType) ?: return null