Refactoring: Use modifier list in CallableInfo where possible

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

@@ -501,9 +501,7 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
                         }
                         @Suppress("USELESS_CAST") // KT-10755
                         if (callableInfo is FunctionInfo) {
-                            val operatorModifier = if (callableInfo.isOperator) "operator " else ""
+                            psiFactory.createFunction("${modifiers}fun<> $header $body") as KtNamedDeclaration
-                            val infixModifier = if (callableInfo.isInfix) "infix " else ""
-                            psiFactory.createFunction("$modifiers$infixModifier${operatorModifier}fun<> $header $body") as KtNamedDeclaration
                         }
                         else if ((callableInfo as ConstructorInfo).isPrimary) {
                             val constructorText = if (modifiers.isNotEmpty()) "${modifiers}constructor$paramList" else paramList
@@ -646,6 +644,13 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
                 if (TypeUtils.isNullableType(returnType) || KotlinBuiltIns.isPrimitiveType(returnType)) return
                 declaration.addModifier(KtTokens.LATEINIT_KEYWORD)
             }
+
+            if (callableInfo.isAbstract) {
+                val containingClass = declaration.containingClassOrObject
+                if (containingClass is KtClass && containingClass.isInterface()) {
+                    declaration.removeModifier(KtTokens.ABSTRACT_KEYWORD)
+                }
+            }
         }
 
         private fun setupDeclarationBody(func: KtDeclarationWithBody) {

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

@@ -24,6 +24,7 @@ import org.jetbrains.kotlin.idea.core.KotlinNameSuggester
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.createClass.ClassInfo
 import org.jetbrains.kotlin.idea.util.getResolutionScope
 import org.jetbrains.kotlin.idea.util.getResolvableApproximations
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
@@ -177,16 +178,17 @@ abstract class CallableInfo (
         val returnTypeInfo: TypeInfo,
         val possibleContainers: List<KtElement>,
         val typeParameterInfos: List<TypeInfo>,
-        val isAbstract: Boolean = false,
         val isForCompanion: Boolean = false,
         val modifierList: KtModifierList? = null
 ) {
     abstract val kind: CallableKind
     abstract val parameterInfos: List<ParameterInfo>
 
+    val isAbstract get() = modifierList?.hasModifier(KtTokens.ABSTRACT_KEYWORD) == true
+
     abstract fun copy(receiverTypeInfo: TypeInfo = this.receiverTypeInfo,
                       possibleContainers: List<KtElement> = this.possibleContainers,
-                      isAbstract: Boolean = this.isAbstract): CallableInfo
+                      modifierList: KtModifierList? = this.modifierList): CallableInfo
 }
 
 class FunctionInfo(name: String,
@@ -195,25 +197,25 @@ class FunctionInfo(name: String,
                    possibleContainers: List<KtElement> = Collections.emptyList(),
                    override val parameterInfos: List<ParameterInfo> = Collections.emptyList(),
                    typeParameterInfos: List<TypeInfo> = Collections.emptyList(),
-                   val isOperator: Boolean = false,
-                   val isInfix: Boolean = false,
-                   isAbstract: Boolean = false,
                    isForCompanion: Boolean = false,
                    modifierList: KtModifierList? = null,
                    val preferEmptyBody: Boolean = false
-) : CallableInfo(name, receiverTypeInfo, returnTypeInfo, possibleContainers, typeParameterInfos, isAbstract, isForCompanion, modifierList) {
+) : CallableInfo(name, receiverTypeInfo, returnTypeInfo, possibleContainers, typeParameterInfos, isForCompanion, modifierList) {
     override val kind: CallableKind get() = CallableKind.FUNCTION
 
-    override fun copy(receiverTypeInfo: TypeInfo, possibleContainers: List<KtElement>, isAbstract: Boolean) = FunctionInfo(
+    override fun copy(
+            receiverTypeInfo: TypeInfo,
+            possibleContainers: List<KtElement>,
+            modifierList: KtModifierList?
+    ) = FunctionInfo(
             name,
             receiverTypeInfo,
             returnTypeInfo,
             possibleContainers,
             parameterInfos,
             typeParameterInfos,
-            isOperator,
+            isForCompanion,
-            isInfix,
+            modifierList
-            isAbstract
     )
 }
 
@@ -227,7 +229,11 @@ class ClassWithPrimaryConstructorInfo(
     override val kind: CallableKind get() = CallableKind.CLASS_WITH_PRIMARY_CONSTRUCTOR
     override val parameterInfos: List<ParameterInfo> get() = classInfo.parameterInfos
 
-    override fun copy(receiverTypeInfo: TypeInfo, possibleContainers: List<KtElement>, isAbstract: Boolean) = throw UnsupportedOperationException()
+    override fun copy(
+            receiverTypeInfo: TypeInfo,
+            possibleContainers: List<KtElement>,
+            modifierList: KtModifierList?
+    ) = throw UnsupportedOperationException()
 }
 
 class ConstructorInfo(
@@ -239,7 +245,11 @@ class ConstructorInfo(
 ): CallableInfo("", TypeInfo.Empty, TypeInfo.Empty, Collections.emptyList(), Collections.emptyList(), false, modifierList = modifierList) {
     override val kind: CallableKind get() = CallableKind.CONSTRUCTOR
 
-    override fun copy(receiverTypeInfo: TypeInfo, possibleContainers: List<KtElement>, isAbstract: Boolean) = throw UnsupportedOperationException()
+    override fun copy(
+            receiverTypeInfo: TypeInfo,
+            possibleContainers: List<KtElement>,
+            modifierList: KtModifierList?
+    ) = throw UnsupportedOperationException()
 }
 
 class PropertyInfo(name: String,
@@ -248,22 +258,24 @@ class PropertyInfo(name: String,
                    val writable: Boolean,
                    possibleContainers: List<KtElement> = Collections.emptyList(),
                    typeParameterInfos: List<TypeInfo> = Collections.emptyList(),
-                   isAbstract: Boolean = false,
                    val isLateinitPreferred: Boolean = false,
                    isForCompanion: Boolean = false,
                    modifierList: KtModifierList? = null,
                    val withInitializer: Boolean = false
-) : CallableInfo(name, receiverTypeInfo, returnTypeInfo, possibleContainers, typeParameterInfos, isAbstract, isForCompanion, modifierList) {
+) : CallableInfo(name, receiverTypeInfo, returnTypeInfo, possibleContainers, typeParameterInfos, isForCompanion, modifierList) {
     override val kind: CallableKind get() = CallableKind.PROPERTY
     override val parameterInfos: List<ParameterInfo> get() = Collections.emptyList()
 
-    override fun copy(receiverTypeInfo: TypeInfo, possibleContainers: List<KtElement>, isAbstract: Boolean) =
+    override fun copy(
-            copyProperty(receiverTypeInfo, possibleContainers, isAbstract)
+            receiverTypeInfo: TypeInfo,
+            possibleContainers: List<KtElement>,
+            modifierList: KtModifierList?
+    ) = copyProperty(receiverTypeInfo, possibleContainers, modifierList)
 
     fun copyProperty(
             receiverTypeInfo: TypeInfo = this.receiverTypeInfo,
             possibleContainers: List<KtElement> = this.possibleContainers,
-            isAbstract: Boolean = this.isAbstract,
+            modifierList: KtModifierList? = this.modifierList,
             isLateinitPreferred: Boolean = this.isLateinitPreferred
     ) = PropertyInfo(
             name,
@@ -272,7 +284,6 @@ class PropertyInfo(name: String,
             writable,
             possibleContainers,
             typeParameterInfos,
-            isAbstract,
             isLateinitPreferred,
             isForCompanion,
             modifierList,

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

@@ -22,6 +22,7 @@ import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.*
 import org.jetbrains.kotlin.lexer.KtToken
 import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.KtBinaryExpression
+import org.jetbrains.kotlin.psi.KtPsiFactory
 import org.jetbrains.kotlin.types.Variance
 import org.jetbrains.kotlin.types.expressions.OperatorConventions
 import java.util.*
@@ -55,8 +56,12 @@ object CreateBinaryOperationActionFactory : CreateCallableMemberFromUsageFactory
         }
         val parameters = Collections.singletonList(ParameterInfo(TypeInfo(argumentExpr, Variance.IN_VARIANCE)))
         val isOperator = token != KtTokens.IDENTIFIER
-        return FunctionInfo(operationName, receiverType, returnType, parameterInfos = parameters,
+        return FunctionInfo(
-                            isOperator = isOperator,
+                operationName,
-                            isInfix = !isOperator)
+                receiverType,
+                returnType,
+                parameterInfos = parameters,
+                modifierList = KtPsiFactory(element).createModifierList(if (isOperator) KtTokens.OPERATOR_KEYWORD else KtTokens.INFIX_KEYWORD)
+        )
     }
 }

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

@@ -153,7 +153,10 @@ sealed class CreateCallableFromCallActionFactory<E : KtExpression>(
 
         if (!receiverType.isAbstract() && TypeUtils.getAllSupertypes(receiverType).all { !it.isAbstract() }) return null
 
-        return mainCallable.copy(receiverTypeInfo = receiverTypeInfo, possibleContainers = emptyList(), isAbstract = true)
+        return mainCallable.copy(
+                receiverTypeInfo = receiverTypeInfo,
+                possibleContainers = emptyList(),
+                modifierList = KtPsiFactory(originalExpression).createModifierList(KtTokens.ABSTRACT_KEYWORD))
     }
 
     protected fun getCallableWithReceiverInsideExtension(

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

@@ -23,8 +23,10 @@ import org.jetbrains.kotlin.idea.core.quickfix.QuickFixUtil
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.CallableInfo
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.FunctionInfo
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.TypeInfo
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.KtDestructuringDeclaration
 import org.jetbrains.kotlin.psi.KtForExpression
+import org.jetbrains.kotlin.psi.KtPsiFactory
 import org.jetbrains.kotlin.resolve.DataClassDescriptorResolver
 import org.jetbrains.kotlin.types.Variance
 
@@ -52,6 +54,11 @@ object CreateComponentFunctionActionFactory : CreateCallableMemberFromUsageFacto
         val entry = entries[componentNumber]
         val returnTypeInfo = TypeInfo(entry, Variance.OUT_VARIANCE)
 
-        return FunctionInfo(name.identifier, ownerTypeInfo, returnTypeInfo, isOperator = true)
+        return FunctionInfo(
+                name.identifier,
+                ownerTypeInfo,
+                returnTypeInfo,
+                modifierList = KtPsiFactory(element).createModifierList(KtTokens.OPERATOR_KEYWORD)
+        )
     }
 }

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

@@ -21,7 +21,9 @@ import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.Callab
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.FunctionInfo
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.ParameterInfo
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.TypeInfo
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.KtArrayAccessExpression
+import org.jetbrains.kotlin.psi.KtPsiFactory
 import org.jetbrains.kotlin.types.Variance
 import org.jetbrains.kotlin.util.OperatorNameConventions
 import java.util.*
@@ -34,7 +36,12 @@ object CreateGetFunctionActionFactory : CreateGetSetFunctionActionFactory(isGet
         val parameters = element.indexExpressions.map { ParameterInfo(TypeInfo(it, Variance.IN_VARIANCE)) }
         val returnType = TypeInfo(element, Variance.OUT_VARIANCE)
         return FunctionInfo(
-                OperatorNameConventions.GET.asString(), arrayType, returnType, Collections.emptyList(), parameters, isOperator = true
+                OperatorNameConventions.GET.asString(),
+                arrayType,
+                returnType,
+                Collections.emptyList(),
+                parameters,
+                modifierList = KtPsiFactory(element).createModifierList(KtTokens.OPERATOR_KEYWORD)
         )
     }
 }

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

@@ -24,7 +24,9 @@ import org.jetbrains.kotlin.idea.project.builtIns
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.CallableInfo
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.FunctionInfo
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.TypeInfo
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.KtForExpression
+import org.jetbrains.kotlin.psi.KtPsiFactory
 import org.jetbrains.kotlin.types.Variance
 import org.jetbrains.kotlin.util.OperatorNameConventions
 
@@ -38,6 +40,11 @@ object CreateHasNextFunctionActionFactory : CreateCallableMemberFromUsageFactory
                 DiagnosticFactory.cast(diagnostic, Errors.HAS_NEXT_MISSING, Errors.HAS_NEXT_FUNCTION_NONE_APPLICABLE)
         val ownerType = TypeInfo(diagnosticWithParameters.a, Variance.IN_VARIANCE)
         val returnType = TypeInfo(element.builtIns.booleanType, Variance.OUT_VARIANCE)
-        return FunctionInfo(OperatorNameConventions.HAS_NEXT.asString(), ownerType, returnType, isOperator = true)
+        return FunctionInfo(
+                OperatorNameConventions.HAS_NEXT.asString(),
+                ownerType,
+                returnType,
+                modifierList = KtPsiFactory(element).createModifierList(KtTokens.OPERATOR_KEYWORD)
+        )
     }
 }

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

