No use of WhenBuilder at all

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

@@ -412,100 +412,6 @@ public class JetPsiFactory(private val project: Project) {
         }
     }
 
-    public inner class WhenBuilder(subjectText: String?) {
-        private val sb = StringBuilder("when ")
-        private var frozen = false
-        private var inCondition = false
-
-        public fun condition(text: String): WhenBuilder {
-            assert(!frozen)
-
-            if (!inCondition) {
-                inCondition = true
-            }
-            else {
-                sb.append(", ")
-            }
-            sb.append(text)
-
-            return this
-        }
-
-        public fun condition(expression: JetExpression?): WhenBuilder {
-            return condition(JetPsiUtil.getText(expression))
-        }
-
-        public fun pattern(typeReferenceText: String, negated: Boolean): WhenBuilder {
-            return condition((if (negated) "!is" else "is") + " " + typeReferenceText)
-        }
-
-        public fun pattern(typeReference: JetTypeReference?, negated: Boolean): WhenBuilder {
-            return pattern(JetPsiUtil.getText(typeReference), negated)
-        }
-
-        public fun range(argumentText: String, negated: Boolean): WhenBuilder {
-            return condition((if (negated) "!in" else "in") + " " + argumentText)
-        }
-
-        public fun range(argument: JetExpression?, negated: Boolean): WhenBuilder {
-            return range(JetPsiUtil.getText(argument), negated)
-        }
-
-        public fun branchExpression(expressionText: String): WhenBuilder {
-            assert(!frozen)
-            assert(inCondition)
-
-            inCondition = false
-            sb.append(" -> ").append(expressionText).append("\n")
-
-            return this
-        }
-
-        public fun branchExpression(expression: JetExpression?): WhenBuilder {
-            return branchExpression(JetPsiUtil.getText(expression))
-        }
-
-        public fun entry(entryText: String): WhenBuilder {
-            assert(!frozen)
-            assert(!inCondition)
-
-            sb.append(entryText).append("\n")
-
-            return this
-        }
-
-        public fun entry(whenEntry: JetWhenEntry?): WhenBuilder {
-            return entry(JetPsiUtil.getText(whenEntry))
-        }
-
-        public fun elseEntry(text: String): WhenBuilder {
-            return entry("else -> $text")
-        }
-
-        public fun elseEntry(expression: JetExpression?): WhenBuilder {
-            return elseEntry(JetPsiUtil.getText(expression))
-        }
-
-        public fun toExpression(): JetWhenExpression {
-            if (!frozen) {
-                sb.append("}")
-                frozen = true
-            }
-            return createExpression(sb.toString()) as JetWhenExpression
-        }
-
-        init {
-            if (subjectText != null) {
-                sb.append("(").append(subjectText).append(") ")
-            }
-            sb.append("{\n")
-        }
-    }
-
-    public fun WhenBuilder(subject: JetExpression?): WhenBuilder {
-        return WhenBuilder(subject?.getText())
-    }
-
     public class CallableBuilder(private val target: Target) {
         public enum class Target {
             FUNCTION

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

@@ -199,8 +199,10 @@ public class ExpressionBuilder {
     }
 
     public fun appendExpression(expression: JetExpression?): ExpressionBuilder {
-        patternBuilder.append("$" + arguments.size())
+        if (expression != null) {
-        arguments.add(expression)
+            patternBuilder.append("$" + arguments.size())
+            arguments.add(expression)
+        }
         return this
     }
 

idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/branchedTransformationUtils.kt

@@ -131,22 +131,32 @@ public fun JetWhenExpression.flatten(): JetWhenExpression {
 
     assert(elseBranch is JetWhenExpression, TRANSFORM_WITHOUT_CHECK)
 
-    val nestedWhenExpression = (elseBranch as JetWhenExpression)
+    val nestedWhenExpression = elseBranch as JetWhenExpression
 
     val outerEntries = getEntries()
     val innerEntries = nestedWhenExpression.getEntries()
-    val builder = JetPsiFactory(this).WhenBuilder(subjectExpression)
-    for (entry in outerEntries) {
-        if (entry.isElse())
-            continue
 
-        builder.entry(entry)
+    val whenExpression = JetPsiFactory(this).buildExpression {
-    }
+        appendFixedText("when")
-    for (entry in innerEntries) {
+        if (subjectExpression != null) {
-        builder.entry(entry)
+            appendFixedText("(").appendExpression(subjectExpression).appendFixedText(")")
-    }
+        }
+        appendFixedText("{\n")
 
-    return replaced(builder.toExpression())
+        for (entry in outerEntries) {
+            if (entry.isElse()) continue
+            appendNonFormattedText(entry.getText())
+            appendFixedText("\n")
+        }
+        for (entry in innerEntries) {
+            appendNonFormattedText(entry.getText())
+            appendFixedText("\n")
+        }
+
+        appendFixedText("}")
+    } as JetWhenExpression
+
+    return replaced(whenExpression)
 }
 
 public fun JetWhenExpression.introduceSubject(): JetWhenExpression {