Clean up quick fix package

idea/src/org/jetbrains/kotlin/idea/quickfix/AddFunctionBodyFix.kt

@@ -41,7 +41,7 @@ class AddFunctionBodyFix(element: KtFunction) : KotlinQuickFixAction<KtFunction>
 
     companion object : KotlinSingleIntentionActionFactory() {
         public override fun createAction(diagnostic: Diagnostic): AddFunctionBodyFix? {
-            return diagnostic.psiElement.getNonStrictParentOfType<KtFunction>()?.let { AddFunctionBodyFix(it) }
+            return diagnostic.psiElement.getNonStrictParentOfType<KtFunction>()?.let(::AddFunctionBodyFix)
         }
     }
 }

idea/src/org/jetbrains/kotlin/idea/quickfix/AddStarProjectionsFix.kt

@@ -19,10 +19,8 @@ package org.jetbrains.kotlin.idea.quickfix
 import com.intellij.codeInsight.intention.IntentionAction
 import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.project.Project
-import com.intellij.psi.PsiFile
 import org.jetbrains.kotlin.diagnostics.Diagnostic
 import org.jetbrains.kotlin.diagnostics.Errors
-import org.jetbrains.kotlin.idea.core.quickfix.QuickFixUtil
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.types.expressions.TypeReconstructionUtil
 import org.jetbrains.kotlin.utils.sure

idea/src/org/jetbrains/kotlin/idea/quickfix/AddWhenElseBranchFix.kt

@@ -43,7 +43,7 @@ class AddWhenElseBranchFix(element: KtWhenExpression) : KotlinQuickFixAction<KtW
 
     companion object : KotlinSingleIntentionActionFactory() {
         public override fun createAction(diagnostic: Diagnostic): AddWhenElseBranchFix? {
-            return diagnostic.psiElement.getNonStrictParentOfType<KtWhenExpression>()?.let { AddWhenElseBranchFix(it) }
+            return diagnostic.psiElement.getNonStrictParentOfType<KtWhenExpression>()?.let(::AddWhenElseBranchFix)
         }
     }
 }

idea/src/org/jetbrains/kotlin/idea/quickfix/AutoImportFix.kt

@@ -53,6 +53,7 @@ import org.jetbrains.kotlin.util.OperatorNameConventions
 import org.jetbrains.kotlin.utils.CachedValueProperty
 import org.jetbrains.kotlin.utils.addToStdlib.singletonList
 import org.jetbrains.kotlin.utils.addToStdlib.singletonOrEmptyList