@@ -23,7 +23,9 @@ import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.Callab
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.FunctionInfo
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.ParameterInfo
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.TypeInfo
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.KtCallExpression
+import org.jetbrains.kotlin.psi.KtPsiFactory
 import org.jetbrains.kotlin.types.Variance
 import org.jetbrains.kotlin.types.isError
 import org.jetbrains.kotlin.util.OperatorNameConventions
@@ -48,6 +50,12 @@ object CreateInvokeFunctionActionFactory : CreateCallableMemberFromUsageFactory<
         }
 
         val returnType = TypeInfo(element, Variance.OUT_VARIANCE)
-        return FunctionInfo(OperatorNameConventions.INVOKE.asString(), receiverType, returnType, parameterInfos = parameters, isOperator = true)
+        return FunctionInfo(
+                OperatorNameConventions.INVOKE.asString(),
+                receiverType,
+                returnType,
+                parameterInfos = parameters,
+                modifierList = KtPsiFactory(element).createModifierList(KtTokens.OPERATOR_KEYWORD)
+        )
     }
 }

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

@@ -23,9 +23,11 @@ import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.Callab
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.FunctionInfo
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.TypeInfo
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.guessTypes
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.KtForExpression
+import org.jetbrains.kotlin.psi.KtPsiFactory
 import org.jetbrains.kotlin.types.KotlinTypeFactory
 import org.jetbrains.kotlin.types.TypeProjectionImpl
 import org.jetbrains.kotlin.types.Variance
