Add JetPsiFactory(JetElement) function and use it

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetCodeFragment.kt

@@ -100,7 +100,7 @@ public abstract class JetCodeFragment(
     }
 
     fun importsAsImportList(): JetImportList? {
-        return JetPsiFactory(_project).createFile(_myImports.makeString("\n")).getImportList()
+        return JetPsiFactory(this).createFile(_myImports.makeString("\n")).getImportList()
     }
 
     override fun setVisibilityChecker(checker: JavaCodeFragment.VisibilityChecker?) { }

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetExpressionImpl.java

@@ -46,7 +46,7 @@ public abstract class JetExpressionImpl extends JetElementImpl implements JetExp
         PsiElement parent = getParent();
         if (parent instanceof JetExpression && newElement instanceof JetExpression &&
             JetPsiUtil.areParenthesesNecessary((JetExpression) newElement, this, (JetExpression) parent)) {
-            return super.replace(PsiPackage.JetPsiFactory(getProject()).createExpression("(" + newElement.getText() + ")"));
+            return super.replace(PsiPackage.JetPsiFactory(this).createExpression("(" + newElement.getText() + ")"));
         }
         return super.replace(newElement);
     }

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetExpressionImplStub.java

@@ -44,7 +44,7 @@ public abstract class JetExpressionImplStub<T extends StubElement> extends JetEl
         PsiElement parent = getParent();
         if (parent instanceof JetExpression && newElement instanceof JetExpression &&
             JetPsiUtil.areParenthesesNecessary((JetExpression) newElement, this, (JetExpression) parent)) {
-            return super.replace(PsiPackage.JetPsiFactory(getProject()).createExpression("(" + newElement.getText() + ")"));
+            return super.replace(PsiPackage.JetPsiFactory(this).createExpression("(" + newElement.getText() + ")"));
         }
         return super.replace(newElement);
     }

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetNamedDeclarationNotStubbed.java

@@ -64,7 +64,7 @@ abstract class JetNamedDeclarationNotStubbed extends JetDeclarationImpl implemen
 
     @Override
     public PsiElement setName(@NonNls @NotNull String name) throws IncorrectOperationException {
-        return getNameIdentifier().replace(JetPsiFactory(getProject()).createNameIdentifier(name));
+        return getNameIdentifier().replace(JetPsiFactory(this).createNameIdentifier(name));
     }
 
     @Override

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetNamedDeclarationStub.java

@@ -77,7 +77,7 @@ abstract class JetNamedDeclarationStub<T extends PsiJetStubWithFqName> extends J
 
     @Override
     public PsiElement setName(@NonNls @NotNull String name) throws IncorrectOperationException {
-        return getNameIdentifier().replace(JetPsiFactory(getProject()).createNameIdentifier(name));
+        return getNameIdentifier().replace(JetPsiFactory(this).createNameIdentifier(name));
     }
 
     @Override

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetObjectDeclarationName.java

@@ -49,7 +49,7 @@ public class JetObjectDeclarationName extends JetExpressionImpl {
     }
 
     public PsiElement setName(@NonNls @NotNull String name) throws IncorrectOperationException {
-        return getNameIdentifier().replace(PsiPackage.JetPsiFactory(getProject()).createNameIdentifier(name));
+        return getNameIdentifier().replace(PsiPackage.JetPsiFactory(this).createNameIdentifier(name));
     }
 
     @Override

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiFactory.kt

@@ -27,6 +27,7 @@ import org.jetbrains.jet.lexer.JetKeywordToken
 import org.jetbrains.jet.plugin.JetFileType
 
 public fun JetPsiFactory(project: Project?): JetPsiFactory = JetPsiFactory(project!!)