+import java.lang.IllegalStateException
 import java.util.*
 
 /**
@@ -214,7 +215,7 @@ internal class AutoImportFix(expression: KtSimpleNameExpression) : AutoImportFix
 
     companion object : KotlinSingleIntentionActionFactory() {
         override fun createAction(diagnostic: Diagnostic) =
-                (diagnostic.psiElement as? KtSimpleNameExpression)?.let { AutoImportFix(it) }
+                (diagnostic.psiElement as? KtSimpleNameExpression)?.let(::AutoImportFix)
 
         override fun isApplicableForCodeFragment() = true
 
@@ -231,7 +232,7 @@ internal class MissingInvokeAutoImportFix(expression: KtExpression) : AutoImport
 
     companion object : KotlinSingleIntentionActionFactory() {
         override fun createAction(diagnostic: Diagnostic) =
-                (diagnostic.psiElement as? KtExpression)?.let { MissingInvokeAutoImportFix(it) }
+                (diagnostic.psiElement as? KtExpression)?.let(::MissingInvokeAutoImportFix)
 
         private val ERRORS by lazy(LazyThreadSafetyMode.PUBLICATION) { QuickFixes.getInstance().getDiagnostics(this) }
     }

idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeAccessorTypeFix.kt

@@ -61,7 +61,7 @@ class ChangeAccessorTypeFix(element: KtPropertyAccessor) : KotlinQuickFixAction<
 
     companion object : KotlinSingleIntentionActionFactory() {
         public override fun createAction(diagnostic: Diagnostic): ChangeAccessorTypeFix? {
-            return diagnostic.psiElement.getNonStrictParentOfType<KtPropertyAccessor>()?.let { ChangeAccessorTypeFix(it) }
+            return diagnostic.psiElement.getNonStrictParentOfType<KtPropertyAccessor>()?.let(::ChangeAccessorTypeFix)
         }
     }
 }

idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeVariableTypeFix.kt

@@ -25,9 +25,9 @@ import org.jetbrains.kotlin.diagnostics.Diagnostic
 import org.jetbrains.kotlin.idea.KotlinBundle
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptor
+import org.jetbrains.kotlin.idea.core.ShortenReferences
 import org.jetbrains.kotlin.idea.core.quickfix.QuickFixUtil
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
-import org.jetbrains.kotlin.idea.core.ShortenReferences
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
@@ -42,7 +42,7 @@ class ChangeVariableTypeFix(element: KtVariableDeclaration, type: KotlinType) :
     private val typeSourceCode = IdeDescriptorRenderers.SOURCE_CODE.renderType(type)
 
     override fun getText(): String {
-        var propertyName = element.fqName?.asString() ?: element.name
+        val propertyName = element.fqName?.asString() ?: element.name
         return "Change '$propertyName' type to '$typePresentation'"
     }
 

idea/src/org/jetbrains/kotlin/idea/quickfix/CommaInWhenConditionWithoutArgumentFix.kt

@@ -38,9 +38,7 @@ class CommaInWhenConditionWithoutArgumentFix(element: PsiElement) : KotlinQuickF
 
     companion object : KotlinSingleIntentionActionFactory() {
         override fun createAction(diagnostic: Diagnostic): IntentionAction? =
-                diagnostic.psiElement.parent?.parent?.let { whenExpressionElement ->
+                diagnostic.psiElement.parent?.parent?.let(::CommaInWhenConditionWithoutArgumentFix)
-                    CommaInWhenConditionWithoutArgumentFix(whenExpressionElement)
-                }
 
         private class WhenEntryConditionsData(
                 val conditions: Array<KtWhenCondition>,

idea/src/org/jetbrains/kotlin/idea/quickfix/KotlinReferenceImporter.kt

@@ -87,7 +87,7 @@ class KotlinReferenceImporter : ReferenceImporter {
             val bindingContext = analyze(BodyResolveMode.PARTIAL)
             if (mainReference.resolveToDescriptors(bindingContext).isNotEmpty()) return false
 
-            var suggestions = AutoImportFix(this).computeSuggestions()
+            val suggestions = AutoImportFix(this).computeSuggestions()
 
             if (suggestions.distinctBy { it.importableFqName!! }.size != 1) return false
 

idea/src/org/jetbrains/kotlin/idea/quickfix/MakeVisibleFactory.kt

@@ -19,7 +19,6 @@ package org.jetbrains.kotlin.idea.quickfix
 import com.intellij.codeInsight.intention.IntentionAction
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptorWithVisibility
-import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.descriptors.Visibilities.*
 import org.jetbrains.kotlin.diagnostics.Diagnostic
 import org.jetbrains.kotlin.diagnostics.DiagnosticFactory3

idea/src/org/jetbrains/kotlin/idea/quickfix/ReplaceInfixOrOperatorCallFix.kt

@@ -19,15 +19,12 @@ package org.jetbrains.kotlin.idea.quickfix
 import com.intellij.codeInsight.intention.IntentionAction
 import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.project.Project
-import com.intellij.psi.tree.TokenSet
 import org.jetbrains.kotlin.diagnostics.Diagnostic
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.intentions.OperatorToFunctionIntention
 import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getAssignmentByLHS
-import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType
-import org.jetbrains.kotlin.psi.psiUtil.parents
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.types.expressions.OperatorConventions
 import org.jetbrains.kotlin.types.typeUtil.isBoolean

idea/src/org/jetbrains/kotlin/idea/quickfix/SimplifyComparisonFix.kt

@@ -19,7 +19,6 @@ package org.jetbrains.kotlin.idea.quickfix
 import com.intellij.codeInsight.intention.IntentionAction
 import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.project.Project
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.diagnostics.Diagnostic
 import org.jetbrains.kotlin.diagnostics.DiagnosticWithParameters2
 import org.jetbrains.kotlin.idea.intentions.SimplifyBooleanWithConstantsIntention

idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/CallableBuilder.kt

@@ -73,8 +73,10 @@ import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
 import org.jetbrains.kotlin.types.typeUtil.isAnyOrNullableAny
 import org.jetbrains.kotlin.types.typeUtil.isUnit
 import org.jetbrains.kotlin.utils.addToStdlib.singletonOrEmptyList
+import java.lang.AssertionError
+import java.lang.IllegalArgumentException
+import java.lang.IllegalStateException
 import java.util.*
-import kotlin.properties.Delegates
 
 /**
  * Represents a single choice for a type (e.g. parameter type or return type).
@@ -168,14 +170,14 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
                 override fun hashCode() = 0 // no good way to compute hashCode() that would agree with our equals()
             }
 
-            val newTypes = LinkedHashSet(types.map { EqWrapper(it) })
+            val newTypes = LinkedHashSet(types.map(::EqWrapper))
             for (substitution in substitutions) {
                 // each substitution can be applied or not, so we offer all options
                 val toAdd = newTypes.map { it._type.substitute(substitution, typeInfo.variance) }
                 // substitution.byType are type arguments, but they cannot already occur in the type before substitution
                 val toRemove = newTypes.filter { substitution.byType in it._type }
 
-                newTypes.addAll(toAdd.map { EqWrapper(it) })
+                newTypes.addAll(toAdd.map(::EqWrapper))
                 newTypes.removeAll(toRemove)
             }
 
@@ -514,7 +516,7 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
                 }
 
                 if (assignmentToReplace != null) {
-                    (declaration as KtProperty).setInitializer(assignmentToReplace.right)
+                    (declaration as KtProperty).initializer = assignmentToReplace.right
                     return assignmentToReplace.replace(declaration) as KtCallableDeclaration
                 }
 

idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/templateExpressions.kt

@@ -32,9 +32,8 @@ import org.jetbrains.kotlin.idea.core.KotlinNameSuggester
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
 import org.jetbrains.kotlin.psi.psiUtil.getValueParameters
-import java.util.Collections
+import java.lang.AssertionError
-import java.util.HashSet
+import java.util.*
-import java.util.LinkedHashSet
 
 /**
  * Special <code>Expression</code> for parameter names based on its type.
@@ -43,7 +42,7 @@ internal class ParameterNameExpression(
         private val names: Array<String>,
         private val parameterTypeToNamesMap: Map<String, Array<String>>) : Expression() {
     init {
-        assert(names.all { it.isNotEmpty() })
+        assert(names.all(String::isNotEmpty))
     }
 
     override fun calculateResult(context: ExpressionContext?): Result? {

idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateCallableFromCallActionFactory.kt

@@ -44,6 +44,7 @@ import org.jetbrains.kotlin.resolve.scopes.receivers.*
 import org.jetbrains.kotlin.resolve.source.getPsi
 import org.jetbrains.kotlin.types.Variance
 import org.jetbrains.kotlin.types.typeUtil.isSubtypeOf
+import java.lang.AssertionError
 import java.util.*
 
 sealed class CreateCallableFromCallActionFactory<E : KtExpression>(
@@ -296,8 +297,8 @@ sealed class CreateCallableFromCallActionFactory<E : KtExpression>(
             if ((klass !is KtClass && klass !is PsiClass) || !klass.canRefactor()) return null
 
             val expectedType = context[BindingContext.EXPECTED_EXPRESSION_TYPE, expression.getQualifiedExpressionForSelectorOrThis()]
-                               ?: classDescriptor!!.builtIns.nullableAnyType
+                               ?: classDescriptor.builtIns.nullableAnyType
-            if (!classDescriptor!!.defaultType.isSubtypeOf(expectedType)) return null
+            if (!classDescriptor.defaultType.isSubtypeOf(expectedType)) return null
 
             val parameters = expression.getParameterInfos()
 

idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createClass/createClassUtils.kt

@@ -25,12 +25,12 @@ import com.intellij.psi.PsiPackage
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.idea.KotlinBundle
 import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde
-import org.jetbrains.kotlin.idea.refactoring.canRefactor
 import org.jetbrains.kotlin.idea.quickfix.DelegatingIntentionAction
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.TypeInfo
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.containsStarProjections
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.guessTypes
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.noSubstitutions
+import org.jetbrains.kotlin.idea.refactoring.canRefactor
 import org.jetbrains.kotlin.psi.Call
 import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.psi.KtFile
@@ -41,6 +41,7 @@ import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.scopes.receivers.Qualifier
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
 import org.jetbrains.kotlin.types.Variance
+import java.lang.AssertionError
 import org.jetbrains.kotlin.descriptors.ClassKind as ClassDescriptorKind
 
 internal fun String.checkClassName(): Boolean = isNotEmpty() && Character.isUpperCase(first())
@@ -110,20 +111,20 @@ internal fun KtSimpleNameExpression.getCreatePackageFixIfApplicable(targetParent
     val name = getReferencedName()
     if (!name.checkPackageName()) return null
 
-    val basePackage: PsiPackage? =
+    val basePackage: PsiPackage =
             when (targetParent) {
                 is KtFile -> JavaPsiFacade.getInstance(targetParent.project).findPackage(targetParent.packageFqName.asString())
                 is PsiPackage -> targetParent
                 else -> null
             }
-    if (basePackage == null) return null
+            ?: return null
 
     val baseName = basePackage.qualifiedName
     val fullName = if (baseName.isNotEmpty()) "$baseName.$name" else name
 
     val javaFix = CreateClassOrPackageFix.createFix(fullName, resolveScope, this, basePackage, null, null, null) ?: return null
 
-    return object: DelegatingIntentionAction(javaFix) {
+    return object : DelegatingIntentionAction(javaFix) {
         override fun getFamilyName(): String = KotlinBundle.message("create.from.usage.family")
 
         override fun getText(): String = "Create package '$fullName'"

idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/CallableUsageReplacementStrategy.kt

@@ -161,7 +161,7 @@ private fun performCallReplacement(
     }
 
     val wrappedExpression = callKindHandler.wrapGeneratedExpression(wrapper.expression)
-    var result = elementToBeReplaced.replace(wrappedExpression) as KtElement
+    val result = elementToBeReplaced.replace(wrappedExpression) as KtElement
 
     val file = result.getContainingKtFile()
     replacement.fqNamesToImport

idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/ClassUsageReplacementStrategy.kt

@@ -17,8 +17,8 @@
 package org.jetbrains.kotlin.idea.quickfix.replaceWith
 
 import com.intellij.openapi.project.Project
-import org.jetbrains.kotlin.idea.core.replaced
 import org.jetbrains.kotlin.idea.core.ShortenReferences
+import org.jetbrains.kotlin.idea.core.replaced
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getQualifiedExpressionForSelectorOrThis
 import org.jetbrains.kotlin.utils.addToStdlib.check
@@ -34,7 +34,7 @@ class ClassUsageReplacementStrategy(
     private val typeReplacement = typeReplacement?.check { it.referenceExpression != null }
     private val typeReplacementQualifierAsExpression = typeReplacement?.qualifier?.let { factory.createExpression(it.text) }
 
-    private val constructorReplacementStrategy = constructorReplacement?.let { CallableUsageReplacementStrategy(it) }
+    private val constructorReplacementStrategy = constructorReplacement?.let(::CallableUsageReplacementStrategy)
 
     override fun createReplacer(usage: KtSimpleNameExpression): (() -> KtElement)? {
         if (usage !is KtNameReferenceExpression) return null

idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/ReplaceWithAnnotationAnalyzer.kt

@@ -225,9 +225,9 @@ object ReplaceWithAnnotationAnalyzer {
     private fun importFqNames(annotation: ReplaceWith): List<FqName> {
         return annotation.imports
                 .filter { FqNameUnsafe.isValid(it) }
-                .map { FqNameUnsafe(it) }
+                .map(::FqNameUnsafe)
-                .filter { it.isSafe }
+                .filter(FqNameUnsafe::isSafe)
-                .map { it.toSafe() }
+                .map(FqNameUnsafe::toSafe)
     }
 
     private fun analyzeInContext(