@@ -57,6 +59,11 @@ object CreateIteratorFunctionActionFactory : CreateCallableMemberFromUsageFactor
                                                             returnJetType.isMarkedNullable,
                                                             returnJetType.memberScope)
         val returnType = TypeInfo(newReturnJetType, Variance.OUT_VARIANCE)
-        return FunctionInfo(OperatorNameConventions.ITERATOR.asString(), iterableType, returnType, isOperator = true)
+        return FunctionInfo(
+                OperatorNameConventions.ITERATOR.asString(),
+                iterableType,
+                returnType,
+                modifierList = KtPsiFactory(element).createModifierList(KtTokens.OPERATOR_KEYWORD)
+        )
     }
 }

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

@@ -23,8 +23,10 @@ import org.jetbrains.kotlin.idea.core.quickfix.QuickFixUtil
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.CallableInfo
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.FunctionInfo
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.TypeInfo
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.psi.KtForExpression
+import org.jetbrains.kotlin.psi.KtPsiFactory
 import org.jetbrains.kotlin.types.Variance
 import org.jetbrains.kotlin.util.OperatorNameConventions
 
@@ -39,6 +41,11 @@ object CreateNextFunctionActionFactory : CreateCallableMemberFromUsageFactory<Kt
 
         val variableExpr = element.loopParameter ?: element.destructuringDeclaration ?: return null
         val returnType = TypeInfo(variableExpr as KtExpression, Variance.OUT_VARIANCE)