+public fun JetPsiFactory(contextElement: JetElement): JetPsiFactory = JetPsiFactory(contextElement.getProject())
 
 public class JetPsiFactory(private val project: Project) {
 
@@ -190,7 +191,7 @@ public class JetPsiFactory(private val project: Project) {
     }
 
     public fun createWhenEntry(entryText: String): JetWhenEntry {
-        val function = createFunction("fun foo() { when(12) { $entryText } }")
+        val function = createFunction("fun foo() { when(12) { " + entryText + " } }")
         val whenEntry = PsiTreeUtil.findChildOfType(function, javaClass<JetWhenEntry>())
 
         assert(whenEntry != null, "Couldn't generate when entry")
@@ -200,8 +201,8 @@ public class JetPsiFactory(private val project: Project) {
     }
 
     public fun createBlockStringTemplateEntry(expression: JetExpression): JetStringTemplateEntryWithExpression {
-        val stringTemplateExpression = createExpression("\"\${${expression.getText()}}\"") as JetStringTemplateExpression
-        return stringTemplateExpression.getEntries().first() as JetStringTemplateEntryWithExpression
+        val stringTemplateExpression = createExpression("\"\${" + expression.getText() + "}\"") as JetStringTemplateExpression
+        return stringTemplateExpression.getEntries()[0] as JetStringTemplateEntryWithExpression
     }
 
     public fun createImportDirective(path: String): JetImportDirective {
@@ -235,15 +236,15 @@ public class JetPsiFactory(private val project: Project) {
     }
 
     public fun createClassLabel(labelName: String): JetSimpleNameExpression {
-        return (createExpression("this@$labelName") as JetThisExpression).getTargetLabel()!!
+        return (createExpression("this@" + labelName) as JetThisExpression).getTargetLabel()!!
     }
 
     public fun createFieldIdentifier(fieldName: String): JetExpression {
-        return createExpression("$$fieldName")
+        return createExpression("$" + fieldName)
     }
 
     public fun createBinaryExpression(lhs: String, op: String, rhs: String): JetBinaryExpression {
-        return createExpression("$lhs $op $rhs") as JetBinaryExpression
+        return createExpression(lhs + " " + op + " " + rhs) as JetBinaryExpression
     }
 
     public fun createBinaryExpression(lhs: JetExpression?, op: String, rhs: JetExpression?): JetBinaryExpression {
@@ -549,7 +550,7 @@ public class JetPsiFactory(private val project: Project) {
     }
 
     public fun createFunctionBody(bodyText: String): JetExpression {
-        return createFunction("fun foo() {\n$bodyText\n}").getBodyExpression()!!
+        return createFunction("fun foo() {\n" + bodyText + "\n}").getBodyExpression()!!
     }
 
     public fun createEmptyClassObject(): JetClassObject {

compiler/frontend/src/org/jetbrains/jet/lang/psi/psiUtil/jetPsiUtil.kt

@@ -110,7 +110,7 @@ public fun JetBlockExpression.prependElement(element: JetElement): JetElement =
         addBefore(element, getLBrace()!!.getNextSibling()!!)!! as JetElement
 
 public fun JetElement.wrapInBlock(): JetBlockExpression {
-    val block = JetPsiFactory(getProject()).createEmptyBody() as JetBlockExpression
+    val block = JetPsiFactory(this).createEmptyBody() as JetBlockExpression
     block.appendElement(this)
     return block
 }

compiler/frontend/src/org/jetbrains/jet/lang/resolve/DelegatedPropertyResolver.java

@@ -17,7 +17,6 @@
 package org.jetbrains.jet.lang.resolve;
 
 import com.google.common.collect.Lists;
-import com.intellij.openapi.project.Project;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
@@ -173,17 +172,17 @@ public class DelegatedPropertyResolver {
         ExpressionTypingContext context = ExpressionTypingContext.newContext(
                 expressionTypingServices, trace, scope,
                 DataFlowInfo.EMPTY, TypeUtils.NO_EXPECTED_TYPE);
-        Project project = expressionTypingServices.getProject();
 
         boolean hasThis = propertyDescriptor.getReceiverParameter() != null || propertyDescriptor.getExpectedThisObject() != null;
 
         List<JetExpression> arguments = Lists.newArrayList();
-        arguments.add(JetPsiFactory(project).createExpression(hasThis ? "this" : "null"));
+        JetPsiFactory psiFactory = JetPsiFactory(delegateExpression);
+        arguments.add(psiFactory.createExpression(hasThis ? "this" : "null"));
 
-        arguments.add(JetPsiFactory(project).createExpression(KotlinBuiltIns.getInstance().getPropertyMetadataImpl().getName().asString() +
-                                                              "(\"" +
-                                                              propertyDescriptor.getName().asString() +
-                                                              "\")"));
+        arguments.add(psiFactory.createExpression(KotlinBuiltIns.getInstance().getPropertyMetadataImpl().getName().asString() +
+                                               "(\"" +
+                                               propertyDescriptor.getName().asString() +
+                                               "\")"));
 
         if (!isGet) {
             JetReferenceExpression fakeArgument = (JetReferenceExpression) createFakeExpressionOfType(expressionTypingServices.getProject(), trace,
@@ -195,7 +194,7 @@ public class DelegatedPropertyResolver {
         }
 
         Name functionName = Name.identifier(isGet ? "get" : "set");
-        JetReferenceExpression fakeCalleeExpression = JetPsiFactory(project).createSimpleName(functionName.asString());
+        JetReferenceExpression fakeCalleeExpression = psiFactory.createSimpleName(functionName.asString());
 
         ExpressionReceiver receiver = new ExpressionReceiver(delegateExpression, delegateType);
         Call call = CallMaker.makeCallWithExpressions(fakeCalleeExpression, receiver, null, fakeCalleeExpression, arguments, Call.CallType.DEFAULT);

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallTransformer.java

@@ -264,7 +264,7 @@ public class CallTransformer<D extends CallableDescriptor, F extends D> {
             this.outerCall = call;
             this.explicitExtensionReceiver = explicitExtensionReceiver;
             this.calleeExpressionAsThisObject = calleeExpressionAsThisObject;
-            this.fakeInvokeExpression = (JetSimpleNameExpression) JetPsiFactory(call.getCallElement().getProject()).createExpression( "invoke");
+            this.fakeInvokeExpression = (JetSimpleNameExpression) JetPsiFactory(call.getCallElement()).createExpression( "invoke");
         }
 
         @NotNull

compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingVisitor.java

@@ -109,8 +109,9 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
             return getTypeInfoWhenOnlyOneBranchIsPresent(
                     elseBranch, elseScope, elseInfo, thenInfo, contextWithExpectedType, ifExpression, isStatement);
         }
-        JetBlockExpression thenBlock = JetPsiFactory(ifExpression.getProject()).wrapInABlock(thenBranch);
-        JetBlockExpression elseBlock = JetPsiFactory(ifExpression.getProject()).wrapInABlock(elseBranch);
+        JetPsiFactory psiFactory = JetPsiFactory(ifExpression);
+        JetBlockExpression thenBlock = psiFactory.wrapInABlock(thenBranch);
+        JetBlockExpression elseBlock = psiFactory.wrapInABlock(elseBranch);
         Call callForIf = createCallForSpecialConstruction(ifExpression, ifExpression, Lists.newArrayList(thenBlock, elseBlock));
         MutableDataFlowInfoForArguments dataFlowInfoForArguments =
                     createDataFlowInfoForArgumentsForIfCall(callForIf, thenInfo, elseInfo);

compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java

@@ -209,19 +209,17 @@ public class ExpressionTypingUtils {
      * Check that function or property with the given qualified name can be resolved in given scope and called on given receiver
      *
      * @param callableFQN
-     * @param project
      * @param scope
      * @return
      */
     public static List<CallableDescriptor> canFindSuitableCall(
             @NotNull FqName callableFQN,
-            @NotNull Project project,
             @NotNull JetExpression receiverExpression,
             @NotNull JetType receiverType,
             @NotNull JetScope scope,
             @NotNull ModuleDescriptor module
     ) {
-        JetImportDirective importDirective = JetPsiFactory(project).createImportDirective(callableFQN.asString());
+        JetImportDirective importDirective = JetPsiFactory(receiverExpression).createImportDirective(callableFQN.asString());
 
         Collection<? extends DeclarationDescriptor> declarationDescriptors = new QualifiedExpressionResolver()
                 .analyseImportReference(importDirective, scope, new BindingTraceContext(), module);

idea/src/org/jetbrains/jet/plugin/actions/JetAddFunctionToClassifierAction.java

@@ -65,7 +65,7 @@ public class JetAddFunctionToClassifierAction implements QuestionAction {
     }
 
     private static void addFunction(
-            @NotNull final Project project,
+            @NotNull Project project,
             @NotNull final ClassDescriptor typeDescriptor,
             @NotNull final FunctionDescriptor functionDescriptor
     ) {
@@ -82,7 +82,7 @@ public class JetAddFunctionToClassifierAction implements QuestionAction {
                 ApplicationManager.getApplication().runWriteAction(new Runnable() {
                     @Override
                     public void run() {
-                        JetPsiFactory psiFactory = PsiPackage.JetPsiFactory(project);
+                        JetPsiFactory psiFactory = PsiPackage.JetPsiFactory(classifierDeclaration);
                         JetClassBody body = classifierDeclaration.getBody();
                         if (body == null) {
                             PsiElement whitespaceBefore = classifierDeclaration.add(psiFactory.createWhiteSpace());

idea/src/org/jetbrains/jet/plugin/actions/JetChangeFunctionSignatureAction.java

@@ -119,14 +119,14 @@ public class JetChangeFunctionSignatureAction implements QuestionAction {
         };
     }
 
-    private static void changeSignature(final JetNamedFunction element, final Project project, FunctionDescriptor signature) {
+    private static void changeSignature(final JetNamedFunction element, Project project, FunctionDescriptor signature) {
         final String signatureString = CodeInsightUtils.createFunctionSignatureStringFromDescriptor(
                 signature,
                 /* shortTypeNames = */ false);
 
         PsiDocumentManager.getInstance(project).commitAllDocuments();
 
-        final JetPsiFactory psiFactory = PsiPackage.JetPsiFactory(project);
+        final JetPsiFactory psiFactory = PsiPackage.JetPsiFactory(element);
         CommandProcessor.getInstance().executeCommand(project, new Runnable() {
             @Override
             public void run() {

idea/src/org/jetbrains/jet/plugin/caches/JetShortNamesCache.java

@@ -244,7 +244,7 @@ public class JetShortNamesCache extends PsiShortNamesCache {
                     }
                 });
         for (FqName fqName : topLevelFunctionFqNames) {
-            JetImportDirective importDirective = JetPsiFactory(project).createImportDirective(new ImportPath(fqName, false));
+            JetImportDirective importDirective = JetPsiFactory(expression).createImportDirective(new ImportPath(fqName, false));
             Collection<? extends DeclarationDescriptor> declarationDescriptors = new QualifiedExpressionResolver().analyseImportReference(
                     importDirective, jetScope, new BindingTraceContext(), resolveSession.getModuleDescriptor());
             for (DeclarationDescriptor declarationDescriptor : declarationDescriptors) {
@@ -314,7 +314,7 @@ public class JetShortNamesCache extends PsiShortNamesCache {
         // Iterate through the function with attempt to resolve found functions
         for (FqName functionFQN : functionFQNs) {
             for (CallableDescriptor functionDescriptor : ExpressionTypingUtils.canFindSuitableCall(
-                    functionFQN, project, receiverExpression, expressionType, scope, resolveSession.getModuleDescriptor())) {
+                    functionFQN, receiverExpression, expressionType, scope, resolveSession.getModuleDescriptor())) {
 
                 resultDescriptors.add(functionDescriptor);
             }

idea/src/org/jetbrains/jet/plugin/codeInsight/KotlinCopyPasteReferenceProcessor.kt

@@ -311,8 +311,8 @@ public class KotlinCopyPasteReferenceProcessor() : CopyPastePostProcessor<Refere
 
     private object LengthenReferences {
 
-        private fun createQualifiedExpression(project: Project, text: String): JetDotQualifiedExpression {
-            val newExpression = JetPsiFactory(project).createExpression(text)
+        private fun createQualifiedExpression(psiFactory: JetPsiFactory, text: String): JetDotQualifiedExpression {
+            val newExpression = psiFactory.createExpression(text)
             LOG.assertTrue(newExpression is JetDotQualifiedExpression,
                            "\"${newExpression.getText()}\" is ${newExpression.javaClass}," +
                            "not ${javaClass<JetDotQualifiedExpression>().getSimpleName()}."
@@ -325,18 +325,19 @@ public class KotlinCopyPasteReferenceProcessor() : CopyPastePostProcessor<Refere
             val project = expression.getProject()
             val parent = expression.getParent()
             val prefixToInsert = fqName.parent().asString()
+            val psiFactory = JetPsiFactory(expression)
             if (parent is JetCallExpression) {
                 val text = "$prefixToInsert.${parent.getText()}"
-                parent.replace(createQualifiedExpression(project, text))
+                parent.replace(createQualifiedExpression(psiFactory, text))
             }
             else if (parent is JetUserType) {
                 val typeReference = PsiTreeUtil.getParentOfType(expression, javaClass<JetTypeReference>())
                 LOG.assertTrue(typeReference != null, "JetUserType is expected to have parent of type JetTypeReference:\n" +
                     "At: ${DiagnosticUtils.atLocation(expression)}\nFILE:\n${expression.getContainingFile()!!.getText()}")
-                typeReference!!.replace(JetPsiFactory(project).createType("$prefixToInsert.${typeReference.getText()}"))
+                typeReference!!.replace(psiFactory.createType("$prefixToInsert.${typeReference.getText()}"))
             }
             else {
-                expression.replace(createQualifiedExpression(project, fqName.asString()))
+                expression.replace(createQualifiedExpression(psiFactory, fqName.asString()))
             }
         }
 

idea/src/org/jetbrains/jet/plugin/codeInsight/OverrideImplementMethodsHandler.java

@@ -82,8 +82,7 @@ public abstract class OverrideImplementMethodsHandler implements LanguageCodeIns
     ) {
         JetClassBody body = classOrObject.getBody();
         if (body == null) {
-            Project project = classOrObject.getProject();
-            JetPsiFactory psiFactory = JetPsiFactory(project);
+            JetPsiFactory psiFactory = JetPsiFactory(classOrObject);
             classOrObject.add(psiFactory.createWhiteSpace());
             body = (JetClassBody) classOrObject.add(psiFactory.createEmptyClassBody());
         }

idea/src/org/jetbrains/jet/plugin/codeInsight/ShortenReferences.kt

@@ -191,7 +191,7 @@ public object ShortenReferences {
             if (referenceExpression == null) return
             val typeArgumentList = userType.getTypeArgumentList()
             val text = referenceExpression.getText() + (if (typeArgumentList != null) typeArgumentList.getText() else "")
-            val newUserType = JetPsiFactory(userType.getProject()).createType(text).getTypeElement()!!
+            val newUserType = JetPsiFactory(userType).createType(text).getTypeElement()!!
             userType.replace(newUserType)
         }
     }

idea/src/org/jetbrains/jet/plugin/codeInsight/surroundWith/MoveDeclarationsOutHelper.java

@@ -95,7 +95,7 @@ public class MoveDeclarationsOutHelper {
     private static JetBinaryExpression createVariableAssignment(@NotNull JetProperty property) {
         String propertyName = property.getName();
         assert propertyName != null : "Property should have a name " + property.getText();
-        JetBinaryExpression assignment = (JetBinaryExpression) JetPsiFactory(property.getProject()).createExpression(propertyName + " = x");
+        JetBinaryExpression assignment = (JetBinaryExpression) JetPsiFactory(property).createExpression(propertyName + " = x");
         JetExpression right = assignment.getRight();
         assert right != null : "Created binary expression should have a right part " + assignment.getText();
         JetExpression initializer = property.getInitializer();
@@ -134,7 +134,7 @@ public class MoveDeclarationsOutHelper {
             typeString = DescriptorRenderer.FQ_NAMES_IN_TYPES.renderType(propertyType);
         }
 
-        return JetPsiFactory(property.getProject()).createProperty(property.getName(), typeString, property.isVar(), initializer);
+        return JetPsiFactory(property).createProperty(property.getName(), typeString, property.isVar(), initializer);
     }
 
     private static boolean needToDeclareOut(@NotNull PsiElement element, int lastStatementOffset, @NotNull SearchScope scope) {

idea/src/org/jetbrains/jet/plugin/codeInsight/surroundWith/expression/KotlinNotSurrounder.java

@@ -47,7 +47,7 @@ public class KotlinNotSurrounder extends KotlinExpressionSurrounder {
     @Nullable
     @Override
     public TextRange surroundExpression(@NotNull Project project, @NotNull Editor editor, @NotNull JetExpression expression) {
-        JetPrefixExpression prefixExpr = (JetPrefixExpression) JetPsiFactory(project).createExpression("!(a)");
+        JetPrefixExpression prefixExpr = (JetPrefixExpression) JetPsiFactory(expression).createExpression("!(a)");
         JetParenthesizedExpression parenthesizedExpression = (JetParenthesizedExpression) prefixExpr.getBaseExpression();
         assert parenthesizedExpression != null : "JetParenthesizedExpression should exists for " + prefixExpr.getText() + " expression";
         JetExpression expressionWithoutParentheses = parenthesizedExpression.getExpression();

idea/src/org/jetbrains/jet/plugin/codeInsight/surroundWith/expression/KotlinParenthesesSurrounder.java

@@ -42,7 +42,7 @@ public class KotlinParenthesesSurrounder extends KotlinExpressionSurrounder {
     @Nullable
     @Override
     public TextRange surroundExpression( @NotNull Project project, @NotNull Editor editor, @NotNull JetExpression expression) {
-        JetParenthesizedExpression parenthesizedExpression = (JetParenthesizedExpression) JetPsiFactory(project).createExpression("(a)");
+        JetParenthesizedExpression parenthesizedExpression = (JetParenthesizedExpression) JetPsiFactory(expression).createExpression("(a)");
         JetExpression expressionWithoutParentheses = parenthesizedExpression.getExpression();
         assert expressionWithoutParentheses != null : "JetExpression should exists for " + parenthesizedExpression.getText() + " expression";
         expressionWithoutParentheses.replace(expression);

idea/src/org/jetbrains/jet/plugin/codeInsight/surroundWith/expression/KotlinStringTemplateSurrounder.java

@@ -44,7 +44,7 @@ public class KotlinStringTemplateSurrounder extends KotlinExpressionSurrounder {
     @Nullable
     @Override
     public TextRange surroundExpression(@NotNull Project project, @NotNull Editor editor, @NotNull JetExpression expression) {
-        JetStringTemplateExpression stringTemplateExpression = (JetStringTemplateExpression) JetPsiFactory(project).createExpression(
+        JetStringTemplateExpression stringTemplateExpression = (JetStringTemplateExpression) JetPsiFactory(expression).createExpression(
                 getCodeTemplate(expression)
         );
         JetStringTemplateEntry templateEntry = stringTemplateExpression.getEntries()[0];

idea/src/org/jetbrains/jet/plugin/codeInsight/surroundWith/expression/KotlinWhenSurrounder.java

@@ -49,7 +49,7 @@ public class KotlinWhenSurrounder extends KotlinExpressionSurrounder {
     @Nullable
     @Override
     public TextRange surroundExpression(@NotNull Project project, @NotNull Editor editor, @NotNull JetExpression expression) {
-        JetWhenExpression whenExpression = (JetWhenExpression) JetPsiFactory(project).createExpression(getCodeTemplate(expression));
+        JetWhenExpression whenExpression = (JetWhenExpression) JetPsiFactory(expression).createExpression(getCodeTemplate(expression));
         JetExpression subjectExpression = whenExpression.getSubjectExpression();
         assert subjectExpression != null : "JetExpression should exists for " + whenExpression.getText() + " expression";
         subjectExpression.replace(expression);

idea/src/org/jetbrains/jet/plugin/codeInsight/unwrap/KotlinUnwrappers.java

@@ -74,7 +74,7 @@ public class KotlinUnwrappers {
         @Override
         protected void doUnwrap(PsiElement element, Context context) throws IncorrectOperationException {
             JetIfExpression ifExpr = (JetIfExpression) element;
-            context.replace(ifExpr, JetPsiFactory(ifExpr.getProject()).createIf(ifExpr.getCondition(), ifExpr.getThen(), null));
+            context.replace(ifExpr, JetPsiFactory(ifExpr).createIf(ifExpr.getCondition(), ifExpr.getThen(), null));
         }
     }
 

idea/src/org/jetbrains/jet/plugin/debugger/evaluate/extractFunctionForDebuggerUtil.kt

@@ -110,7 +110,7 @@ private fun addImportsToFile(newImportList: JetImportList?, tmpFile: JetFile) {
     if (newImportList != null) {
         val tmpFileImportList = tmpFile.getImportList()
         val packageDirective = tmpFile.getPackageDirective()
-        val psiFactory = JetPsiFactory(tmpFile.getProject())
+        val psiFactory = JetPsiFactory(tmpFile)
         if (tmpFileImportList == null) {
             tmpFile.addAfter(psiFactory.createNewLine(), packageDirective)
             tmpFile.addAfter(newImportList, tmpFile.getPackageDirective())
@@ -126,7 +126,7 @@ private fun addDebugExpressionBeforeContextElement(codeFragment: JetCodeFragment
     val parent = contextElement.getParent()
     if (parent == null) return null
 
-    val psiFactory = JetPsiFactory(contextElement.getProject())
+    val psiFactory = JetPsiFactory(codeFragment)
     parent.addBefore(psiFactory.createNewLine(), contextElement)
 
     val debugExpression = codeFragment.getContentElement()

idea/src/org/jetbrains/jet/plugin/intentions/AddBracesIntention.kt

@@ -53,7 +53,7 @@ public class AddBracesIntention : JetSelfTargetingIntention<JetExpressionImpl>("
         if (element.getNextSibling()?.getText() == ";") {
             element.getNextSibling()!!.delete()
         }
-        val psiFactory = JetPsiFactory(element.getProject())
+        val psiFactory = JetPsiFactory(element)
         val newElement = bodyNode!!.getPsi()!!.replace(psiFactory.createFunctionBody(bodyNode.getText()))
 
         //handles the case of the block statement being on a new line

idea/src/org/jetbrains/jet/plugin/intentions/ConvertAssertToIfWithThrowIntention.kt

@@ -61,7 +61,7 @@ public class ConvertAssertToIfWithThrowIntention : JetSelfTargetingIntention<Jet
         val condition = args[0]?.getArgumentExpression()
         val lambdas = element.getFunctionLiteralArguments()
 
-        val psiFactory = JetPsiFactory(element.getProject())
+        val psiFactory = JetPsiFactory(element)
         val messageExpr =
                 if (args.size == 2) {
                     args[1]?.getArgumentExpression()

idea/src/org/jetbrains/jet/plugin/intentions/ConvertIfWithThrowToAssertIntention.kt

@@ -71,7 +71,7 @@ public class ConvertIfWithThrowToAssertIntention :
                 ""
             }
 
-        val psiFactory = JetPsiFactory(element.getProject())
+        val psiFactory = JetPsiFactory(element)
         val negatedCondition = psiFactory.createExpression("!true") as JetPrefixExpression
         negatedCondition.getBaseExpression()!!.replace(condition)
         condition.replace(negatedCondition)

idea/src/org/jetbrains/jet/plugin/intentions/ConvertNegatedBooleanSequenceIntention.kt

@@ -54,7 +54,7 @@ public class ConvertNegatedBooleanSequenceIntention : JetSelfTargetingIntention<
                 "!(${bareExpressions.last()}", { negated, expression -> "$expression $operatorText $negated" }
         )
 
-        val newExpression = JetPsiFactory(element.getProject()).createExpression("$negatedExpression)")
+        val newExpression = JetPsiFactory(element).createExpression("$negatedExpression)")
 
         val insertedElement = element.replace(newExpression)
         val insertedElementParent = insertedElement.getParent() as? JetParenthesizedExpression ?: return

idea/src/org/jetbrains/jet/plugin/intentions/ConvertNegatedExpressionWithDemorgansLawIntention.kt

@@ -64,7 +64,7 @@ public class ConvertNegatedExpressionWithDemorgansLawIntention : JetSelfTargetin
         val negatedExpression = negatedElements.subList(0, negatedElements.lastIndex).foldRight(
                 "${negatedElements.last()}", { negated, exp -> "$exp $operatorText $negated" })
 
-        val newExpression = JetPsiFactory(element.getProject()).createExpression(negatedExpression)
+        val newExpression = JetPsiFactory(element).createExpression(negatedExpression)
         element.replace(newExpression)
     }
 

idea/src/org/jetbrains/jet/plugin/intentions/ConvertToBlockBodyAction.kt

@@ -44,7 +44,7 @@ public class ConvertToBlockBodyAction : PsiElementBaseIntentionAction() {
 
             val oldBodyText = body.getText()!!
             val newBodyText = if (needReturn) "return ${oldBodyText}" else oldBodyText
-            return JetPsiFactory(project).createFunctionBody(newBodyText)
+            return JetPsiFactory(declaration).createFunctionBody(newBodyText)
         }
 
         if (declaration is JetNamedFunction) {

idea/src/org/jetbrains/jet/plugin/intentions/ConvertToConcatenatedStringIntention.kt

@@ -32,7 +32,7 @@ public class ConvertToConcatenatedStringIntention : JetSelfTargetingIntention<Je
                 .makeString(separator = "+")
                 .replaceAll("""$quote\+$quote""", "")
 
-        val replacement = JetPsiFactory(element.getProject()).createExpression(result)
+        val replacement = JetPsiFactory(element).createExpression(result)
 
         element.replace(replacement)
     }

idea/src/org/jetbrains/jet/plugin/intentions/ConvertToExpressionBodyAction.kt

@@ -46,7 +46,7 @@ public class ConvertToExpressionBodyAction : PsiElementBaseIntentionAction() {
         }
 
         val body = declaration.getBodyExpression()!!
-        declaration.addBefore(JetPsiFactory(project).createEQ(), body)
+        declaration.addBefore(JetPsiFactory(declaration).createEQ(), body)
         body.replace(value)
     }
 

idea/src/org/jetbrains/jet/plugin/intentions/ConvertToForEachFunctionCallIntention.kt

@@ -62,6 +62,6 @@ public class ConvertToForEachFunctionCallIntention : JetSelfTargetingIntention<J
             else -> body.getText() ?: throw AssertionError("Body of ForExpression shouldn't be empty: expressionText = ${element.getText()}")
         })
 
-        element.replace(JetPsiFactory(element.getProject()).createExpression("${buildReceiverText(element)}.forEach { $bodyText }"))
+        element.replace(JetPsiFactory(element).createExpression("${buildReceiverText(element)}.forEach { $bodyText }"))
     }
 }

idea/src/org/jetbrains/jet/plugin/intentions/ConvertToForEachLoopIntention.kt

@@ -113,6 +113,6 @@ public class ConvertToForEachLoopIntention : JetSelfTargetingIntention<JetExpres
 
         val functionLiteral = getFunctionLiteralArgument(element)!!
 
-        element.replace(JetPsiFactory(element.getProject()).createExpression(generateLoopText(receiver, functionLiteral)))
+        element.replace(JetPsiFactory(element).createExpression(generateLoopText(receiver, functionLiteral)))
     }
 }

idea/src/org/jetbrains/jet/plugin/intentions/ConvertToStringTemplateIntention.kt

@@ -57,7 +57,7 @@ public class ConvertToStringTemplateIntention : JetSelfTargetingIntention<JetBin
 
         val rightStr = mkString(element.getRight(), false)
         val resultStr = fold(element.getLeft(), rightStr)
-        val expr = JetPsiFactory(element.getProject()).createExpression(resultStr)
+        val expr = JetPsiFactory(element).createExpression(resultStr)
 
         element.replace(expr)
     }

idea/src/org/jetbrains/jet/plugin/intentions/InsertCurlyBracesToTemplateIntention.kt

@@ -28,6 +28,6 @@ public class InsertCurlyBracesToTemplateIntention : JetSelfTargetingIntention<Je
     override fun applyTo(element: JetSimpleNameStringTemplateEntry, editor: Editor) {
         val expression = element.getExpression()
         if (expression == null) return
-        element.replace(JetPsiFactory(element.getProject()).createBlockStringTemplateEntry(expression))
+        element.replace(JetPsiFactory(element).createBlockStringTemplateEntry(expression))
     }
 }

idea/src/org/jetbrains/jet/plugin/intentions/InsertExplicitTypeArguments.kt

@@ -55,7 +55,7 @@ public class InsertExplicitTypeArguments : JetSelfTargetingIntention<JetCallExpr
         val args = resolvedCall.getTypeArguments()
         val types = resolvedCall.getCandidateDescriptor().getTypeParameters()
 
-        val psiFactory = JetPsiFactory(element.getProject())
+        val psiFactory = JetPsiFactory(element)
         val typeArgs = types.map {
             assert(args[it] != null, "there is a null in the type arguments to transform")
             val typeToCompute = DescriptorRenderer.FQ_NAMES_IN_TYPES.renderType(args[it]!!);

idea/src/org/jetbrains/jet/plugin/intentions/InvertIfConditionIntention.kt

@@ -64,7 +64,7 @@ public class InvertIfConditionIntention : JetSelfTargetingIntention<JetIfExpress
     }
 
     override fun applyTo(element: JetIfExpression, editor: Editor) {
-        val psiFactory = JetPsiFactory(element.getProject())
+        val psiFactory = JetPsiFactory(element)
 
         fun isNegatableOperator(token: IElementType): Boolean {
             return token in array(JetTokens.EQEQ, JetTokens.EXCLEQ, JetTokens.EQEQEQ, JetTokens.EXCLEQEQEQ, JetTokens.IS_KEYWORD, JetTokens.NOT_IS, JetTokens.IN_KEYWORD, JetTokens.NOT_IN, JetTokens.LT, JetTokens.LTEQ, JetTokens.GT, JetTokens.GTEQ)

idea/src/org/jetbrains/jet/plugin/intentions/MakeTypeExplicitInLambdaIntention.kt

@@ -63,7 +63,7 @@ public class MakeTypeExplicitInLambdaIntention : JetSelfTargetingIntention<JetFu
         val parameterString = valueParameters.map({descriptor -> "" + descriptor.getName() +
                                                       ": " + DescriptorRenderer.SOURCE_CODE.renderType(descriptor.getType())
                                                   }).makeString(", ", "(", ")")
-        val psiFactory = JetPsiFactory(element.getProject())
+        val psiFactory = JetPsiFactory(element)
         val newParameterList = psiFactory.createParameterList(parameterString)
         val oldParameterList = functionLiteral.getValueParameterList()
         if (oldParameterList != null) {

idea/src/org/jetbrains/jet/plugin/intentions/MakeTypeImplicitInLambdaIntention.kt

@@ -42,7 +42,7 @@ public class MakeTypeImplicitInLambdaIntention : JetSelfTargetingIntention<JetFu
         val functionLiteral = element.getFunctionLiteral()
         val oldParameterList = functionLiteral.getValueParameterList()
 
-        val psiFactory = JetPsiFactory(element.getProject())
+        val psiFactory = JetPsiFactory(element)
         if (hasExplicitReturnType(element)) {
             val childAfterParamList = oldParameterList?.getNextSibling()
             val arrow = functionLiteral.getArrowNode()?.getPsi()

idea/src/org/jetbrains/jet/plugin/intentions/MoveLambdaInsideParenthesesIntention.kt

@@ -49,6 +49,6 @@ public class MoveLambdaInsideParenthesesIntention : JetSelfTargetingIntention<Je
             sb.append("$literalName = ")
         }
         val newExpression = "$funName${sb.toString()}${element.getFunctionLiteralArguments()[0].getText()})"
-        element.replace(JetPsiFactory(element.getProject()).createExpression(newExpression))
+        element.replace(JetPsiFactory(element).createExpression(newExpression))
     }
 }

idea/src/org/jetbrains/jet/plugin/intentions/MoveLambdaOutsideParenthesesIntention.kt

@@ -49,6 +49,6 @@ public class MoveLambdaOutsideParenthesesIntention : JetSelfTargetingIntention<J
             } else {
                 "$calleeText$params $functionLiteral"
             }
-        element.replace(JetPsiFactory(element.getProject()).createExpression(newCall))
+        element.replace(JetPsiFactory(element).createExpression(newCall))
     }
 }

idea/src/org/jetbrains/jet/plugin/intentions/OperatorToFunctionIntention.kt

@@ -92,7 +92,7 @@ public class OperatorToFunctionIntention : JetSelfTargetingIntention<JetExpressi
         }
 
         val transformation = "$base.$call"
-        val transformed = JetPsiFactory(element.getProject()).createExpression(transformation)
+        val transformed = JetPsiFactory(element).createExpression(transformation)
         element.replace(transformed)
     }
 
@@ -107,7 +107,7 @@ public class OperatorToFunctionIntention : JetSelfTargetingIntention<JetExpressi
         }
 
         val transformation = "$base.$call"
-        val transformed = JetPsiFactory(element.getProject()).createExpression(transformation)
+        val transformed = JetPsiFactory(element).createExpression(transformation)
         element.replace(transformed)
     }
 
@@ -153,7 +153,7 @@ public class OperatorToFunctionIntention : JetSelfTargetingIntention<JetExpressi
             else -> return
         }
 
-        val transformed = JetPsiFactory(element.getProject()).createExpression(transformation)
+        val transformed = JetPsiFactory(element).createExpression(transformation)
 
         element.replace(transformed)
     }
@@ -177,7 +177,7 @@ public class OperatorToFunctionIntention : JetSelfTargetingIntention<JetExpressi
             replaced = element
         }
 
-        val transformed = JetPsiFactory(element.getProject()).createExpression(transformation)
+        val transformed = JetPsiFactory(element).createExpression(transformation)
         replaced.replace(transformed)
     }
 
@@ -188,7 +188,7 @@ public class OperatorToFunctionIntention : JetSelfTargetingIntention<JetExpressi
         val funcLitArgs = element.getFunctionLiteralArguments()
         val calleeText = callee.getText()
         val transformation = if (argumentString == null) "$calleeText.invoke" else "$calleeText.invoke($argumentString)"
-        val transformed = JetPsiFactory(element.getProject()).createExpression(transformation)
+        val transformed = JetPsiFactory(element).createExpression(transformation)
         funcLitArgs.forEach { transformed.add(it) }
         callee.getParent()!!.replace(transformed)
     }

idea/src/org/jetbrains/jet/plugin/intentions/ReconstructTypeInCastOrIsAction.java

@@ -45,7 +45,7 @@ public class ReconstructTypeInCastOrIsAction extends PsiElementBaseIntentionActi
         assert typeRef != null : "Must be checked by isAvailable(): " + element;
 
         JetType type = getReconstructedType(typeRef);
-        JetTypeReference newType = JetPsiFactory(project).createType(DescriptorRenderer.SOURCE_CODE.renderType(type));
+        JetTypeReference newType = JetPsiFactory(typeRef).createType(DescriptorRenderer.SOURCE_CODE.renderType(type));
         JetTypeReference replaced = (JetTypeReference) typeRef.replace(newType);
         ShortenReferences.instance$.process(replaced);
     }

idea/src/org/jetbrains/jet/plugin/intentions/RemoveBracesIntention.kt

@@ -50,11 +50,10 @@ public class RemoveBracesIntention : JetSelfTargetingIntention<JetExpressionImpl
 
         handleComments(element, jetBlockElement)
 
-        val project = element.getProject()
         val newElement = jetBlockElement.replace(firstStatement.copy())
 
         if (expressionKind == ExpressionKind.DOWHILE) {
-            newElement.getParent()!!.addAfter(JetPsiFactory(project).createNewLine(), newElement)
+            newElement.getParent()!!.addAfter(JetPsiFactory(element).createNewLine(), newElement)
         }
     }
 
@@ -64,11 +63,12 @@ public class RemoveBracesIntention : JetSelfTargetingIntention<JetExpressionImpl
         while (sibling != null) {
             if (sibling is PsiComment) {
                 //cleans up extra whitespace
+                val psiFactory = JetPsiFactory(element)
                 if (element.getPrevSibling() is PsiWhiteSpace) {
-                    element.getPrevSibling()!!.replace(JetPsiFactory(element.getProject()).createNewLine())
+                    element.getPrevSibling()!!.replace(psiFactory.createNewLine())
                 }
                 val commentElement = element.getParent()!!.addBefore(sibling as PsiComment, element.getPrevSibling())
-                element.getParent()!!.addBefore(JetPsiFactory(element.getProject()).createNewLine(), commentElement)
+                element.getParent()!!.addBefore(psiFactory.createNewLine(), commentElement)
             }
             sibling = sibling!!.getNextSibling()
         }

idea/src/org/jetbrains/jet/plugin/intentions/RemoveCurlyBracesFromTemplateIntention.kt

@@ -46,6 +46,6 @@ public class RemoveCurlyBracesFromTemplateIntention : JetSelfTargetingIntention<
         val tripleQuotes = parent.getFirstChild()?.getText()?.startsWith("\"\"\"")
         if (tripleQuotes == null) return
         val newExpression = if (tripleQuotes) "\"\"\"${sb.toString()}\"\"\"" else "\"${sb.toString()}\""
-        parent.replace(JetPsiFactory(element.getProject()).createExpression(newExpression))
+        parent.replace(JetPsiFactory(element).createExpression(newExpression))
     }
 }

idea/src/org/jetbrains/jet/plugin/intentions/ReplaceItWithExplicitFunctionLiteralParamIntention.kt

@@ -43,7 +43,7 @@ public class ReplaceItWithExplicitFunctionLiteralParamIntention() : PsiElementBa
 
         val funcExpr = DescriptorToSourceUtils.descriptorToDeclaration(target.getContainingDeclaration()!!) as JetFunctionLiteral
 
-        val newExpr = JetPsiFactory(project).createExpression("{ it -> 42 }") as JetFunctionLiteralExpression
+        val newExpr = JetPsiFactory(simpleNameExpression).createExpression("{ it -> 42 }") as JetFunctionLiteralExpression
         funcExpr.addRangeAfter(newExpr.getFunctionLiteral().getValueParameterList(),
                                newExpr.getFunctionLiteral().getArrowNode()!!.getPsi(),
                                funcExpr.getOpenBraceNode().getPsi())

idea/src/org/jetbrains/jet/plugin/intentions/ReplaceWithDotQualifiedMethodCallIntention.kt

@@ -42,7 +42,7 @@ public class ReplaceWithDotQualifiedMethodCallIntention : JetSelfTargetingIntent
                 }
         )
 
-        val replacement = JetPsiFactory(element.getProject()).createExpression(replacementExpressionStringBuilder.toString())
+        val replacement = JetPsiFactory(element).createExpression(replacementExpressionStringBuilder.toString())
         element.replace(replacement)
     }
 }

idea/src/org/jetbrains/jet/plugin/intentions/ReplaceWithInfixFunctionCallIntention.kt

@@ -109,7 +109,7 @@ public open class ReplaceWithInfixFunctionCallIntention : JetSelfTargetingIntent
                     functionLiteralArguments.first().getText()
         )
 
-        val replacement = JetPsiFactory(element.getProject()).createExpression("$leftHandText $operatorText ${rightHandTextStringBuilder.toString()}")
+        val replacement = JetPsiFactory(element).createExpression("$leftHandText $operatorText ${rightHandTextStringBuilder.toString()}")
 
         parent.replace(replacement)
     }

idea/src/org/jetbrains/jet/plugin/intentions/ReplaceWithOperatorAssignIntention.kt

@@ -111,6 +111,6 @@ public class ReplaceWithOperatorAssignIntention : JetSelfTargetingIntention<JetB
             }
         }
 
-        element.replace(JetPsiFactory(element.getProject()).createExpression(buildReplacement(element.getLeft() as JetSimpleNameExpression, element.getRight() as JetBinaryExpression, StringBuilder())))
+        element.replace(JetPsiFactory(element).createExpression(buildReplacement(element.getLeft() as JetSimpleNameExpression, element.getRight() as JetBinaryExpression, StringBuilder())))
     }
 }

idea/src/org/jetbrains/jet/plugin/intentions/ReplaceWithTraditionalAssignmentIntention.kt

@@ -53,6 +53,6 @@ public class ReplaceWithTraditionalAssignmentIntention : JetSelfTargetingIntenti
             return replacementStringBuilder.toString()
         }
 
-        element.replace(JetPsiFactory(element.getProject()).createExpression(buildReplacement(element)))
+        element.replace(JetPsiFactory(element).createExpression(buildReplacement(element)))
     }
 }

