JetPsiFactory: create by pattern allows Name's as arguments + changed placeholder text specification format

idea/src/org/jetbrains/kotlin/idea/intentions/InfixCallToOrdinaryIntention.kt

@@ -29,7 +29,7 @@ public class InfixCallToOrdinaryIntention : JetSelfTargetingIntention<JetBinaryE
     override fun applyTo(element: JetBinaryExpression, editor: Editor) {
         val argument = JetPsiUtil.safeDeparenthesize(element.getRight()!!)
         val pattern = "$0.$1" + when (argument) {
-            is JetFunctionLiteralExpression -> " $2={}$"
+            is JetFunctionLiteralExpression -> " $2:'{}'"
             else -> "($2)"
         }
         val replacement = JetPsiFactory(element).createExpressionByPattern(pattern, element.getLeft()!!, element.getOperationReference().getText(), argument)

idea/src/org/jetbrains/kotlin/idea/intentions/Utils.kt

@@ -89,7 +89,7 @@ fun splitPropertyDeclaration(property: JetProperty): JetBinaryExpression {
     val explicitTypeToSet = if (property.getTypeReference() != null) null else initializer.analyze().getType(initializer)
 
     val psiFactory = JetPsiFactory(property)
-    var assignment = psiFactory.createExpressionByPattern("$0 = $1", property.getName()!!, initializer)
+    var assignment = psiFactory.createExpressionByPattern("$0 = $1", property.getNameAsName()!!, initializer)
 
     assignment = parent.addAfter(assignment, property) as JetBinaryExpression
     parent.addAfter(psiFactory.createNewLine(), property)

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

@@ -611,20 +611,19 @@ public abstract class DeprecatedSymbolUsageFixBase(
         ) {
             assert(usages.all { expression.isAncestor(it, strict = true) })
 
-            fun nameInCode(name: String) = Name.identifier(name).renderName()
-
-            fun replaceUsages(name: String) {
-                val nameInCode = psiFactory.createExpression(nameInCode(name))
+            fun replaceUsages(name: Name) {
+                val nameInCode = psiFactory.createExpression(name.renderName())
                 for (usage in usages) {
                     usage.replace(nameInCode)
                 }
             }
 
-            fun suggestName(validator: JetNameValidator): String {
-                return if (nameSuggestion != null)
+            fun suggestName(validator: JetNameValidator): Name {
+                val name = if (nameSuggestion != null)
                     validator.validateName(nameSuggestion)
                 else
                     JetNameSuggester.suggestNamesForExpression(value, validator, "t").first()
+                return Name.identifier(name)
             }
 
             // checks that name is used (without receiver) inside expression being constructed but not inside usages that will be replaced
@@ -653,7 +652,7 @@ public abstract class DeprecatedSymbolUsageFixBase(
                             }
                         })
 
-                        var declaration = psiFactory.createDeclaration<JetVariableDeclaration>("val ${nameInCode(name)} = " + value.getText())
+                        var declaration = psiFactory.createDeclarationByPattern<JetVariableDeclaration>("val $0 = $1", name, value)
                         declaration = block.addBefore(declaration, expressionToBeReplaced) as JetVariableDeclaration
                         block.addBefore(psiFactory.createNewLine(), expressionToBeReplaced)
 
@@ -676,7 +675,7 @@ public abstract class DeprecatedSymbolUsageFixBase(
             val dot = if (safeCall) "?." else "."
 
             expression = if (!isNameUsed("it")) {
-                replaceUsages("it")
+                replaceUsages(Name.identifier("it"))
                 psiFactory.createExpressionByPattern("$0${dot}let { $1 }", value, expression)
             }
             else {
@@ -684,7 +683,7 @@ public abstract class DeprecatedSymbolUsageFixBase(
                     override fun validateInner(name: String) = !isNameUsed(name)
                 })
                 replaceUsages(name)
-                psiFactory.createExpressionByPattern("$0${dot}let { ${nameInCode(name)} -> $1 }", value, expression)
+                psiFactory.createExpressionByPattern("$0${dot}let { $1 -> $2 }", value, name, expression)
             }
         }
 

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

@@ -61,10 +61,10 @@ public class RemoveNameFromFunctionExpressionFix(element: JetNamedFunction) : Je
 
         private fun removeNameFromFunction(function: JetNamedFunction) {
             var wereAutoLabelUsages = false
-            val name = function.getName() ?: return
+            val name = function.getNameAsName() ?: return
 
             function.forEachDescendantOfType<JetReturnExpression> {
-                if (!wereAutoLabelUsages && it.getLabelName() == name) {
+                if (!wereAutoLabelUsages && it.getLabelNameAsName() == name) {
                     wereAutoLabelUsages = it.analyze().get(BindingContext.LABEL_TARGET, it.getTargetLabel()) == function
                 }
             }
@@ -73,7 +73,7 @@ public class RemoveNameFromFunctionExpressionFix(element: JetNamedFunction) : Je
 
             if (wereAutoLabelUsages) {
                 val psiFactory = JetPsiFactory(function)
-                val newFunction = psiFactory.createExpressionByPattern("$name@ $0", function)
+                val newFunction = psiFactory.createExpressionByPattern("$0@ $1", name, function)
                 function.replace(newFunction)
             }
         }

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

@@ -94,7 +94,7 @@ public class ReplaceObsoleteLabelSyntaxFix(element: JetAnnotationEntry?) : JetIn
             val textRangeToRetain = TextRange(annotation.getTextRange().getEndOffset(), baseExpressionStart)
             val textToRetain = textRangeToRetain.substring(annotation.getContainingFile().getText())
 
-            val labeledExpression = JetPsiFactory(annotation).createExpressionByPattern("$labelName@$0$1", textToRetain, expression)
+            val labeledExpression = JetPsiFactory(annotation).createExpressionByPattern("$0@$1$2", labelName, textToRetain, expression)
 
             annotatedExpression.replace(labeledExpression)
         }

idea/src/org/jetbrains/kotlin/idea/util/psiModificationUtil.kt

@@ -76,7 +76,7 @@ fun JetCallExpression.moveFunctionLiteralOutsideParentheses() {
     val expression = argument.getArgumentExpression()!!
     assert(expression.unpackFunctionLiteral() != null)
 
-    val dummyCall = JetPsiFactory(this).createExpressionByPattern("foo()$0={}$", expression) as JetCallExpression
+    val dummyCall = JetPsiFactory(this).createExpressionByPattern("foo()$0:'{}'", expression) as JetCallExpression
     val functionLiteralArgument = dummyCall.getFunctionLiteralArguments().single()
     this.add(functionLiteralArgument)
     if (argumentList.getArguments().size() > 1) {