-        return FunctionInfo(OperatorNameConventions.NEXT.asString(), ownerType, returnType, isOperator = true)
+        return FunctionInfo(
+                OperatorNameConventions.NEXT.asString(),
+                ownerType,
+                returnType,
+                modifierList = KtPsiFactory(element).createModifierList(KtTokens.OPERATOR_KEYWORD)
+        )
     }
 }

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

@@ -26,8 +26,10 @@ import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.Callab
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.FunctionInfo
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.ParameterInfo
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.TypeInfo
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.psi.KtProperty
+import org.jetbrains.kotlin.psi.KtPsiFactory
 import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
@@ -61,13 +63,15 @@ object CreatePropertyDelegateAccessorsActionFactory : CreateCallableMemberFromUs
 
         val callableInfos = SmartList<CallableInfo>()
 
+        val psiFactory = KtPsiFactory(element)
+
         if (isApplicableForAccessor(propertyDescriptor.getter)) {
             val getterInfo = FunctionInfo(
                     name = OperatorNameConventions.GET_VALUE.asString(),
                     receiverTypeInfo = accessorReceiverType,
                     returnTypeInfo = TypeInfo(propertyType, Variance.OUT_VARIANCE),
                     parameterInfos = listOf(thisRefParam, metadataParam),
-                    isOperator = true
+                    modifierList = psiFactory.createModifierList(KtTokens.OPERATOR_KEYWORD)
             )
             callableInfos.add(getterInfo)
         }