idea/src/org/jetbrains/jet/plugin/intentions/SimplifyBooleanWithConstantsIntention.kt

@@ -67,7 +67,7 @@ public class SimplifyBooleanWithConstantsIntention : JetSelfTargetingIntention<J
     }
 
     private fun simplifyBoolean(element: JetExpression) : JetExpression {
-        val psiFactory = JetPsiFactory(element.getProject())
+        val psiFactory = JetPsiFactory(element)
         if (element.canBeReducedToTrue())
             return psiFactory.createExpression("true")
         if (element.canBeReducedToFalse())
@@ -115,7 +115,7 @@ public class SimplifyBooleanWithConstantsIntention : JetSelfTargetingIntention<J
             operation: IElementType
     ): JetExpression {
         assert(booleanConstantOperand.canBeReducedToBooleanConstant(null), "should only be called when we know it can be reduced")
-        val psiFactory = JetPsiFactory(otherOperand.getProject())
+        val psiFactory = JetPsiFactory(otherOperand)
         if (booleanConstantOperand.canBeReducedToTrue() && operation == JetTokens.OROR)
             return psiFactory.createExpression("true")
         if (booleanConstantOperand.canBeReducedToFalse() && operation == JetTokens.ANDAND)

idea/src/org/jetbrains/jet/plugin/intentions/SimplifyNegatedBinaryExpressionIntention.kt

@@ -74,7 +74,7 @@ public class SimplifyNegatedBinaryExpressionIntention : JetSelfTargetingIntentio
         val expression = element.unparenthesize()!!
         val invertedOperation = JetPsiUtil.getOperationToken(expression as JetOperationExpression)!!.negate()!!
 
-        val psiFactory = JetPsiFactory(expression.getProject())
+        val psiFactory = JetPsiFactory(expression)
         element.replace(
                 when (expression) {
                     is JetIsExpression -> {

idea/src/org/jetbrains/jet/plugin/intentions/SpecifyTypeExplicitlyAction.java

@@ -264,7 +264,7 @@ public class SpecifyTypeExplicitlyAction extends PsiElementBaseIntentionAction {
     }
 
     private static void addTypeAnnotationSilently(Project project, JetNamedDeclaration namedDeclaration, PsiElement anchor) {
-        JetPsiFactory psiFactory = PsiPackage.JetPsiFactory(project);
+        JetPsiFactory psiFactory = PsiPackage.JetPsiFactory(namedDeclaration);
         namedDeclaration.addAfter(psiFactory.createType("Any"), anchor);
         namedDeclaration.addAfter(psiFactory.createColon(), anchor);
     }

idea/src/org/jetbrains/jet/plugin/intentions/SplitIfIntention.kt

@@ -59,7 +59,7 @@ public class SplitIfIntention : JetSelfTargetingIntention<JetExpression>("split.
         val elseExpression = ifExpression.getElse()
         val thenExpression = ifExpression.getThen()
 
-        val psiFactory = JetPsiFactory(element.getProject())
+        val psiFactory = JetPsiFactory(element)
         if (currentElement.getReferencedNameElementType() == JetTokens.ANDAND) {
             ifExpression.replace(
                     psiFactory.createIf(leftExpression, psiFactory.wrapInABlock(
@@ -80,7 +80,7 @@ public class SplitIfIntention : JetSelfTargetingIntention<JetExpression>("split.
         val startOffset = element.getRight()!!.getTextOffset() - condition.getTextOffset()
         val rightString = condition.getText()!![startOffset, condition.getTextLength()].toString()
 
-        return JetPsiFactory(element.getProject()).createExpression(rightString)
+        return JetPsiFactory(element).createExpression(rightString)
     }
 
     fun isCursorOnIfKeyword(element: JetIfExpression, editor: Editor): Boolean {

idea/src/org/jetbrains/jet/plugin/intentions/SwapBinaryExpression.kt

@@ -61,7 +61,7 @@ public class SwapBinaryExpression : JetSelfTargetingIntention<JetBinaryExpressio
         }
         val left = leftSubject(element)!!
         val right = rightSubject(element)!!
-        val psiFactory = JetPsiFactory(element.getProject())
+        val psiFactory = JetPsiFactory(element)
         val newRight = psiFactory.createExpression(left.getText()!!)
         val newLeft = psiFactory.createExpression(right.getText()!!)
         left.replace(newLeft)

idea/src/org/jetbrains/jet/plugin/intentions/Utils.kt

@@ -27,21 +27,20 @@ import org.jetbrains.jet.lexer.JetTokens
 import org.jetbrains.jet.plugin.caches.resolve.getLazyResolveSession
 
 fun specifyTypeExplicitly(declaration: JetNamedFunction, typeText: String) {
-    specifyTypeExplicitly(declaration, JetPsiFactory(declaration.getProject()).createType(typeText))
+    specifyTypeExplicitly(declaration, JetPsiFactory(declaration).createType(typeText))
 }
 
 fun specifyTypeExplicitly(declaration: JetNamedFunction, `type`: JetType) {
     if (`type`.isError()) return
-    val typeReference = JetPsiFactory(declaration.getProject()).createType(DescriptorRenderer.SOURCE_CODE.renderType(`type`))
+    val typeReference = JetPsiFactory(declaration).createType(DescriptorRenderer.SOURCE_CODE.renderType(`type`))
     specifyTypeExplicitly(declaration, typeReference)
     ShortenReferences.process(declaration.getReturnTypeRef()!!)
 }
 
 fun specifyTypeExplicitly(declaration: JetNamedFunction, typeReference: JetTypeReference) {
-    val project = declaration.getProject()
     val anchor = declaration.getValueParameterList() ?: return/*incomplete declaration*/
     declaration.addAfter(typeReference, anchor)
-    declaration.addAfter(JetPsiFactory(project).createColon(), anchor)
+    declaration.addAfter(JetPsiFactory(declaration).createColon(), anchor)
 }
 
 fun expressionType(expression: JetExpression): JetType? {

idea/src/org/jetbrains/jet/plugin/intentions/attributeCallReplacements/ReplaceBinaryInfixIntention.kt

@@ -50,7 +50,7 @@ public open class ReplaceBinaryInfixIntention : AttributeCallReplacementIntentio
         val argument = (handleErrors(editor, call.getPositionalArguments()) ?: return)[0].getArgumentExpression()
 
         call.element.replace(
-                JetPsiFactory(call.element.getProject()).createBinaryExpression(
+                JetPsiFactory(call.element).createBinaryExpression(
                         call.element.getReceiverExpression(),
                         lookup(call.functionName)!!,  // Lookup must succeed
                         argument

idea/src/org/jetbrains/jet/plugin/intentions/attributeCallReplacements/ReplaceContainsIntention.kt

@@ -42,7 +42,7 @@ public open class ReplaceContainsIntention : AttributeCallReplacementIntention("
         val argument = (handleErrors(editor, call.getPositionalArguments()) ?: return)[0].getArgumentExpression()
 
         // Append semicolon to previous statement if needed
-        val psiFactory = JetPsiFactory(call.element.getProject())
+        val psiFactory = JetPsiFactory(call.element)
         if (argument is JetFunctionLiteralExpression) {
             val previousElement = JetPsiUtil.skipSiblingsBackwardByPredicate(call.element) {
                 // I checked, it can't be null.

idea/src/org/jetbrains/jet/plugin/intentions/attributeCallReplacements/ReplaceGetIntention.kt

@@ -29,7 +29,7 @@ public open class ReplaceGetIntention : AttributeCallReplacementIntention("repla
             it.getArgumentExpression()?.getText() ?: ""
         }.makeString(", ")
 
-        call.element.replace(JetPsiFactory(call.element.getProject()).createExpression(
+        call.element.replace(JetPsiFactory(call.element).createExpression(
                 "${call.element.getReceiverExpression().getText()}[${argumentString}]"
         ))
     }

idea/src/org/jetbrains/jet/plugin/intentions/attributeCallReplacements/ReplaceInvokeIntention.kt

@@ -26,7 +26,7 @@ public open class ReplaceInvokeIntention : AttributeCallReplacementIntention("re
     }
 
     override fun replaceCall(call: CallDescription, editor: Editor) {
-        call.element.replace(JetPsiFactory(call.element.getProject()).createExpression(
+        call.element.replace(JetPsiFactory(call.element).createExpression(
                 call.element.getReceiverExpression().getText() +
                 (call.callElement.getTypeArgumentList()?.getText() ?: "") +
                 (call.callElement.getValueArgumentList()?.getText() ?: "") +

idea/src/org/jetbrains/jet/plugin/intentions/attributeCallReplacements/ReplaceUnaryPrefixIntention.kt

@@ -44,7 +44,7 @@ public open class ReplaceUnaryPrefixIntention : AttributeCallReplacementIntentio
     }
 
     override fun replaceCall(call: CallDescription, editor: Editor) {
-        call.element.replace(JetPsiFactory(call.element.getProject()).createExpression(
+        call.element.replace(JetPsiFactory(call.element).createExpression(
                 lookup(call.functionName)!! + call.element.getReceiverExpression().getText()
         ))
     }

idea/src/org/jetbrains/jet/plugin/intentions/branchedTransformations/BranchedFoldingUtils.java

@@ -166,8 +166,6 @@ public class BranchedFoldingUtils {
     }
 
     public static void foldIfExpressionWithAssignments(JetIfExpression ifExpression) {
-        Project project = ifExpression.getProject();
-
         JetBinaryExpression thenAssignment = getFoldableBranchedAssignment(ifExpression.getThen());
 
         assertNotNull(thenAssignment);
@@ -175,7 +173,7 @@ public class BranchedFoldingUtils {
         String op = thenAssignment.getOperationReference().getText();
         JetSimpleNameExpression lhs = (JetSimpleNameExpression) thenAssignment.getLeft();
 
-        JetBinaryExpression assignment = JetPsiFactory(project).createBinaryExpression(lhs, op, ifExpression);
+        JetBinaryExpression assignment = JetPsiFactory(ifExpression).createBinaryExpression(lhs, op, ifExpression);
         JetIfExpression newIfExpression = (JetIfExpression)assignment.getRight();
 
         assertNotNull(newIfExpression);
@@ -202,9 +200,7 @@ public class BranchedFoldingUtils {
     }
 
     public static void foldIfExpressionWithReturns(JetIfExpression ifExpression) {
-        Project project = ifExpression.getProject();
-
-        JetReturnExpression newReturnExpression = JetPsiFactory(project).createReturn(ifExpression);
+        JetReturnExpression newReturnExpression = JetPsiFactory(ifExpression).createReturn(ifExpression);
         JetIfExpression newIfExpression = (JetIfExpression)newReturnExpression.getReturnedExpression();
 
         assertNotNull(newIfExpression);
@@ -231,8 +227,6 @@ public class BranchedFoldingUtils {
     }
 
     public static void foldIfExpressionWithAsymmetricReturns(JetIfExpression ifExpression) {
-        Project project = ifExpression.getProject();
-
         JetExpression condition = ifExpression.getCondition();
         JetExpression thenRoot = ifExpression.getThen();
         JetExpression elseRoot = (JetExpression)JetPsiUtil.skipTrailingWhitespacesAndComments(ifExpression);
@@ -242,7 +236,7 @@ public class BranchedFoldingUtils {
         assertNotNull(elseRoot);
 
         //noinspection ConstantConditions
-        JetPsiFactory psiFactory = JetPsiFactory(project);
+        JetPsiFactory psiFactory = JetPsiFactory(ifExpression);
         JetIfExpression newIfExpression = psiFactory.createIf(condition, thenRoot, elseRoot);
         JetReturnExpression newReturnExpression = psiFactory.createReturn(newIfExpression);
 
@@ -274,8 +268,6 @@ public class BranchedFoldingUtils {
 
     @SuppressWarnings("ConstantConditions")
     public static void foldWhenExpressionWithAssignments(JetWhenExpression whenExpression) {
-        Project project = whenExpression.getProject();
-
         assert !whenExpression.getEntries().isEmpty() : FOLD_WITHOUT_CHECK;
 
         JetBinaryExpression firstAssignment = getFoldableBranchedAssignment(whenExpression.getEntries().get(0).getExpression());
@@ -285,7 +277,7 @@ public class BranchedFoldingUtils {
         String op = firstAssignment.getOperationReference().getText();
         JetSimpleNameExpression lhs = (JetSimpleNameExpression) firstAssignment.getLeft();
 
-        JetBinaryExpression assignment = JetPsiFactory(project).createBinaryExpression(lhs, op, whenExpression);
+        JetBinaryExpression assignment = JetPsiFactory(whenExpression).createBinaryExpression(lhs, op, whenExpression);
         JetWhenExpression newWhenExpression = (JetWhenExpression)assignment.getRight();
 
         assertNotNull(newWhenExpression);
@@ -306,11 +298,9 @@ public class BranchedFoldingUtils {
     }
 
     public static void foldWhenExpressionWithReturns(JetWhenExpression whenExpression) {
-        Project project = whenExpression.getProject();
-
         assert !whenExpression.getEntries().isEmpty() : FOLD_WITHOUT_CHECK;
 
-        JetReturnExpression newReturnExpression = JetPsiFactory(project).createReturn(whenExpression);
+        JetReturnExpression newReturnExpression = JetPsiFactory(whenExpression).createReturn(whenExpression);
         JetWhenExpression newWhenExpression = (JetWhenExpression)newReturnExpression.getReturnedExpression();
 
         assertNotNull(newWhenExpression);

idea/src/org/jetbrains/jet/plugin/intentions/branchedTransformations/BranchedUnfoldingUtils.java

@@ -79,7 +79,6 @@ public class BranchedUnfoldingUtils {
     }
 
     public static void unfoldAssignmentToIf(@NotNull JetBinaryExpression assignment, @NotNull Editor editor) {
-        Project project = assignment.getProject();
         String op = assignment.getOperationReference().getText();
         JetExpression lhs = assignment.getLeft();
         JetIfExpression ifExpression = (JetIfExpression) assignment.getRight();
@@ -96,7 +95,7 @@ public class BranchedUnfoldingUtils {
         assertNotNull(elseExpr);
 
         //noinspection ConstantConditions
-        JetPsiFactory psiFactory = JetPsiFactory(project);
+        JetPsiFactory psiFactory = JetPsiFactory(assignment);
         thenExpr.replace(psiFactory.createBinaryExpression(lhs, op, thenExpr));
         elseExpr.replace(psiFactory.createBinaryExpression(lhs, op, elseExpr));
 
@@ -106,7 +105,6 @@ public class BranchedUnfoldingUtils {
     }
 
     public static void unfoldAssignmentToWhen(@NotNull JetBinaryExpression assignment, @NotNull Editor editor) {
-        Project project = assignment.getProject();
         String op = assignment.getOperationReference().getText();
         JetExpression lhs = assignment.getLeft();
         JetWhenExpression whenExpression = (JetWhenExpression) assignment.getRight();
@@ -122,7 +120,7 @@ public class BranchedUnfoldingUtils {
             assertNotNull(currExpr);
 
             //noinspection ConstantConditions
-            currExpr.replace(JetPsiFactory(project).createBinaryExpression(lhs, op, currExpr));
+            currExpr.replace(JetPsiFactory(assignment).createBinaryExpression(lhs, op, currExpr));
         }
 
         PsiElement resultElement = assignment.replace(newWhenExpression);
@@ -141,7 +139,6 @@ public class BranchedUnfoldingUtils {
     }
 
     public static void unfoldReturnToIf(@NotNull JetReturnExpression returnExpression) {
-        Project project = returnExpression.getProject();
         JetIfExpression ifExpression = (JetIfExpression) returnExpression.getReturnedExpression();
 
         assertNotNull(ifExpression);
@@ -155,7 +152,7 @@ public class BranchedUnfoldingUtils {
         assertNotNull(thenExpr);
         assertNotNull(elseExpr);
 
-        JetPsiFactory psiFactory = JetPsiFactory(project);
+        JetPsiFactory psiFactory = JetPsiFactory(returnExpression);
         thenExpr.replace(psiFactory.createReturn(thenExpr));
         elseExpr.replace(psiFactory.createReturn(elseExpr));
 
@@ -163,7 +160,6 @@ public class BranchedUnfoldingUtils {
     }
 
     public static void unfoldReturnToWhen(@NotNull JetReturnExpression returnExpression) {
-        Project project = returnExpression.getProject();
         JetWhenExpression whenExpression = (JetWhenExpression) returnExpression.getReturnedExpression();
 
         assertNotNull(whenExpression);
@@ -176,7 +172,7 @@ public class BranchedUnfoldingUtils {
 
             assertNotNull(currExpr);
 
-            currExpr.replace(JetPsiFactory(project).createReturn(currExpr));
+            currExpr.replace(JetPsiFactory(returnExpression).createReturn(currExpr));
         }
 
         returnExpression.replace(newWhenExpression);

idea/src/org/jetbrains/jet/plugin/intentions/branchedTransformations/IfThenUtils.kt

@@ -42,6 +42,7 @@ import org.jetbrains.jet.lang.psi.JetThrowExpression
 import org.jetbrains.jet.lang.psi.JetPostfixExpression
 import org.jetbrains.jet.lang.psi.JetCallExpression
 import org.jetbrains.jet.lang.resolve.DescriptorUtils
+import org.jetbrains.jet.lang.psi.JetElement
 
 val NULL_PTR_EXCEPTION = "NullPointerException"
 val NULL_PTR_EXCEPTION_FQ = "java.lang.NullPointerException"
@@ -121,12 +122,12 @@ fun JetExpression.evaluatesTo(other: JetExpression): Boolean {
 }
 
 fun JetExpression.convertToIfNotNullExpression(conditionLhs: JetExpression, thenClause: JetExpression, elseClause: JetExpression?): JetIfExpression {
-    val condition = JetPsiFactory(this.getProject()).createExpression("${conditionLhs.getText()} != null")
+    val condition = JetPsiFactory(this).createExpression("${conditionLhs.getText()} != null")
     return this.convertToIfStatement(condition, thenClause, elseClause)
 }
 
 fun JetExpression.convertToIfNullExpression(conditionLhs: JetExpression, thenClause: JetExpression): JetIfExpression {
-    val condition = JetPsiFactory(this.getProject()).createExpression("${conditionLhs.getText()} == null")
+    val condition = JetPsiFactory(this).createExpression("${conditionLhs.getText()} == null")
     return this.convertToIfStatement(condition, thenClause, null)
 }
 
@@ -144,8 +145,8 @@ fun JetIfExpression.introduceValueForCondition(occurrenceInThenClause: JetExpres
     KotlinIntroduceVariableHandler.doRefactoring(project, editor, occurrenceInConditional, listOf(occurrenceInConditional, occurrenceInThenClause))
 }
 
-fun PsiElement.replace(expressionAsString: String): PsiElement =
-        this.replace(JetPsiFactory(this.getProject()).createExpression(expressionAsString))
+fun JetElement.replace(expressionAsString: String): PsiElement =
+        this.replace(JetPsiFactory(this).createExpression(expressionAsString))
 
 fun JetSimpleNameExpression.inlineIfDeclaredLocallyAndOnlyUsedOnceWithPrompt(editor: Editor) {
     val declaration = this.getReference()?.resolve() as JetDeclaration

idea/src/org/jetbrains/jet/plugin/intentions/branchedTransformations/branchedTransformationUtils.kt

@@ -139,7 +139,7 @@ public fun JetWhenExpression.flatten(): JetWhenExpression {
 
     val outerEntries = getEntries()
     val innerEntries = nestedWhenExpression.getEntries()
-    val builder = JetPsiFactory(getProject()).WhenBuilder(subjectExpression)
+    val builder = JetPsiFactory(this).WhenBuilder(subjectExpression)
     for (entry in outerEntries) {
         if (entry.isElse())
             continue
@@ -156,7 +156,7 @@ public fun JetWhenExpression.flatten(): JetWhenExpression {
 public fun JetWhenExpression.introduceSubject(): JetWhenExpression {
     val subject = getSubjectCandidate()!!
 
-    val builder = JetPsiFactory(getProject()).WhenBuilder(subject)
+    val builder = JetPsiFactory(this).WhenBuilder(subject)
     for (entry in getEntries()) {
         val branchExpression = entry.getExpression()
         if (entry.isElse()) {
@@ -203,7 +203,7 @@ public fun JetWhenExpression.introduceSubject(): JetWhenExpression {
 public fun JetWhenExpression.eliminateSubject(): JetWhenExpression {
     val subject = getSubjectExpression()!!
 
-    val builder = JetPsiFactory(getProject()).WhenBuilder()
+    val builder = JetPsiFactory(this).WhenBuilder()
     for (entry in getEntries()) {
         val branchExpression = entry.getExpression()
 
@@ -264,7 +264,7 @@ public fun JetIfExpression.transformToWhen() {
         override fun hasNext(): Boolean = expression != null
     }
 
-    val builder = JetPsiFactory(getProject()).WhenBuilder()
+    val builder = JetPsiFactory(this).WhenBuilder()
     branchIterator(this).forEach { ifExpression ->
         ifExpression.getCondition()?.let { condition ->
             val orBranches = condition.splitToOrBranches()
@@ -304,7 +304,7 @@ public fun JetWhenExpression.transformToIf() {
         }
     }
 
-    val builder = JetPsiFactory(getProject()).IfChainBuilder()
+    val builder = JetPsiFactory(this).IfChainBuilder()
 
     for (entry in getEntries()) {
         val branch = entry.getExpression()
@@ -365,7 +365,7 @@ public fun JetWhenExpression.mergeWithNext() {
             val block = if (this is JetBlockExpression) this else replaced(wrapInBlock())
             for (element in that.blockExpressionsOrSingle()) {
                 val expression = block.appendElement(element)
-                block.addBefore(JetPsiFactory(getProject()).createNewLine(), expression)
+                block.addBefore(JetPsiFactory(this).createNewLine(), expression)
             }
             block
         }

idea/src/org/jetbrains/jet/plugin/intentions/branchedTransformations/intentions/DoubleBangToIfThenIntention.kt

@@ -45,11 +45,10 @@ public class DoubleBangToIfThenIntention : JetSelfTargetingIntention<JetPostfixE
             element.getOperationToken() == JetTokens.EXCLEXCL
 
     override fun applyTo(element: JetPostfixExpression, editor: Editor) {
-        val project = element.getProject()
         val base = checkNotNull(JetPsiUtil.deparenthesize(element.getBaseExpression()), "Base expression cannot be null")
         val expressionText = formatForUseInExceptionArgument(base.getText()!!)
 
-        val defaultException = JetPsiFactory(project).createExpression("throw $NULL_PTR_EXCEPTION()")
+        val defaultException = JetPsiFactory(element).createExpression("throw $NULL_PTR_EXCEPTION()")
 
         val isStatement = element.isStatement()
         val isStable = base.isStableVariable()
@@ -73,6 +72,7 @@ public class DoubleBangToIfThenIntention : JetSelfTargetingIntention<JetPostfixE
                     override fun getResult(element: String?) = element
                 }
 
+        val project = element.getProject()
         val manager = TemplateManagerImpl(project)
         val builder = TemplateBuilderImpl(thrownExpression)
         builder.replaceElement(thrownExpression, exceptionLookupExpression);

idea/src/org/jetbrains/jet/plugin/intentions/branchedTransformations/intentions/SafeAccessToIfThenIntention.kt

@@ -39,7 +39,7 @@ public class SafeAccessToIfThenIntention : JetSelfTargetingIntention<JetSafeQual
 
         val receiverTemplate = if (receiver is JetBinaryExpression) "(%s)" else "%s"
         val receiverAsString = receiverTemplate.format(receiver.getText())
-        val psiFactory = JetPsiFactory(element.getProject())
+        val psiFactory = JetPsiFactory(element)
         val dotQualifiedExpression = psiFactory.createExpression("${receiverAsString}.${selector!!.getText()}")
 
         val elseClause = if (element.isStatement()) null else psiFactory.createExpression("null")

idea/src/org/jetbrains/jet/plugin/intentions/declarations/ConvertMemberToExtension.java

@@ -114,7 +114,7 @@ public class ConvertMemberToExtension extends BaseIntentionAction {
                                (returnTypeRef != null ? ": " + returnTypeRef.getText() : "") +
                                body(member);
 
-        JetPsiFactory psiFactory = PsiPackage.JetPsiFactory(project);
+        JetPsiFactory psiFactory = PsiPackage.JetPsiFactory(member);
         JetDeclaration extension = psiFactory.<JetDeclaration>createDeclaration(extensionText);
 
         PsiElement added = file.addAfter(extension, outermostParent);

idea/src/org/jetbrains/jet/plugin/intentions/declarations/DeclarationUtils.java

@@ -96,8 +96,6 @@ public class DeclarationUtils {
     // returns assignment which replaces initializer
     @NotNull
     public static JetBinaryExpression splitPropertyDeclaration(@NotNull JetProperty property) {
-        Project project = property.getProject();
-
         PsiElement parent = property.getParent();
         assertNotNull(parent);
 
@@ -105,7 +103,7 @@ public class DeclarationUtils {
         JetExpression initializer = property.getInitializer();
         assertNotNull(initializer);
 
-        JetPsiFactory psiFactory = JetPsiFactory(project);
+        JetPsiFactory psiFactory = JetPsiFactory(property);
         //noinspection ConstantConditions, unchecked
         JetBinaryExpression newInitializer = psiFactory.createBinaryExpression(
                 psiFactory.createSimpleName(property.getName()), "=", initializer

idea/src/org/jetbrains/jet/plugin/quickfix/AddFunctionBodyFix.java

@@ -58,7 +58,7 @@ public class AddFunctionBodyFix extends JetIntentionAction<JetFunction> {
     @Override
     public void invoke(@NotNull Project project, Editor editor, JetFile file) throws IncorrectOperationException {
         JetFunction newElement = (JetFunction) element.copy();
-        JetPsiFactory psiFactory = JetPsiFactory(project);
+        JetPsiFactory psiFactory = JetPsiFactory(file);
         if (!(newElement.getLastChild() instanceof PsiWhiteSpace)) {
             newElement.add(psiFactory.createWhiteSpace());
         }

idea/src/org/jetbrains/jet/plugin/quickfix/AddNameToArgumentFix.java

@@ -145,7 +145,7 @@ public class AddNameToArgumentFix extends JetIntentionAction<JetValueArgument> {
     private static JetValueArgument getParsedArgumentWithName(@NotNull String name, @NotNull JetValueArgument argument) {
         JetExpression argumentExpression = argument.getArgumentExpression();
         assert argumentExpression != null : "Argument should be already parsed.";
-        return JetPsiFactory(argument.getProject()).createArgumentWithName(name, argumentExpression);
+        return JetPsiFactory(argument).createArgumentWithName(name, argumentExpression);
     }
 
     @NotNull

idea/src/org/jetbrains/jet/plugin/quickfix/AddSemicolonAfterFunctionCallFix.java

@@ -61,7 +61,7 @@ public class AddSemicolonAfterFunctionCallFix extends JetIntentionAction<JetCall
         int caretOffset = editor.getCaretModel().getOffset();
         element.getParent().addRangeAfter(afterArgumentList, literal, element);
         element.deleteChildRange(afterArgumentList, literal);
-        element.getParent().addAfter(JetPsiFactory(project).createSemicolon(), element);
+        element.getParent().addAfter(JetPsiFactory(file).createSemicolon(), element);
         editor.getCaretModel().moveToOffset(caretOffset + 1);
     }
 

idea/src/org/jetbrains/jet/plugin/quickfix/AddStarProjectionsFix.java

@@ -59,7 +59,7 @@ public abstract class AddStarProjectionsFix extends JetIntentionAction<JetUserTy
         assert element.getTypeArguments().isEmpty();
 
         String typeString = TypeReconstructionUtil.getTypeNameAndStarProjectionsString(element.getText(), argumentCount);
-        JetTypeElement replacement = JetPsiFactory(project).createType(typeString).getTypeElement();
+        JetTypeElement replacement = JetPsiFactory(file).createType(typeString).getTypeElement();
         assert replacement != null : "No type element after parsing " + typeString;
 
         element.replace(replacement);

idea/src/org/jetbrains/jet/plugin/quickfix/AddWhenElseBranchFix.java

@@ -65,7 +65,7 @@ public class AddWhenElseBranchFix extends JetIntentionAction<JetWhenExpression>
         PsiElement whenCloseBrace = element.getCloseBrace();
         assert (whenCloseBrace != null) : "isAvailable should check if close brace exist";
 
-        JetPsiFactory psiFactory = JetPsiFactory(project);
+        JetPsiFactory psiFactory = JetPsiFactory(file);
         JetWhenEntry entry = psiFactory.createWhenEntry(ELSE_ENTRY_TEXT);
 
         PsiElement insertedBranch = element.addBefore(entry, whenCloseBrace);

idea/src/org/jetbrains/jet/plugin/quickfix/CastExpressionFix.java

@@ -68,7 +68,7 @@ public class CastExpressionFix extends JetIntentionAction<JetExpression> {
 
     @Override
     public void invoke(@NotNull Project project, Editor editor, JetFile file) throws IncorrectOperationException {
-        JetPsiFactory psiFactory = JetPsiFactory(project);
+        JetPsiFactory psiFactory = JetPsiFactory(file);
         JetBinaryExpressionWithTypeRHS castedExpression =
                 (JetBinaryExpressionWithTypeRHS) psiFactory.createExpression("(" + element.getText() + ") as " + renderedType);
         if (JetPsiUtil.areParenthesesUseless((JetParenthesizedExpression) castedExpression.getLeft())) {

idea/src/org/jetbrains/jet/plugin/quickfix/ChangeAccessorTypeFix.java

@@ -67,7 +67,7 @@ public class ChangeAccessorTypeFix extends JetIntentionAction<JetPropertyAccesso
     @Override
     public void invoke(@NotNull Project project, Editor editor, JetFile file) throws IncorrectOperationException {
         JetPropertyAccessor newElement = (JetPropertyAccessor) element.copy();
-        JetTypeReference newTypeReference = JetPsiFactory(project).createType(renderedType);
+        JetTypeReference newTypeReference = JetPsiFactory(file).createType(renderedType);
 
         if (element.isGetter()) {
             JetTypeReference returnTypeReference = newElement.getReturnTypeReference();

idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionLiteralReturnTypeFix.java

@@ -120,7 +120,7 @@ public class ChangeFunctionLiteralReturnTypeFix extends JetIntentionAction<JetFu
     @Override
     public void invoke(@NotNull Project project, Editor editor, JetFile file) throws IncorrectOperationException {
         if (functionLiteralReturnTypeRef != null) {
-            functionLiteralReturnTypeRef.replace(JetPsiFactory(project).createType(renderedType));
+            functionLiteralReturnTypeRef.replace(JetPsiFactory(file).createType(renderedType));
         }
         if (appropriateQuickFix != null && appropriateQuickFix.isAvailable(project, editor, file)) {
             appropriateQuickFix.invoke(project, editor, file);

idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionReturnTypeFix.java

@@ -110,12 +110,12 @@ public class ChangeFunctionReturnTypeFix extends JetIntentionAction<JetFunction>
         else {
             SpecifyTypeExplicitlyAction.removeTypeAnnotation(element);
             if (!(KotlinBuiltIns.getInstance().isUnit(type) && element.hasBlockBody())) {
-                addReturnTypeAnnotation(project, element, renderedType);
+                addReturnTypeAnnotation(element, renderedType);
             }
         }
     }
 
-    public static void addReturnTypeAnnotation(Project project, JetFunction function, String typeText) {
+    public static void addReturnTypeAnnotation(JetFunction function, String typeText) {
         PsiElement elementToPrecedeType = function.getValueParameterList();
         if (elementToPrecedeType == null) elementToPrecedeType = function.getNameIdentifier();
         assert elementToPrecedeType != null : "Return type of function without name can't mismatch anything";
@@ -123,7 +123,7 @@ public class ChangeFunctionReturnTypeFix extends JetIntentionAction<JetFunction>
             // if a function doesn't have a value parameter list, a syntax error is raised, and it should follow the function name
             elementToPrecedeType = elementToPrecedeType.getNextSibling();
         }
-        JetPsiFactory psiFactory = JetPsiFactory(project);
+        JetPsiFactory psiFactory = JetPsiFactory(function);
         function.addAfter(psiFactory.createType(typeText), elementToPrecedeType);
         function.addAfter(psiFactory.createColon(), elementToPrecedeType);
     }

idea/src/org/jetbrains/jet/plugin/quickfix/ChangeParameterTypeFix.java

@@ -67,6 +67,6 @@ public class ChangeParameterTypeFix extends JetIntentionAction<JetParameter> {
     public void invoke(@NotNull Project project, Editor editor, JetFile file) throws IncorrectOperationException {
         JetTypeReference typeReference = element.getTypeReference();
         assert typeReference != null : "Parameter without type annotation cannot cause type mismatch";
-        typeReference.replace(JetPsiFactory(project).createType(renderedType));
+        typeReference.replace(JetPsiFactory(file).createType(renderedType));
     }
 }

idea/src/org/jetbrains/jet/plugin/quickfix/ChangeToBackingFieldFix.java

@@ -46,7 +46,7 @@ public class ChangeToBackingFieldFix extends JetIntentionAction<JetSimpleNameExp
 
     @Override
     public void invoke(@NotNull Project project, Editor editor, JetFile file) throws IncorrectOperationException {
-        JetSimpleNameExpression backingField = (JetSimpleNameExpression) JetPsiFactory(project).createExpression("$" + element.getText());
+        JetSimpleNameExpression backingField = (JetSimpleNameExpression) JetPsiFactory(file).createExpression("$" + element.getText());
         element.replace(backingField);
     }
 

idea/src/org/jetbrains/jet/plugin/quickfix/ChangeToConstructorInvocationFix.java

@@ -79,7 +79,7 @@ public class ChangeToConstructorInvocationFix extends JetIntentionAction<JetDele
     @Override
     public void invoke(@NotNull Project project, Editor editor, JetFile file) throws IncorrectOperationException {
         JetDelegatorToSuperClass delegator = (JetDelegatorToSuperClass) element.copy();
-        JetClass aClass = JetPsiFactory(project).createClass("class A : " + delegator.getText() + "()");
+        JetClass aClass = JetPsiFactory(file).createClass("class A : " + delegator.getText() + "()");
         List<JetDelegationSpecifier> delegationSpecifiers = aClass.getDelegationSpecifiers();
         assert delegationSpecifiers.size() == 1;
         JetDelegationSpecifier specifier = delegationSpecifiers.iterator().next();

idea/src/org/jetbrains/jet/plugin/quickfix/ChangeToFunctionInvocationFix.java

@@ -48,7 +48,7 @@ public class ChangeToFunctionInvocationFix extends JetIntentionAction<JetExpress
     @Override
     public void invoke(@NotNull Project project, Editor editor, JetFile file) throws IncorrectOperationException {
         JetExpression reference = (JetExpression) element.copy();
-        element.replace(JetPsiFactory(project).createExpression(reference.getText() + "()"));
+        element.replace(JetPsiFactory(file).createExpression(reference.getText() + "()"));
     }
 
     public static JetSingleIntentionActionFactory createFactory() {

idea/src/org/jetbrains/jet/plugin/quickfix/ChangeToPropertyNameFix.java

@@ -55,7 +55,7 @@ public class ChangeToPropertyNameFix extends JetIntentionAction<JetSimpleNameExp
 
     @Override
     public void invoke(@NotNull Project project, Editor editor, JetFile file) throws IncorrectOperationException {
-        JetSimpleNameExpression propertyName = (JetSimpleNameExpression) JetPsiFactory(project).createExpression(getPropertyName());
+        JetSimpleNameExpression propertyName = (JetSimpleNameExpression) JetPsiFactory(file).createExpression(getPropertyName());
         element.replace(propertyName);
     }
 

idea/src/org/jetbrains/jet/plugin/quickfix/ChangeToStarProjectionFix.java

@@ -53,7 +53,7 @@ public class ChangeToStarProjectionFix extends JetIntentionAction<JetTypeElement
     public void invoke(@NotNull Project project, Editor editor, JetFile file) throws IncorrectOperationException {
         for (JetTypeReference typeReference : element.getTypeArgumentsAsTypes()) {
             if (typeReference != null) {
-                typeReference.replace(JetPsiFactory(project).createStar());
+                typeReference.replace(JetPsiFactory(file).createStar());
             }
         }
     }

idea/src/org/jetbrains/jet/plugin/quickfix/ChangeTypeFix.java

@@ -56,7 +56,7 @@ public class ChangeTypeFix extends JetIntentionAction<JetTypeReference> {
 
     @Override
     public void invoke(@NotNull Project project, Editor editor, JetFile file) throws IncorrectOperationException {
-        element.replace(JetPsiFactory(project).createType(renderedType));
+        element.replace(JetPsiFactory(file).createType(renderedType));
     }
 
     @NotNull

idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVariableMutabilityFix.java

@@ -88,7 +88,7 @@ public class ChangeVariableMutabilityFix implements IntentionAction {
     public void invoke(@NotNull Project project, Editor editor, PsiFile file) throws IncorrectOperationException {
         JetProperty property = getCorrespondingProperty(editor, (JetFile)file);
         assert property != null;
-        property.getValOrVarNode().getPsi().replace(JetPsiFactory(project).createValOrVarNode(isVar ? "val" : "var").getPsi());
+        property.getValOrVarNode().getPsi().replace(JetPsiFactory(property).createValOrVarNode(isVar ? "val" : "var").getPsi());
     }
 
     @Override

idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVariableTypeFix.java

@@ -83,7 +83,7 @@ public class ChangeVariableTypeFix extends JetIntentionAction<JetVariableDeclara
         SpecifyTypeExplicitlyAction.removeTypeAnnotation(element);
         PsiElement nameIdentifier = element.getNameIdentifier();
         assert nameIdentifier != null : "ChangeVariableTypeFix applied to variable without name";
-        JetPsiFactory psiFactory = PsiPackage.JetPsiFactory(project);
+        JetPsiFactory psiFactory = PsiPackage.JetPsiFactory(file);
         element.addAfter(psiFactory.createType(renderedType), nameIdentifier);
         element.addAfter(psiFactory.createColon(), nameIdentifier);
 

idea/src/org/jetbrains/jet/plugin/quickfix/CreateFunctionFromUsageFix.kt

@@ -620,10 +620,9 @@ public class CreateFunctionFromUsageFix internal (
     }
 
     private fun createFunctionSkeleton(): JetNamedFunction {
-        val project = currentFile.getProject()
         val parametersString = parameters.indices.map { i -> "p$i: Any" }.makeString(", ")
         val returnTypeString = if (isUnit) "" else ": Any"
-        val psiFactory = JetPsiFactory(project)
+        val psiFactory = JetPsiFactory(currentFile)
         if (isExtension) {
             // create as extension function
             val ownerTypeString = selectedReceiverType.renderedType!!
@@ -638,7 +637,7 @@ public class CreateFunctionFromUsageFix internal (
             containingFile = ownerClass.getContainingJetFile()
 
             NavigationUtil.activateFileWithPsiElement(containingFile)
-            containingFileEditor = FileEditorManager.getInstance(project)!!.getSelectedTextEditor()!!
+            containingFileEditor = FileEditorManager.getInstance(currentFile.getProject())!!.getSelectedTextEditor()!!
 
             var classBody = ownerClass.getBody()
             if (classBody == null) {
@@ -738,7 +737,7 @@ public class CreateFunctionFromUsageFix internal (
             typeRefsToShorten: MutableList<JetTypeReference>, parameterTypeExpressions: List<TypeExpression>,
             returnTypeExpression: TypeExpression?) {
         if (isExtension) {
-            val receiverTypeRef = JetPsiFactory(func.getProject()).createType(selectedReceiverType.theType.renderLong(typeParameterNameMap))
+            val receiverTypeRef = JetPsiFactory(func).createType(selectedReceiverType.theType.renderLong(typeParameterNameMap))
             replaceWithLongerName(receiverTypeRef, selectedReceiverType.theType)
 
             val funcReceiverTypeRef = func.getReceiverTypeRef()
@@ -799,7 +798,7 @@ public class CreateFunctionFromUsageFix internal (
             throw IncorrectOperationException("Failed to parse file template", e)
         }
 
-        val newBodyExpression = JetPsiFactory(func.getProject()).createFunctionBody(bodyText)
+        val newBodyExpression = JetPsiFactory(func).createFunctionBody(bodyText)
         func.getBodyExpression()!!.replace(newBodyExpression)
     }
 
@@ -867,8 +866,7 @@ public class CreateFunctionFromUsageFix internal (
     }
 
     private fun replaceWithLongerName(typeRef: JetTypeReference, theType: JetType) {
-        val project = typeRef.getProject()
-        val fullyQualifiedReceiverTypeRef = JetPsiFactory(project).createType(theType.renderLong(typeParameterNameMap))
+        val fullyQualifiedReceiverTypeRef = JetPsiFactory(typeRef).createType(theType.renderLong(typeParameterNameMap))
         typeRef.replace(fullyQualifiedReceiverTypeRef)
     }
 

idea/src/org/jetbrains/jet/plugin/quickfix/KotlinSuppressIntentionAction.kt

@@ -53,14 +53,13 @@ public class KotlinSuppressIntentionAction(
     }
 
     private fun suppressAtModifierListOwner(suppressAt: JetModifierListOwner, id: String) {
-        val project = suppressAt.getProject()
         val modifierList = suppressAt.getModifierList()
-        val psiFactory = JetPsiFactory(project)
+        val psiFactory = JetPsiFactory(suppressAt)
         if (modifierList == null) {
             // create a modifier list from scratch
             val newModifierList = psiFactory.createModifierList(suppressAnnotationText(id))
             val replaced = JetPsiUtil.replaceModifierList(suppressAt, newModifierList)
-            val whiteSpace = project.createWhiteSpace(kind)
+            val whiteSpace = psiFactory.createWhiteSpace(kind)
             suppressAt.addAfter(whiteSpace, replaced)
         }
         else {
@@ -69,7 +68,7 @@ public class KotlinSuppressIntentionAction(
                 // no [suppress] annotation
                 val newAnnotation = psiFactory.createAnnotation(suppressAnnotationText(id))
                 val addedAnnotation = modifierList.addBefore(newAnnotation, modifierList.getFirstChild())
-                val whiteSpace = project.createWhiteSpace(kind)
+                val whiteSpace = psiFactory.createWhiteSpace(kind)
                 modifierList.addAfter(whiteSpace, addedAnnotation)
             }
             else {
@@ -94,12 +93,10 @@ public class KotlinSuppressIntentionAction(
         val suppressAt = caretBox.expression
         assert(suppressAt !is JetDeclaration, "Declarations should have been checked for above")
 
-        val project = suppressAt.getProject()
-
         val parentheses = JetPsiPrecedences.getPrecedence(suppressAt) > JetPsiPrecedences.PRECEDENCE_OF_PREFIX_EXPRESSION
         val placeholderText = "PLACEHOLDER_ID"
         val inner = if (parentheses) "($placeholderText)" else placeholderText
-        val annotatedExpression = JetPsiFactory(project).createExpression(suppressAnnotationText(id) + "\n" + inner)
+        val annotatedExpression = JetPsiFactory(suppressAt).createExpression(suppressAnnotationText(id) + "\n" + inner)
 
         val copy = suppressAt.copy()!!
 
@@ -112,11 +109,9 @@ public class KotlinSuppressIntentionAction(
     }
 
     private fun addArgumentToSuppressAnnotation(entry: JetAnnotationEntry, id: String) {
-        val project = entry.getProject()
-
         // add new arguments to an existing entry
         val args = entry.getValueArgumentList()
-        val psiFactory = JetPsiFactory(project)
+        val psiFactory = JetPsiFactory(entry)
         val newArgList = psiFactory.createCallArguments("($id)")
         if (args == null) {
             // new argument list
@@ -149,9 +144,9 @@ public class KotlinSuppressIntentionAction(
 }
 
 public class AnnotationHostKind(val kind: String, val name: String, val newLineNeeded: Boolean)
-private fun Project.createWhiteSpace(kind: AnnotationHostKind): PsiElement {
-    val psiFactory = JetPsiFactory(this)
-    return if (kind.newLineNeeded) psiFactory.createNewLine() else psiFactory.createWhiteSpace()
+
+private fun JetPsiFactory.createWhiteSpace(kind: AnnotationHostKind): PsiElement {
+    return if (kind.newLineNeeded) createNewLine() else createWhiteSpace()
 }
 
 private class CaretBox<out E: JetExpression>(

idea/src/org/jetbrains/jet/plugin/quickfix/MoveWhenElseBranchFix.java

@@ -73,7 +73,7 @@ public class MoveWhenElseBranchFix extends JetIntentionAction<JetWhenExpression>
         int cursorOffset = editor.getCaretModel().getOffset() - elseEntry.getTextOffset();
 
         PsiElement insertedBranch = element.addAfter(elseEntry, lastEntry);
-        element.addAfter(JetPsiFactory(project).createNewLine(), lastEntry);
+        element.addAfter(JetPsiFactory(file).createNewLine(), lastEntry);
         element.deleteChildRange(elseEntry, elseEntry);
         JetWhenEntry insertedWhenEntry = (JetWhenEntry) CodeInsightUtilBase.forcePsiPostprocessAndRestoreElement(insertedBranch);
 

idea/src/org/jetbrains/jet/plugin/quickfix/ReplaceCallFix.java

@@ -77,7 +77,7 @@ public class ReplaceCallFix implements IntentionAction {
 
         JetExpression selector = callExpression.getSelectorExpression();
         if (selector != null) {
-            JetQualifiedExpression newElement = (JetQualifiedExpression) JetPsiFactory(project).createExpression(
+            JetQualifiedExpression newElement = (JetQualifiedExpression) JetPsiFactory(callExpression).createExpression(
                     callExpression.getReceiverExpression().getText() + (toSafe ? "?." : ".") + selector.getText()
             );
 

idea/src/org/jetbrains/jet/plugin/quickfix/ReplaceInfixCallFix.java

@@ -54,7 +54,7 @@ public class ReplaceInfixCallFix extends JetIntentionAction<JetBinaryExpression>
         assert left != null && right != null : "Preconditions checked by factory";
         String newText = left.getText() + "?." + element.getOperationReference().getText()
                          + "(" + right.getText() + ")";
-        JetQualifiedExpression newElement = (JetQualifiedExpression) JetPsiFactory(project).createExpression(newText);
+        JetQualifiedExpression newElement = (JetQualifiedExpression) JetPsiFactory(file).createExpression(newText);
         element.replace(newElement);
     }
 

idea/src/org/jetbrains/jet/plugin/quickfix/ReplaceOperationInBinaryExpressionFix.java

@@ -44,7 +44,7 @@ public abstract class ReplaceOperationInBinaryExpressionFix<T extends JetExpress
             JetExpression left = ((JetBinaryExpressionWithTypeRHS) element).getLeft();
             JetTypeReference right = ((JetBinaryExpressionWithTypeRHS) element).getRight();
             if (right != null) {
-                JetExpression expression = PsiPackage.JetPsiFactory(project).createExpression(left.getText() + operation + right.getText());
+                JetExpression expression = PsiPackage.JetPsiFactory(file).createExpression(left.getText() + operation + right.getText());
                 element.replace(expression);
             }
         }

idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/usages/JetFunctionDefinitionUsage.java

@@ -64,7 +64,7 @@ public class JetFunctionDefinitionUsage extends JetUsageInfo<PsiElement> {
 
                 //TODO use ChangeFunctionReturnTypeFix.invoke when JetTypeCodeFragment.getType() is ready
                 if (!KotlinBuiltIns.getInstance().getUnitType().toString().equals(returnTypeText))
-                    ChangeFunctionReturnTypeFix.addReturnTypeAnnotation(getProject(), function, returnTypeText);
+                    ChangeFunctionReturnTypeFix.addReturnTypeAnnotation(function, returnTypeText);
             }
         }
         else

idea/src/org/jetbrains/jet/plugin/refactoring/extractFunction/ExtractionData.kt

@@ -103,7 +103,7 @@ class ExtractionData(
 
     val originalStartOffset = originalElements.first?.let { e -> e.getTextRange()!!.getStartOffset() }
 
-    private val itFakeDeclaration by Delegates.lazy { JetPsiFactory(project).createParameter("it", "Any?") }
+    private val itFakeDeclaration by Delegates.lazy { JetPsiFactory(originalFile).createParameter("it", "Any?") }
 
     val refOffsetToDeclaration by Delegates.lazy {
         fun isExtractableIt(descriptor: DeclarationDescriptor, context: BindingContext): Boolean {

idea/src/org/jetbrains/jet/plugin/refactoring/extractFunction/ExtractionDescriptor.kt

@@ -71,7 +71,7 @@ class RenameReplacement(override val parameter: Parameter): ParameterReplacement
     [suppress("PARAMETER_NAME_CHANGED_ON_OVERRIDE")]
     override fun invoke(e: JetElement): JetElement {
         val thisExpr = e.getParent() as? JetThisExpression
-        return (thisExpr ?: e).replaced(JetPsiFactory(e.getProject()).createSimpleName(parameter.nameForRef))
+        return (thisExpr ?: e).replaced(JetPsiFactory(e).createSimpleName(parameter.nameForRef))
     }
 }
 
@@ -81,8 +81,7 @@ class AddPrefixReplacement(override val parameter: Parameter): ParameterReplacem
     [suppress("PARAMETER_NAME_CHANGED_ON_OVERRIDE")]
     override fun invoke(e: JetElement): JetElement {
         val selector = (e.getParent() as? JetCallExpression) ?: e
-        val newExpr = selector.replace(
-                JetPsiFactory(e.getProject()).createExpression("${parameter.nameForRef}.${selector.getText()}")
+        val newExpr = selector.replace(JetPsiFactory(e).createExpression("${parameter.nameForRef}.${selector.getText()}")
         ) as JetQualifiedExpression
 
         return with(newExpr.getSelectorExpression()!!) { if (this is JetCallExpression) getCalleeExpression()!! else this }

idea/src/org/jetbrains/jet/plugin/refactoring/extractFunction/extractFunctionUtils.kt

@@ -797,9 +797,7 @@ fun ExtractionDescriptor.generateFunction(
         inTempFile: Boolean = false,
         nameByOffset: MutableMap<Int, JetElement> = HashMap()
 ): JetNamedFunction {
-    val project = extractionData.project
-
-    val psiFactory = JetPsiFactory(project)
+    val psiFactory = JetPsiFactory(extractionData.originalFile)
     fun createFunction(): JetNamedFunction {
         return with(extractionData) {
             if (inTempFile) {

idea/src/org/jetbrains/jet/plugin/refactoring/inline/KotlinInlineValHandler.java

@@ -271,7 +271,7 @@ public class KotlinInlineValHandler extends InlineActionHandler {
             }
         }
 
-        JetPsiFactory psiFactory = JetPsiFactory(containingFile.getProject());
+        JetPsiFactory psiFactory = JetPsiFactory(containingFile);
         for (JetFunctionLiteralExpression functionLiteralExpression : functionsToAddParameters) {
             JetFunctionLiteral functionLiteral = functionLiteralExpression.getFunctionLiteral();
 
@@ -334,7 +334,7 @@ public class KotlinInlineValHandler extends InlineActionHandler {
             }
         }
 
-        JetPsiFactory psiFactory = JetPsiFactory(containingFile.getProject());
+        JetPsiFactory psiFactory = JetPsiFactory(containingFile);
         for (JetCallExpression call : callsToAddArguments) {
             call.addAfter(psiFactory.createTypeArguments("<" + typeArguments + ">"), call.getCalleeExpression());
             ShortenReferences.instance$.process(call.getTypeArgumentList());
@@ -379,11 +379,12 @@ public class KotlinInlineValHandler extends InlineActionHandler {
             @NotNull PsiElement referenceElement,
             @NotNull JetExpression newExpression
     ) {
-        if (referenceElement.getParent() instanceof JetSimpleNameStringTemplateEntry &&
+        PsiElement parent = referenceElement.getParent();
+        if (parent instanceof JetSimpleNameStringTemplateEntry &&
             !(newExpression instanceof JetSimpleNameExpression)) {
             JetBlockStringTemplateEntry templateEntry =
-                    (JetBlockStringTemplateEntry) referenceElement.getParent().replace(
-                            JetPsiFactory(referenceElement.getProject()).createBlockStringTemplateEntry(newExpression));
+                    (JetBlockStringTemplateEntry) parent.replace(
+                            JetPsiFactory((JetElement) parent).createBlockStringTemplateEntry(newExpression));
             JetExpression expression = templateEntry.getExpression();
             assert expression != null;
             return expression;