@@ -79,7 +83,7 @@ object CreatePropertyDelegateAccessorsActionFactory : CreateCallableMemberFromUs
                     receiverTypeInfo = accessorReceiverType,
                     returnTypeInfo = TypeInfo(builtIns.unitType, Variance.OUT_VARIANCE),
                     parameterInfos = listOf(thisRefParam, metadataParam, newValueParam),
-                    isOperator = true
+                    modifierList = psiFactory.createModifierList(KtTokens.OPERATOR_KEYWORD)
             )
             callableInfos.add(setterInfo)
         }

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

@@ -24,10 +24,8 @@ import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.Callab
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.FunctionInfo
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.ParameterInfo
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.TypeInfo
-import org.jetbrains.kotlin.psi.KtArrayAccessExpression
+import org.jetbrains.kotlin.lexer.KtTokens
-import org.jetbrains.kotlin.psi.KtBinaryExpression
+import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.psi.KtOperationExpression
-import org.jetbrains.kotlin.psi.KtUnaryExpression
 import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall
 import org.jetbrains.kotlin.types.ErrorUtils
 import org.jetbrains.kotlin.types.Variance
@@ -63,7 +61,12 @@ object CreateSetFunctionActionFactory : CreateGetSetFunctionActionFactory(isGet
 
         val returnType = TypeInfo(builtIns.unitType, Variance.OUT_VARIANCE)
         return FunctionInfo(
-                OperatorNameConventions.SET.asString(), arrayType, returnType, Collections.emptyList(), parameters, isOperator = true
+                OperatorNameConventions.SET.asString(),
+                arrayType,
+                returnType,
+                Collections.emptyList(),
+                parameters,
+                modifierList = KtPsiFactory(element).createModifierList(KtTokens.OPERATOR_KEYWORD)
         )
     }
 }

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

@@ -21,6 +21,8 @@ import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.Callab
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.FunctionInfo
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.TypeInfo
 import org.jetbrains.kotlin.lexer.KtToken
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.psi.KtPsiFactory
 import org.jetbrains.kotlin.psi.KtUnaryExpression
 import org.jetbrains.kotlin.types.Variance
 import org.jetbrains.kotlin.types.expressions.OperatorConventions
@@ -39,6 +41,11 @@ object CreateUnaryOperationActionFactory: CreateCallableMemberFromUsageFactory<K
 
         val receiverType = TypeInfo(receiverExpr, Variance.IN_VARIANCE)
         val returnType = if (incDec) TypeInfo.ByReceiverType(Variance.OUT_VARIANCE) else TypeInfo(element, Variance.OUT_VARIANCE)
-        return FunctionInfo(operationName.asString(), receiverType, returnType, isOperator = true)
+        return FunctionInfo(
+                operationName.asString(),
+                receiverType,
+                returnType,
+                modifierList = KtPsiFactory(element).createModifierList(KtTokens.OPERATOR_KEYWORD)
+        )
     }
 }

idea/src/org/jetbrains/kotlin/idea/quickfix/crossLanguage/KotlinElementActionsFactory.kt

@@ -376,7 +376,6 @@ class KotlinElementActionsFactory : JvmElementActionsFactory() {
                 returnTypeInfo,
                 listOf(targetContainer),
                 parameterInfos,
-                isAbstract = JvmModifier.ABSTRACT in request.modifiers,
                 isForCompanion = JvmModifier.STATIC in request.modifiers,
                 modifierList = modifierBuilder.modifierList,
                 preferEmptyBody = true